Pagination - SDK JavaScript

interface SBListResponse<T> {
  data: T[];                // Tableau des éléments de la page courante
  pagination: SBPagination; // Metadonnées de pagination
}

interface SBPagination {
  count: number;                       // Nombre total d'éléments sur toutes les pages
  limit: number;                       // Nombre d'éléments par page
  currentPage: number;                 // Numéro de page actuel (base 1)
  pageCount: number;                   // Nombre total de pages
  filters?: Record<string, unknown>;   // Filtres appliqués
  sorts?: Record<string, string>;      // Critères de tri appliqués
}

const response = await client.expenses.listBusiness({
  page: 1,
  limit: 25,
});

console.log(`Éléments : ${response.data.length}`);
console.log(`Total : ${response.pagination.count}`);
console.log(`Page : ${response.pagination.currentPage} sur ${response.pagination.pageCount}`);

interface PaginationRequest {
  page?: number;                    // Numéro de page (base 1, défaut : 1)
  limit?: number;                   // Éléments par page
  sortBy?: string;                  // Champ de tri
  sortDirection?: 'asc' | 'desc';  // Ordre de tri
}

const { data: expenses } = await client.expenses.listBusiness({
  page: 1,
  limit: 50,
  sortBy: 'createdAt',
  sortDirection: 'desc',
});

async function obtenirToutesDepenses() {
  const toutesDepenses = [];
  let pageCourante = 1;
  let encore = true;

  while (encore) {
    const { data, pagination } = await client.expenses.listBusiness({
      page: pageCourante,
      limit: 100,
    });

    toutesDepenses.push(...data);
    encore = pageCourante < pagination.pageCount;
    pageCourante++;
  }

  return toutesDepenses;
}

async function recupererToutesPages<T>(
  fetcher: (params: { page: number; limit: number }) => Promise<SBListResponse<T>>,
  limit = 100
): Promise<T[]> {
  const tousElements: T[] = [];
  let page = 1;
  let totalPages = 1;

  do {
    const response = await fetcher({ page, limit });
    tousElements.push(...response.data);
    totalPages = response.pagination.pageCount;
    page++;
  } while (page <= totalPages);

  return tousElements;
}

// Utilisation
const toutesDepenses = await recupererToutesPages(
  (params) => client.expenses.listBusiness(params)
);

const tousFournisseurs = await recupererToutesPages(
  (params) => client.vendors.listBusiness(params)
);

async function* paginerDépenses(params?: Partial<ExpenseListRequest>) {
  let page = 1;
  let totalPages = 1;

  do {
    const response = await client.expenses.listBusiness({
      ...params,
      page,
      limit: params?.limit ?? 100,
    });

    for (const expense of response.data) {
      yield expense;
    }

    totalPages = response.pagination.pageCount;
    page++;
  } while (page <= totalPages);
}

// Traiter les dépenses une par une sans tout charger en memoire
for await (const expense of paginerDépenses({ sortBy: 'amount' })) {
  console.log(expense.id, expense.amount);
}

const { pagination } = await client.expenses.listBusiness({
  page: 1,
  limit: 20,
});

const aPageSuivante = pagination.currentPage < pagination.pageCount;
const aPagePrécédente = pagination.currentPage > 1;

console.log(`Page suivante : ${aPageSuivante}`);
console.log(`Page précédente : ${aPagePrécédente}`);

const { data, pagination } = await client.expenses.listBusiness({
  page: 1,
  limit: 25,
});

// pagination.count reflete le total correspondant au filtre
console.log(`${pagination.count} dépenses correspondantes`);