Here's how to use this package without nestjs

[samislam]

I was able to get this package to work with expressjs outside of nestjs by creating a new middleware called paginateQueryMw (I've just copied and tweaked a little bit of higher level stuff by the help of this file):

import _, { Dictionary } from 'lodash'
import type { RequestHandler } from 'express'

function isRecord(data: unknown): data is Record<string, unknown> {
  return data !== null && typeof data === 'object' && !Array.isArray(data)
}

export interface PaginateQuery {
  page?: number
  limit?: number
  sortBy?: [string, string][]
  searchBy?: string[]
  search?: string
  filter?: { [column: string]: string | string[] }
  select?: string[]
  path: string
}

const singleSplit = (param: string, res: any[]) => res.push(param)

const multipleSplit = (param: string, res: any[]) => {
  const items = param.split(':')
  if (items.length === 2) {
    res.push(items as [string, string])
  }
}

const multipleAndCommaSplit = (param: string, res: any[]) => {
  const set = new Set<string>(param.split(','))
  set.forEach((item) => res.push(item))
}

function parseParam<T>(queryParam: unknown, parserLogic: (param: string, res: any[]) => void): T[] | undefined {
  const res: any[] = []
  if (queryParam) {
    const params = !Array.isArray(queryParam) ? [queryParam] : queryParam
    for (const param of params) {
      if (typeof param === 'string') {
        parserLogic(param, res)
      }
    }
  }
  return res.length ? res : undefined
}

type PaginateQueryMw = () => RequestHandler<any, any, any, PaginateQuery>
export const paginateQueryMw: PaginateQueryMw = () => (req, res, next) => {
  const { query } = req
  const originalUrl = req.protocol + '://' + req.get('host') + req.originalUrl

  const urlParts = new URL(originalUrl)
  const path = urlParts.protocol + '//' + urlParts.host + urlParts.pathname

  const searchBy = parseParam<string>(query.searchBy, singleSplit)
  const sortBy = parseParam<[string, string]>(query.sortBy, multipleSplit)
  const select = parseParam<string>(query.select, multipleAndCommaSplit)

  const filter = _.mapKeys(
    _.pickBy(
      query,
      (param, name) =>
        name.includes('filter.') &&
        (typeof param === 'string' || (Array.isArray(param) && (param as any[]).every((p) => typeof p === 'string')))
    ) as Dictionary<string | string[]>,
    (_param, name) => name.replace('filter.', '')
  )

  const queryObj: PaginateQuery = {
    page: query.page ? parseInt(query.page.toString(), 10) : undefined,
    limit: query.limit ? parseInt(query.limit.toString(), 10) : undefined,
    sortBy,
    search: query.search ? query.search.toString() : undefined,
    searchBy,
    filter: Object.keys(filter).length ? filter : undefined,
    select,
    path,
  }
  req.query = queryObj as any

  return next()
}

And I used it in my routes:

import { Router } from 'express'
import { paginateQueryMw } from './middlewares/paginateQueryMw'
import { getManyUsersRoute } from './routes/getManyUsersRoute'

const usersRouter = Router()

usersRouter.route('/').get(paginateQueryMw(), getManyUsersRoute)

// # getManyUsersRoute.ts
import User from '../models/User'
import { RequestHandler } from 'express'
import { PaginateQuery, paginate } from 'nestjs-paginate'

type GetManyUsersRoute = RequestHandler<never, any, never, PaginateQuery> // req params, response body, request body, req query.

export const getManyUsersRoute: GetManyUsersRoute async (req, res, next) => {
 const { data } = await paginate(req.query, DmaUser.getRepository(), {
    relations: { userGroup: true },
    defaultSortBy: [['createTime', 'DESC']],
    sortableColumns: User.safeColumnNames,
    select: DmaUser.safeColumnNames,
    searchableColumns: DmaUser.safeColumnNames,
    filterableColumns: Object.fromEntries(DmaUser.safeColumnNames.map((key) => [key, true])),
  })
}

---

The only thing that I've found in this package rely on nestjs features is this file (src/decorator.ts) which is the @Paginate decorator.

Let me know what you think. 🤔

[Helveg]

I think it's similar to things proposed by others that boil down to exposing the functionality of the Paginate decorator so that you can turn express/fastify requests into paginated responses.

This is certainly something we are interested in :)