API Endpoints for JSON Datasets

// Basic fetch request
async function fetchEmployees() {
  try {
    const response = await fetch('https://api.jsons.live/employees/5-level/10-KB/formatted');
    
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    
    const data = await response.json();
    
    console.log('✅ Success!');
    console.log('Total records:', data.total);
    console.log('Current page:', data.page);
    console.log('Records returned:', data.count);
    console.log('First employee:', data.data[0]);
    
    return data;
  } catch (error) {
    console.error('❌ Error fetching data:', error.message);
  }
}

// Execute
fetchEmployees();

const response = await fetch(
  "https://apis.jsons.live/j975p/formatted",
  {
    method: "POST",
    headers: {
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      OrderID: "ORD000005",
      name: "MTJ"
    })
  }
);

const data = await response.json();
console.log(data);

const response = await fetch(
  "https://apis.jsons.live/j975p/formatted",
  {
    method: "PATCH",
    headers: {
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      matchKey: "OrderID",
      matchValue: "ORD0000002",
      data: {
        CustomerName: "jat li"
      }
    })
  }
);

const data = await response.json();
console.log(data);

const response = await fetch(
  "https://apis.jsons.live/j975p/formatted",
  {
    method: "DELETE",
    headers: {
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      matchKey: "OrderID",
      matchValue: "ORD0000001"
    })
  }
);

const data = await response.json();
console.log(data);

// Filter by exact name match
async function filterByName(name) {
  const response = await fetch(
    `https://api.jsons.live/employees/5-level/10-KB/formatted?name=${encodeURIComponent(name)}`
  );
  const data = await response.json();
  
  console.log(`Found ${data.count} employees named "${name}"`);
  data.data.forEach(emp => {
    console.log(`  - ${emp.employee.name} (${emp.employee.position})`);
  });
}

filterByName('Jodi Reyes');

// Filter with multiple conditions
async function filterMultiple() {
  const params = new URLSearchParams({
    'employee.department.name': 'Engineering',
    'employee.position': 'Senior Developer',
    'sort': '-employee.name'
  });
  
  const response = await fetch(
    `https://api.jsons.live/employees/5-level/10-KB/formatted?${params}`
  );
  const data = await response.json();
  
  console.log(`Found ${data.count} senior developers in Engineering`);
  data.data.forEach(emp => {
    console.log(`  - ${emp.employee.name}`);
  });
}

filterMultiple();

// Filter using dot notation for nested fields
async function filterByManager(email) {
  const response = await fetch(
    `https://api.jsons.live/employees/5-level/10-KB/formatted?employee.department.manager.contact.email=${email}`
  );
  const data = await response.json();
  
  console.log(`Employees under manager with email ${email}:`);
  data.data.forEach(emp => {
    const manager = emp.employee.department.manager;
    console.log(`  - ${emp.employee.name} (Manager: ${manager.name})`);
  });
}

filterByManager('eodom@example.net');

// Sort ascending (A-Z)
async function sortAscending() {
  const response = await fetch(
    'https://api.jsons.live/employees/5-level/10-KB/formatted?sort=employee.name'
  );
  const data = await response.json();
  
  console.log('Employees sorted A-Z:');
  data.data.forEach((emp, i) => {
    console.log(`  ${i + 1}. ${emp.employee.name}`);
  });
}

// Sort descending (Z-A)
async function sortDescending() {
  const response = await fetch(
    'https://api.jsons.live/employees/5-level/10-KB/formatted?sort=-employee.name'
  );
  const data = await response.json();
  
  console.log('Employees sorted Z-A:');
  data.data.forEach((emp, i) => {
    console.log(`  ${i + 1}. ${emp.employee.name}`);
  });
}

sortAscending();
sortDescending();

// Sort by multiple fields
async function multiFieldSort() {
  const response = await fetch(
    'https://api.jsons.live/employees/5-level/10-KB/formatted?sort=employee.department.name,-employee.position'
  );
  const data = await response.json();
  
  console.log('Employees sorted by department (A-Z) and position (Z-A):');
  data.data.forEach(emp => {
    console.log(`  ${emp.employee.department.name} - ${emp.employee.position} - ${emp.employee.name}`);
  });
}

multiFieldSort();

// Sort by aggregated values
async function sortByTotalHours() {
  const response = await fetch(
    'https://api.jsons.live/employees/5-level/10-KB/formatted?sort=employee.projects.tasks.details.hoursSpent:sum&limit=10'
  );
  const data = await response.json();
  
  console.log('Employees sorted by total hours worked:');
  data.data.forEach(emp => {
    // Calculate total hours for display
    let totalHours = 0;
    emp.employee.projects?.forEach(project => {
      project.tasks?.forEach(task => {
        totalHours += task.details?.hoursSpent || 0;
      });
    });
    console.log(`  ${emp.employee.name}: ${totalHours} hours`);
  });
}

sortByTotalHours();

// Fetch specific page with custom limit
async function getPage(page = 1, limit = 5) {
  const response = await fetch(
    `https://api.jsons.live/employees/5-level/10-KB/formatted?page=${page}&limit=${limit}`
  );
  const data = await response.json();
  
  console.log(`Page ${data.page} of ${Math.ceil(data.total / data.limit)}`);
  console.log(`Showing ${data.count} of ${data.total} records`);
  
  data.data.forEach(emp => {
    console.log(`  - ${emp.employee.name}`);
  });
  
  return data;
}

// Fetch first 3 pages
async function fetchMultiplePages() {
  for (let page = 1; page <= 3; page++) {
    console.log(`\n📄 Page ${page}:`);
    await getPage(page, 3);
  }
}

fetchMultiplePages();

// Simulate infinite scroll pagination
async function* paginateGenerator(limit = 5) {
  let page = 1;
  let hasMore = true;
  
  while (hasMore) {
    const response = await fetch(
      `https://api.jsons.live/employees/5-level/10-KB/formatted?page=${page}&limit=${limit}`
    );
    const data = await response.json();
    
    yield data;
    
    hasMore = data.page * data.limit < data.total;
    page++;
  }
}

// Usage
async function loadAllPages() {
  const generator = paginateGenerator(3);
  
  for await (const page of generator) {
    console.log(`📦 Page ${page.page}: ${page.count} items`);
    page.data.forEach(emp => {
      console.log(`    ${emp.employee.name}`);
    });
  }
}

loadAllPages();

// Select specific fields to reduce payload
async function selectFields() {
  // Get only id, name, and position
  const response = await fetch(
    'https://api.jsons.live/employees/5-level/10-KB/formatted?fields=employee.id,employee.name,employee.position&limit=5'
  );
  const data = await response.json();
  
  console.log('Selected fields only (reduced payload):');
  data.data.forEach(emp => {
    console.log(`  ID: ${emp.employee.id}`);
    console.log(`  Name: ${emp.employee.name}`);
    console.log(`  Position: ${emp.employee.position}`);
    console.log('  ---');
  });
  
  // Calculate size reduction
  const fullSize = JSON.stringify(data).length;
  console.log(`Response size: ${fullSize} bytes`);
}

selectFields();

// Use short field names (automatically mapped)
async function useAliases() {
  const response = await fetch(
    'https://api.jsons.live/employees/5-level/10-KB/formatted?fields=id,name,position&limit=5'
  );
  const data = await response.json();
  
  console.log('Using field aliases:');
  data.data.forEach(emp => {
    // Aliases automatically map to nested paths
    console.log(`  ${emp.id}: ${emp.name} - ${emp.position}`);
  });
}

useAliases();

// Full-featured API client class
class EmployeesAPI {
  constructor(baseURL = 'https://api.jsons.live/employees/5-level/10-KB/formatted') {
    this.baseURL = baseURL;
    this.cache = new Map();
  }

  async request(params = {}) {
    // Build URL with parameters
    const url = new URL(this.baseURL);
    Object.entries(params).forEach(([key, value]) => {
      if (value !== undefined && value !== null) {
        url.searchParams.append(key, value);
      }
    });

    // Check cache
    const cacheKey = url.toString();
    if (this.cache.has(cacheKey)) {
      console.log('📦 Returning cached response');
      return this.cache.get(cacheKey);
    }

    // Make request
    try {
      const response = await fetch(url);
      
      if (!response.ok) {
        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
      }
      
      const data = await response.json();
      
      // Cache for 5 minutes
      this.cache.set(cacheKey, data);
      setTimeout(() => this.cache.delete(cacheKey), 5 * 60 * 1000);
      
      return data;
    } catch (error) {
      console.error('❌ Request failed:', error);
      throw error;
    }
  }

  // Filter methods
  async findByName(name, options = {}) {
    return this.request({ 'employee.name': name, ...options });
  }

  async findByDepartment(department, options = {}) {
    return this.request({ 'employee.department.name': department, ...options });
  }

  async findByManager(email, options = {}) {
    return this.request({ 'employee.department.manager.contact.email': email, ...options });
  }

  // Sorting methods
  async getSorted(field, ascending = true, options = {}) {
    const sort = ascending ? field : `-${field}`;
    return this.request({ sort, ...options });
  }

  async getByTotalHours(options = {}) {
    return this.request({ 
      sort: 'employee.projects.tasks.details.hoursSpent:sum',
      ...options 
    });
  }

  // Pagination
  async getPage(page = 1, limit = 10, options = {}) {
    return this.request({ page, limit, ...options });
  }

  async getAllPages(options = {}) {
    const pages = [];
    let page = 1;
    let hasMore = true;

    while (hasMore) {
      const data = await this.getPage(page, 100, options);
      pages.push(...data.data);
      
      hasMore = data.page * data.limit < data.total;
      page++;
    }

    return pages;
  }

  // Field selection
  async selectFields(fields, options = {}) {
    const fieldsStr = Array.isArray(fields) ? fields.join(',') : fields;
    return this.request({ fields: fieldsStr, ...options });
  }

  // Schema
  async getSchema() {
    return this.request({ schema: 'true' });
  }

  // Utility methods
  async getStats() {
    const data = await this.request({ 
      fields: 'employee.id,employee.name,employee.projects',
      limit: 100 
    });

    const stats = {
      total: data.total,
      withProjects: 0,
      totalHours: 0,
      byDepartment: {}
    };

    data.data.forEach(item => {
      const emp = item.employee;
      const dept = emp.department?.name || 'Unknown';
      
      // Department count
      stats.byDepartment[dept] = (stats.byDepartment[dept] || 0) + 1;
      
      // Project stats
      if (emp.projects?.length) {
        stats.withProjects++;
        emp.projects.forEach(project => {
          project.tasks?.forEach(task => {
            stats.totalHours += task.details?.hoursSpent || 0;
          });
        });
      }
    });

    return stats;
  }
}

// Usage example
async function demonstrateAPI() {
  const api = new EmployeesAPI();

  // 1. Find by name
  console.log('🔍 Finding Jodi Reyes...');
  const jodi = await api.findByName('Jodi Reyes');
  console.log('Found:', jodi.data[0]?.employee.name);

  // 2. Get sorted engineers
  console.log('
📊 Engineering department sorted by name:');
  const engineers = await api.findByDepartment('Engineering', { 
    sort: 'employee.name',
    limit: 5 
  });
  engineers.data.forEach(emp => {
    console.log('  -', emp.employee.name);
  });

  // 3. Pagination example
  console.log('
📄 Page 2 of employees:');
  const page2 = await api.getPage(2, 3);
  page2.data.forEach(emp => {
    console.log('  -', emp.employee.name);
  });

  // 4. Get statistics
  console.log('
📊 Employee Statistics:');
  const stats = await api.getStats();
  console.log('Total employees:', stats.total);
  console.log('Employees with projects:', stats.withProjects);
  console.log('Total hours logged:', stats.totalHours);
  console.log('By department:', stats.byDepartment);
}

// Run the demonstration
demonstrateAPI().catch(console.error);