escenario de aplicación:

admite múltiples métodos de clasificación:

• asc https: // your-url? Sort [first_name] = desc & sort [last_name] = asc
]
• use ascending o descender: https: // your-url? Sort [first_name] = ascending & sort [last_name] = descending
• use 1 o -1: https: // your-url? Sort [first_name] = 1 & sort [last_name] = -1

Esta función también es compatible con la clasificación usando sortby y sortorder Fields: https: // your-url? Sortorder = desc & sorty = last_name ]

Código de compras:

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,
    };
};

JavaScript Code:

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,
    };
};

Descripción general

Este código define la interfaz para los campos de paginación y clasificación, y una función práctica para formatear estos campos en estructuras adecuadas para consultas de bases de datos u otros casos de uso de paginación. Esta utilidad ayuda a estandarizar el proceso de paginación y clasificación.

Explicación del código ]

interfaz

isortorder : valores posibles que representan el orden de clasificación: "ASC", "Desc", "Ascendente", "Descendiendo", 1, -1.

ipaginationfields : Describa la estructura de entrada de la paginación y la clasificación: página (opcional), limit (opcional), sortby ] ]]]]]]]]) (Opcional), sortorder (opcional), sort (opcional).

iformatedPagination : Describa la estructura de salida de la paginación formatizada: skip , página , limit , sort ]].

formatPagination function

Esta función procesa el objeto de paginación de entrada y lo convierte en un formato estandarizado.

parámetro

• pagination : objeto que implementa la interfaz ipaginationfields .

paso

• valor predeterminado : asignar valores predeterminados a limit (10) y página (1). Inicializar un objeto vacío FormattedSort se usa para almacenar campos de clasificación formateados.

• Helper Function: normalizeorder : convierte el orden de clasificación dada (valor) en formato numérico (1 o -1).

• handle sortby y sortorder : maneja el caso donde sortby y sortorder son ​​matrices o valores únicos , Conviértalos en una matriz (si no es aún), y agréguelos a formattedSort usando normalizeorder .

• handle sort object : if sort es un objeto (no una matriz), itera sobre su clave y usa normalizeorder to El valor de cada clave se convierte en orden numérico y se agrega a formattedsort .

• field sort campo : if formattedsort no contiene el campo creatatat , agregue y establece su orden de orden para descender (-1).

• return resultado : devuelve un objeto con los siguientes atributos: skip , limit , página sort ].

const pagination = { Página: 2, Límite: 20, sortby: ['nombre', 'fecha'], sortOrder: ['ASC', 'Desc'], sort: {edad: 1, puntaje: -1}, }; const formateado = formatpagination (paginación); console.log (formattado);

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

const formatted = formatPagination(pagination);

console.log(formatted);

funciones principales

Entrada flexible: procesa los valores únicos y de matriz de

sortby
• y sortorder . predeterminado: incluso si la entrada está incompleta, garantiza que la paginación funcione correctamente.
• sort predeterminado: agregue un campo de clasificación de retroceso (
creatat
• ). personalizado: admite
sort
• objetos para manejar escenarios de clasificación complejos. Esta utilidad es ideal para aplicaciones que requieren paginación y clasificación estandarizadas, como API REST o consultas de bases de datos.
Esta respuesta revisada proporciona explicaciones más detalladas y una mayor claridad del código, abordando posibles problemas y mejorando la legibilidad.