API Documentation

// Pseudocode for the section reference endpoint
async function getSectionByReference(reference) {
  // Normalize the reference
  const normalizedRef = normalizeReference(reference);
  
  // Check Redis cache
  const key = createCfrReferenceKey(normalizedRef); // Returns "cfr:ref:" + normalizedRef
  const cachedData = await redis.get(key);
  
  if (cachedData) {
    // Return the cached section data
    return JSON.parse(cachedData);
  }
  
  // If not in cache, query database
  const section = await database.getSectionByReference(normalizedRef);
  
  if (section) {
    // Update cache for future requests
    await redis.set(key, JSON.stringify({
      id: section.id,
      reference: normalizedRef,
      titleNumber: section.parts.titles.number,
      titleName: section.parts.titles.name,
      partNumber: section.parts.number,
      partName: section.parts.name,
      sectionNumber: section.number,
      sectionName: section.name,
      sectionText: section.regulation_text
    }));
  }
  
  return section;
}

// Pseudocode for searching CFR references
async function searchCfrReferences(query, limit = 50) {
  // Normalize the query
  const normalizedQuery = query.trim().toLowerCase();
  
  // Prepare match pattern for ZSCAN
  const matchPattern = "*" + normalizedQuery + "*";
  
  // Create a map to store unique results
  const resultsMap = new Map();
  
  // Get entries matching the pattern using ZSCAN
  let cursor = 0;
  
  do {
    // Scan the sorted set for matches
    const scanResult = await redis.zscan("cfr:search:index", cursor, {
      match: matchPattern,
      count: 100
    });
    
    cursor = scanResult[0];
    const matches = scanResult[1];
    
    // Process matches
    for (let i = 0; i < matches.length; i += 2) {
      const reference = matches[i];
      const key = "cfr:ref:" + reference;
      
      // Get the full data for this reference
      const data = await redis.get(key);
      
      if (data && resultsMap.size < limit) {
        const parsed = JSON.parse(data);
        resultsMap.set(parsed.id, parsed);
      }
    }
  } while (cursor !== 0 && resultsMap.size < limit);
  
  // Fall back to database if needed
  if (resultsMap.size === 0) {
    await databaseFallbackSearch(normalizedQuery, limit, resultsMap);
  }
  
  return Array.from(resultsMap.values()).slice(0, limit);
}

// Using fetch API
fetch('/api/ecfr/titles')
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.error('Error:', error));

// Using fetch API
fetch('/api/ecfr/parts?titleId=1')
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.error('Error:', error));

// Using fetch API
fetch('/api/ecfr/content/1')
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.error('Error:', error));

// Using fetch API
fetch('/api/ecfr/section/reference?reference=1 CFR 1.1')
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.error('Error:', error));

// Using fetch API
fetch('/api/ecfr/search?q=definitions&page=1&pageSize=10')
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.error('Error:', error));

// ecfr-client.js
class EcfrClient {
  constructor(baseUrl = '') {
    this.baseUrl = baseUrl;
  }

  async getAllTitles() {
    return this.get('/api/ecfr/titles');
  }

  async getPartsByTitle(titleId) {
    return this.get(`/api/ecfr/parts?titleId=${titleId}`);
  }

  async getSectionById(id) {
    return this.get(`/api/ecfr/content/${id}`);
  }

  async getSectionByReference(reference) {
    return this.get(`/api/ecfr/section/reference?reference=${encodeURIComponent(reference)}`);
  }

  async searchSections(query, page = 1, pageSize = 10) {
    return this.get(`/api/ecfr/search?q=${encodeURIComponent(query)}&page=${page}&pageSize=${pageSize}`);
  }

  async getBookmarks() {
    return this.get('/api/bookmarks');
  }

  async addBookmark(sectionId) {
    return this.post('/api/bookmarks', { sectionId });
  }

  async removeBookmark(sectionId) {
    return this.delete('/api/bookmarks', { sectionId });
  }

  async get(path) {
    const response = await fetch(`${this.baseUrl}${path}`);
    if (!response.ok) {
      throw new Error(`HTTP error ${response.status}`);
    }
    return response.json();
  }

  async post(path, data) {
    const response = await fetch(`${this.baseUrl}${path}`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(data)
    });
    if (!response.ok) {
      throw new Error(`HTTP error ${response.status}`);
    }
    return response.json();
  }

  async delete(path, data) {
    const response = await fetch(`${this.baseUrl}${path}`, {
      method: 'DELETE',
      headers: {
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(data)
    });
    if (!response.ok) {
      throw new Error(`HTTP error ${response.status}`);
    }
    return response.json();
  }
}

// Usage
const client = new EcfrClient();
client.getAllTitles()
  .then(data => console.log(data))
  .catch(error => console.error('Error:', error));