Multiple fields sorting with a time saving function for server side developer (api pagination)

Use case:
Sort by asc or desc
https://your-url?sort[first_name]=desc&sort[last_name]=asc

or, Sort by ascending / descending
https://your-url?sort[first_name]=ascending&sort[last_name]=descending

or, Sort by 1 / -1
https://your-url?sort[first_name]=1&sort[last_name]=-1

This function will help you to sort by using sortBy and sortOrder fields also.
https://your-url?sortOrder=desc&sortBy=last_name

Code for Typescript:

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

export interface IPaginationFields {
    page?: number;
    limit?: number;
    sortBy?: string;
    sortOrder?: ISortOrder;
    sort?: Record<string, ISortOrder>;
}

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 formatOrder = (value: string | number) => {
        const numValue = Number(value);
        const isString = Number.isNaN(numValue);

        if (!isString && (numValue === 1 || numValue === -1)) {
            return numValue;
        } else {
            return value === "asc" || value === "ascending" ? 1 : -1;
        }
    };

    if (sortBy) {
        const sortByArr = Array.isArray(sortBy) ? sortBy : [sortBy];
        const sortOrderArr = Array.isArray(sortOrder) ? sortOrder : [sortOrder];
        sortByArr.forEach((field, index) => {
            formattedSort[field] = formatOrder(sortOrderArr[index]);
        });
    }

    if (!Array.isArray(sort) && typeof sort === "object") {
        Object.keys(sort).forEach((field) => {
            formattedSort[field] = formatOrder(sort[field]);
        });
    }

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

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

Code for javascript:

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

    const formattedSort = {};

    const formatOrder = (value) => {
      const numValue = Number(value);
      const isString = Number.isNaN(numValue);

      if (!isString && (numValue === 1 || numValue === -1)) {
        return numValue;
      } else {
        return value === "asc" || value === "ascending" ? 1 : -1;
      }
    };

    if (sortBy) {
      const sortByArr = Array.isArray(sortBy) ? sortBy : [sortBy];
      const sortOrderArr = Array.isArray(sortOrder) ? sortOrder : [sortOrder];
      sortByArr.forEach((field, index) => {
        formattedSort[field] = formatOrder(sortOrderArr[index]);
      });
    }

    if (!Array.isArray(sort) && typeof sort === "object") {
      Object.keys(sort).forEach((field) => {
        formattedSort[field] = formatOrder(sort[field]);
      });
    }

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

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

  return formatPagination;

Overview
The code defines an interface for pagination and sorting fields, as well as a utility function to format these fields into a structure suitable for database queries or other pagination use cases. This utility helps in standardizing the pagination and sorting process.

Code Explanation
Interfaces
ISortOrder

• Represents the possible values for sorting order:
• Strings: "asc", "desc", "ascending", "descending" - Numbers: 1 (ascending), -1 (descending)

IPaginationFields

• Describes the input structure for pagination and sorting:

• page (optional): The current page number (default: 1).

• limit (optional): The number of items per page (default: 10).

• sortBy (optional): A field name (or an array of field names) to sort by.

• sortOrder (optional): The sorting order(s) corresponding to sortBy.

• sort (optional): An object where keys are field names and values are sort orders.

IFormatedPagination

• Describes the output structure for formatted pagination:

• skip: The number of items to skip (calculated as (page - 1) * limit).

• page: The current page number.

• limit: The number of items per page.

• sort: A key-value pair of field names and their corresponding sort orders (1 or -1).

formatPagination Function
This function processes the input pagination object and converts it into a standardized format.

Parameters

• pagination: An object implementing the IPaginationFields interface.

Steps
Defaults

• Destructures the pagination input and assigns default values to limit (10) and page (1).

• Initializes an empty object formattedSort for storing the formatted sort fields.

Helper Function: formatOrder

• Converts the given sorting order (value) into a numeric format (1 or -1):

• If value is a number (1 or -1), it returns the number.

• If value is a string (asc or ascending), it returns 1.

• For desc or descending, it returns -1.

Process sortBy and sortOrder

• Handles the case where sortBy and sortOrder are arrays or single values:

• Converts them to arrays (if not already).

• Iterates over the fields in sortBy and assigns their corresponding orders

• from sortOrder (using formatOrder) to formattedSort.

Process sort Object

• If sort is an object (and not an array), iterates over its keys:

• Converts each key's value into a numeric order using formatOrder and adds it to formattedSort.

Default Sort Field

• If formattedSort does not include the createdAt field, adds it with a descending order (-1).

Return the Result

• Returns an object with the following properties:

• skip: Number of items to skip, calculated as (page - 1) * limit.

• limit: The number of items per page.

• page: The current page number.

• sort: The processed sorting object.
  

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

const formatted = formatPagination(pagination);

console.log(formatted);
/*
{
  skip: 20,
  limit: 20,
  page: 2,
  sort: {
    name: 1,
    date: -1,
    age: 1,
    score: -1,
    createdAt: -1, // Default sort field
  },
}
*/

Key Features

• Flexible Input: Handles single and array values for sortBy and sortOrder.
• Default Values: Ensures pagination works even with incomplete input.
• Default Sorting: Adds a fallback sort field (createdAt).
• Custom Sorting: Supports a sort object for complex sorting scenarios. This utility is ideal for applications that require standardized pagination and sorting, such as REST APIs or database queries