cenário do aplicativo:

suporta vários métodos de classificação:

...
• use ascendente ou descendente: https: // your-url? Sort [primeiro_name] = ascendente e classificação [last_name] = descending
• use 1 ou -1: https: // your-url? Sort [primeiro_name] = 1 & sort [last_name] = -1
• Esta função também suporta a classificação usando os campos sortby
e

: https: // your-url? SortOrder = desc & sortby = last_name ] Código TypeScript:

tipo isortorder = "ASC" | Interface de exportação ipaginationfields { página?: número; limite?: número; Sortby?: String |. Sortorder?: ISORTORDER | classificar?: registro ; } Interface de exportação iformatedpagination { Pule: Número; página: número; Limite: Número; classificar: {[chave: string]: 1 | -1}; } exportar const formatpagination = (paginação: ipaginationfields): iFormatedPagination => { const {limite = 10, página = 1, Sortby, Sortorder, Sort} = Paginação; const FormattedSort: {[chave: string]: 1 | -1} = {}; const normalizeorder = (ordem: string | número): 1 | -1 => { const numorder = número (ordem); if (! isnan (Numorder) && (numorder === 1 || numorder === -1)) retornará Numorder; return (ordem === "ASC" || Ordem === "Ascendente")? }; if (Sortby) { const SortbyArray = Array.isarray (Sortby)? const sTorderArray = Array.isarray (Sortorder)? SortByArray.ForEach ((campo, índice) => { formattedSort [Campo] = NormizeDorder (SortOrderArray [Index]); }); } if (classy && typeof sty === 'object' &&! Array.isArray (sort)) { Object.Entries (classy) .ForEach (([campo, ordem]) => { formattedSort [Campo] = NormizeDorder (Ordem); }); } if (! formattedsort.createTat) { formattedSort.createTat = -1; } retornar { Pule: (Página - 1) * Limite, Limite: Limite, página: página, classificar: formattedsort, }; };

type ISortOrder = "asc" | "desc" | "ascending" | "descending" | 1 | -1;

export interface IPaginationFields {
    page?: number;
    limit?: number;
    sortBy?: string | string[];
    sortOrder?: ISortOrder | ISortOrder[];
    sort?: Record;
}

export interface IFormatedPagination {
    skip: number;
    page: number;
    limit: number;
    sort: { [key: string]: 1 | -1 };
}

export const formatPagination = (pagination: IPaginationFields): IFormatedPagination => {
    const { limit = 10, page = 1, sortBy, sortOrder, sort } = pagination;

    const formattedSort: { [key: string]: 1 | -1 } = {};

    const normalizeOrder = (order: string | number): 1 | -1 => {
        const numOrder = Number(order);
        if (!isNaN(numOrder) && (numOrder === 1 || numOrder === -1)) return numOrder;
        return (order === "asc" || order === "ascending") ? 1 : -1;
    };

    if (sortBy) {
        const sortByArray = Array.isArray(sortBy) ? sortBy : [sortBy];
        const sortOrderArray = Array.isArray(sortOrder) ? sortOrder : [sortOrder];
        sortByArray.forEach((field, index) => {
            formattedSort[field] = normalizeOrder(sortOrderArray[index]);
        });
    }

    if (sort && typeof sort === 'object' && !Array.isArray(sort)) {
        Object.entries(sort).forEach(([field, order]) => {
            formattedSort[field] = normalizeOrder(order);
        });
    }

    if (!formattedSort.createdAt) {
        formattedSort.createdAt = -1;
    }

    return {
        skip: (page - 1) * limit,
        limit: limit,
        page: page,
        sort: formattedSort,
    };
};

const FormatPagination = (paginação) => { const {limite = 10, página = 1, Sortby, Sortorder, Sort} = Paginação; const formattedSort = {}; const normalizeDorder = (ordem) => { const numorder = número (ordem); if (! isnan (Numorder) && (numorder === 1 || numorder === -1)) retornará Numorder; return (ordem === "ASC" || Ordem === "Ascendente")? }; if (Sortby) { const SortbyArray = Array.isarray (Sortby)? const sTorderArray = Array.isarray (Sortorder)? SortByArray.ForEach ((campo, índice) => { formattedSort [Campo] = NormizeDorder (SortOrderArray [Index]); }); } if (classy && typeof sty === 'object' &&! Array.isArray (sort)) { Object.Entries (classy) .ForEach (([campo, ordem]) => { formattedSort [Campo] = NormizeDorder (Ordem); }); } if (! formattedsort.createTat) { formattedSort.createTat = -1; } retornar { Pule: (Página - 1) * Limite, Limite: Limite, página: página, classificar: formattedsort, }; };

const formatPagination = (pagination) => {
    const { limit = 10, page = 1, sortBy, sortOrder, sort } = pagination;

    const formattedSort = {};

    const normalizeOrder = (order) => {
        const numOrder = Number(order);
        if (!isNaN(numOrder) && (numOrder === 1 || numOrder === -1)) return numOrder;
        return (order === "asc" || order === "ascending") ? 1 : -1;
    };

    if (sortBy) {
        const sortByArray = Array.isArray(sortBy) ? sortBy : [sortBy];
        const sortOrderArray = Array.isArray(sortOrder) ? sortOrder : [sortOrder];
        sortByArray.forEach((field, index) => {
            formattedSort[field] = normalizeOrder(sortOrderArray[index]);
        });
    }

    if (sort && typeof sort === 'object' && !Array.isArray(sort)) {
        Object.entries(sort).forEach(([field, order]) => {
            formattedSort[field] = normalizeOrder(order);
        });
    }

    if (!formattedSort.createdAt) {
        formattedSort.createdAt = -1;
    }

    return {
        skip: (page - 1) * limit,
        limit: limit,
        page: page,
        sort: formattedSort,
    };
};

Este código define a interface para campos de paginação e classificação e uma função prática para formatar esses campos em estruturas adequadas para consultas de banco de dados ou outros casos de uso de paginação. Esse utilitário ajuda a padronizar o processo de paginação e classificação.

interface

ISorTorder : Valores possíveis representando a ordem de classificação: "ASC", "Desc", "ascendente", "descendente", 1, -1.

ipAginationFields : descreva a estrutura de entrada da paginação e classificação:

(opcional), limite (opcional), Sortby ] ]]]]]]]]) (Opcional), Sortorder (opcional), sort (opcional). iformatedPagination : descreva a estrutura de saída da paginação formatada:

, página , limit , Sort ]]]. formatPagination function

Esta função processa o objeto de paginação de entrada e o converte em um formato padronizado.

paginação

ipAginationFields
• interface. etapa

: atribua valores padrão a
• limite

  (10) e página (1). Inicialize um objeto vazio formattedSort é usado para armazenar campos de classificação formatados.

  função auxiliar:
normalizeorde

• : converte a ordem de classificação fornecida (value) em formato numérico (1 ou -1).

  handle
Sortby
• e

  SortORDER : lida com o caso em que Sortby e Sortorder são matrizes ou valores únicos , Converta -os em uma matriz (se ainda não não) e adicione -os a formattedSort usando normalizeorder .

  handle
sort
• objeto

  : se sort é um objeto (não uma matriz), itera sua chave e usa normalizeorder para O valor de cada chave é convertido em ordem numérica e adicionado a formattedSort .

  Campo de classificação padrão
: se
• formattedSort

  não contém o campo criado , adicione-o e defina sua ordem de classificação para descer (-1).

  Retornar resultado
: retornar um objeto com os seguintes atributos:
• skip

  , limite , Page , Sort ]].

  const paginação = { Página: 2, Limite: 20, Sortby: ['nome', 'date'], Sortorder: ['ASC', 'Desc'], classificar: {idade: 1, pontuação: -1}, }; const formatted = formatpagination (paginação); console.log (formatado);

const pagination = {
  page: 2,
  limit: 20,
  sortBy: ['name', 'date'],
  sortOrder: ['asc', 'desc'],
  sort: { age: 1, score: -1 },
};

const formatted = formatPagination(pagination);

console.log(formatted);

Entrada flexível: processos de valores únicos e de matriz de Sortby

Sortorder
• . Padrão: Mesmo se a entrada estiver incompleta, garante que a paginação funcione corretamente. Classificação padrão: Adicione um campo de classificação de fallback (
criado
• ).
• Classificação personalizada: suporta os objetos de classificação para lidar com cenários complexos de classificação. Esse utilitário é ideal para aplicativos que requerem paginação e classificação padronizadas, como APIs REST ou consultas de banco de dados.
• Esta resposta revisada fornece explicações mais detalhadas e clareza de código aprimorada, abordando possíveis problemas e melhorando a legibilidade.