API Usage Examples

// Set up API base configuration
const API_BASE_URL = 'https://api.leafmove.com';
const API_TOKEN = 'your-api-token';

// Create request headers
const headers = {
  'Authorization': `Bearer ${API_TOKEN}`,
  'Content-Type': 'application/json'
};

// Get document list
async function getDocuments() {
  try {
    const response = await fetch(`${API_BASE_URL}/api/documents`, {
      method: 'GET',
      headers: headers
    });
    
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    
    const data = await response.json();
    return data;
  } catch (error) {
    console.error('Failed to get documents:', error);
    throw error;
  }
}

// Create new document
async function createDocument(documentData) {
  try {
    const response = await fetch(`${API_BASE_URL}/api/documents`, {
      method: 'POST',
      headers: headers,
      body: JSON.stringify(documentData)
    });
    
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    
    const data = await response.json();
    return data;
  } catch (error) {
    console.error('Failed to create document:', error);
    throw error;
  }
}

// Usage example
const newDocument = {
  title: 'Getting Started Guide',
  content: '# Welcome to our documentation...',
  category: 'guide'
};

createDocument(newDocument)
  .then(doc => console.log('Document created:', doc))
  .catch(error => console.error('Creation failed:', error));

// Batch create documents
async function batchCreateDocuments(documents) {
  const results = [];
  
  for (const doc of documents) {
    try {
      const result = await createDocument(doc);
      results.push({ success: true, data: result });
    } catch (error) {
      results.push({ success: false, error: error.message });
    }
  }
  
  return results;
}

// Unified error handling
class APIClient {
  constructor(baseURL, token) {
    this.baseURL = baseURL;
    this.token = token;
  }
  
  async request(endpoint, options = {}) {
    const url = `${this.baseURL}${endpoint}`;
    const config = {
      headers: {
        'Authorization': `Bearer ${this.token}`,
        'Content-Type': 'application/json',
        ...options.headers
      },
      ...options
    };
    
    try {
      const response = await fetch(url, config);
      
      if (!response.ok) {
        const errorData = await response.json();
        throw new APIError(response.status, errorData.message, errorData);
      }
      
      return await response.json();
    } catch (error) {
      if (error instanceof APIError) {
        throw error;
      }
      throw new APIError(0, 'Network request failed', { originalError: error });
    }
  }
}

// Custom error class
class APIError extends Error {
  constructor(status, message, data) {
    super(message);
    this.name = 'APIError';
    this.status = status;
    this.data = data;
  }
}

// Simple text search
async function searchDocuments(query) {
  const response = await fetch(`${API_BASE_URL}/api/search?q=${encodeURIComponent(query)}`, {
    headers: headers
  });
  
  return await response.json();
}

// Usage
searchDocuments('getting started')
  .then(results => console.log('Search results:', results))
  .catch(error => console.error('Search failed:', error));

// Advanced search with filters
async function advancedSearch(searchParams) {
  const response = await fetch(`${API_BASE_URL}/api/search/advanced`, {
    method: 'POST',
    headers: headers,
    body: JSON.stringify(searchParams)
  });
  
  return await response.json();
}

// Usage example
const searchParams = {
  query: 'API documentation',
  filters: {
    category: ['guide', 'api'],
    tags: ['beginner'],
    dateRange: {
      start: '2024-01-01',
      end: '2024-12-31'
    }
  },
  sort: 'relevance',
  limit: 20
};

advancedSearch(searchParams)
  .then(results => console.log('Advanced search results:', results));

// Add request logging
class LoggingAPIClient extends APIClient {
  async request(endpoint, options = {}) {
    console.log(`[API] ${options.method || 'GET'} ${endpoint}`);
    console.log('[API] Request params:', options.body);
    
    const startTime = Date.now();
    
    try {
      const result = await super.request(endpoint, options);
      const duration = Date.now() - startTime;
      
      console.log(`[API] Request successful (${duration}ms)`);
      console.log('[API] Response data:', result);
      
      return result;
    } catch (error) {
      const duration = Date.now() - startTime;
      
      console.error(`[API] Request failed (${duration}ms):`, error);
      throw error;
    }
  }
}

// Jest testing example
describe('API Client', () => {
  let client;
  
  beforeEach(() => {
    client = new APIClient('https://api.leafmove.com', 'test-token');
  });
  
  test('should get document list', async () => {
    // Mock fetch
    global.fetch = jest.fn().mockResolvedValue({
      ok: true,
      json: () => Promise.resolve({
        code: 200,
        data: {
          documents: [
            { id: 1, title: 'Test Document', content: 'Test content' }
          ]
        }
      })
    });
    
    const result = await client.request('/api/documents');
    
    expect(result.code).toBe(200);
    expect(result.data.documents).toHaveLength(1);
    expect(fetch).toHaveBeenCalledWith(
      'https://api.leafmove.com/api/documents',
      expect.objectContaining({
        headers: expect.objectContaining({
          'Authorization': 'Bearer test-token'
        })
      })
    );
  });
});