@hedhog/pagination 0.0.1

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@hedhog/pagination",
+  "version": "0.0.1",
+  "private": false,
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc && npm version patch",
+    "prod": "npm run build && npm publish --access public"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "description": "",
+  "peerDependencies": {
+    "@prisma/client": "^5.17.0",
+    "@hedhog/prisma": "latest",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.1"
+  }
+}

package/src/constants/pagination.constants.ts

@@ -0,0 +1,2 @@
+export const DEFAULT_PAGE = 1;
+export const DEFAULT_PAGE_SIZE = 20;

package/src/decorator/pagination.decorator.ts

@@ -0,0 +1,62 @@
+import { createParamDecorator, ExecutionContext } from '@nestjs/common';
+import {
+  DEFAULT_PAGE,
+  DEFAULT_PAGE_SIZE,
+} from '../constants/pagination.constants';
+import { PageOrderDirection, PaginationField } from '../enums/patination.enums';
+import { PaginationType } from '../types/pagination.types';
+
+export const Pagination = createParamDecorator(
+  (data: PaginationField, ctx: ExecutionContext): PaginationType => {
+    const request = ctx.switchToHttp().getRequest();
+
+    const defaultOptions: PaginationType = {
+      page: DEFAULT_PAGE,
+      pageSize: DEFAULT_PAGE_SIZE,
+      search: '',
+      sortField: 'id',
+      sortOrder: PageOrderDirection.Asc,
+      fields: '',
+    };
+
+    const requestData = {
+      ...defaultOptions,
+      ...(request.body || {}),
+      ...(request.query || {}),
+    };
+
+    const {
+      page = defaultOptions.page,
+      pageSize = defaultOptions.pageSize,
+      search = defaultOptions.search,
+      sortField = defaultOptions.sortField,
+      sortOrder = defaultOptions.sortOrder,
+      fields = defaultOptions.fields,
+    } = requestData;
+
+    const validSortOrder = Object.values(PageOrderDirection).includes(sortOrder)
+      ? sortOrder
+      : defaultOptions.sortOrder;
+
+    if (data) {
+      switch (data) {
+        case PaginationField.Page:
+        case PaginationField.PageSize:
+          return requestData[data] ? +requestData[data] : defaultOptions[data];
+        case PaginationField.OrderDirection:
+          return requestData[data] || defaultOptions[data];
+        default:
+          return requestData[data];
+      }
+    }
+
+    return {
+      page: +page,
+      pageSize: +pageSize,
+      search,
+      sortField,
+      sortOrder: validSortOrder,
+      fields,
+    };
+  },
+);

package/src/dto/pagination.dto.ts

@@ -0,0 +1,31 @@
+import { Transform } from 'class-transformer';
+import { IsEnum, IsInt, IsOptional, IsString } from 'class-validator';
+import { PageOrderDirection } from '../enums/patination.enums';
+export class PaginationDTO {
+  @IsOptional()
+  @Transform((value) => Number(value))
+  @IsInt({ message: 'page must be an integer' })
+  page: number;
+
+  @IsOptional()
+  @Transform((value) => Number(value))
+  @IsInt({ message: 'pageSize must be an integer' })
+  pageSize: number;
+
+  @IsOptional()
+  @IsString({ message: 'search must be a string' })
+  search: string;
+
+  @IsOptional()
+  @IsString({ message: 'field must be a string' })
+  sortField: string;
+
+  @IsOptional()
+  @IsString({ message: 'sortOrder must be a string' })
+  @IsEnum(PageOrderDirection, { message: 'sortOrder is not valid' })
+  sortOrder: PageOrderDirection;
+
+  @IsOptional()
+  @IsString({ message: 'fields must be a string' })
+  fields: string;
+}

package/src/enums/patination.enums.ts

@@ -0,0 +1,12 @@
+export enum PageOrderDirection {
+  Asc = 'asc',
+  Desc = 'desc',
+}
+
+export enum PaginationField {
+  Page = 'page',
+  PageSize = 'pageSize',
+  OrderField = 'orderField',
+  OrderDirection = 'orderDirection',
+  Search = 'search',
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+export * from './constants/pagination.constants';
+export * from './decorator/pagination.decorator';
+export * from './dto/pagination.dto';
+export * from './enums/patination.enums';
+export * from './pagination.module';
+export * from './pagination.service';
+export type * from './types/pagination.types';

package/src/pagination.module.ts

@@ -0,0 +1,9 @@
+import { Module } from '@nestjs/common';
+import { PaginationService } from './pagination.service';
+
+@Module({
+  imports: [],
+  providers: [PaginationService],
+  exports: [PaginationService],
+})
+export class PaginationModule {}

package/src/pagination.service.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { PaginationService } from './pagination.service';
+
+describe('PaginationService', () => {
+  let service: PaginationService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [PaginationService],
+    }).compile();
+
+    service = module.get<PaginationService>(PaginationService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

package/src/pagination.service.ts

@@ -0,0 +1,128 @@
+import { BadRequestException, Injectable, Logger } from '@nestjs/common';
+import {
+  DEFAULT_PAGE,
+  DEFAULT_PAGE_SIZE,
+} from './constants/pagination.constants';
+import { PageOrderDirection } from './enums/patination.enums';
+import type {
+  BaseModel,
+  FindManyArgs,
+  PaginatedResult,
+  PaginationParams,
+} from './types/pagination.types';
+
+@Injectable()
+export class PaginationService {
+  private readonly logger = new Logger(PaginationService.name);
+
+  async paginate<T, M extends BaseModel>(
+    model: M,
+    paginationParams: PaginationParams,
+    customQuery?: FindManyArgs<M>,
+  ): Promise<PaginatedResult<T>> {
+    try {
+      const page = Number(paginationParams.page || DEFAULT_PAGE);
+      const pageSize = Number(paginationParams.pageSize || DEFAULT_PAGE_SIZE);
+      const search = paginationParams.search || null;
+      const sortField = paginationParams.sortField || null;
+      const sortOrder = paginationParams.sortOrder || PageOrderDirection.Asc;
+      const fields = paginationParams.fields
+        ? paginationParams.fields.split(',')
+        : null;
+
+      if (page < 1 || pageSize < 1) {
+        throw new BadRequestException(
+          'Page and pageSize must be greater than 0',
+        );
+      }
+
+      let selectCondition = undefined;
+      let sortOrderCondition: any = {
+        id: paginationParams.sortOrder || PageOrderDirection.Asc,
+      };
+
+      if (search && sortField) {
+        const fieldNames = this.extractFieldNames(model);
+
+        if (!fieldNames.includes(sortField)) {
+          throw new BadRequestException(
+            `Invalid field: ${sortField}. Valid columns are: ${fieldNames.join(', ')}`,
+          );
+        }
+
+        if (typeof sortField !== 'string') {
+          throw new BadRequestException('Field must be a string');
+        }
+      }
+
+      if (sortField) {
+        sortOrderCondition = { [sortField]: sortOrder };
+      }
+
+      if (fields) {
+        const fieldNames = this.extractFieldNames(model);
+        const invalidFields = fields.filter(
+          (field) => !fieldNames.includes(field),
+        );
+        if (invalidFields.length > 0) {
+          throw new BadRequestException(
+            `Invalid fields: ${invalidFields.join(', ')}. Valid columns are: ${fieldNames.join(', ')}`,
+          );
+        }
+        selectCondition = fields.reduce((acc, field) => {
+          acc[field] = true;
+          return acc;
+        }, {});
+      }
+
+      const skip = page > 0 ? pageSize * (page - 1) : 0;
+
+      const query = {
+        select: selectCondition,
+        where: customQuery?.where || {},
+        orderBy: sortOrderCondition,
+        take: pageSize,
+        skip,
+      };
+
+      const [total, data] = await Promise.all([
+        model.count({ where: customQuery?.where || {} }),
+        model.findMany(query),
+      ]);
+
+      const lastPage = Math.ceil(total / pageSize);
+
+      return {
+        total,
+        lastPage,
+        currentPage: page,
+        pageSize,
+        prev: page > 1 ? page - 1 : null,
+        next: page < lastPage ? page + 1 : null,
+        data,
+      };
+    } catch (error) {
+      this.logger.error('Pagination Error:', error);
+
+      if (error instanceof BadRequestException) {
+        throw error;
+      }
+
+      throw new BadRequestException(`Failed to paginate: ${error.message}`);
+    }
+  }
+
+  extractFieldNames(model: Record<string, any>): string[] {
+    const fieldNames: string[] = [];
+
+    const fields = model.fields;
+
+    for (const key in fields) {
+      if (fields.hasOwnProperty(key)) {
+        fieldNames.push(key);
+      }
+    }
+
+    return fieldNames;
+  }
+}

package/src/types/pagination.types.ts

@@ -0,0 +1,43 @@
+import { PageOrderDirection } from '../enums/patination.enums';
+
+export type PaginatedResult<T> = {
+  total: number;
+  lastPage: number;
+  currentPage: number;
+  pageSize: number;
+  prev: number | null;
+  next: number | null;
+  data: T[];
+};
+
+export type PaginationType = string | number | PaginationParams;
+
+export type PaginateFunction = <K, T>(
+  model: any,
+  args?: K,
+  options?: PaginateOptions,
+) => Promise<PaginatedResult<T>>;
+
+export type PaginationParams = {
+  page?: number;
+  pageSize?: number;
+  search?: string;
+  sortField?: string;
+  sortOrder?: PageOrderDirection;
+  fields: string;
+};
+
+export type PaginateOptions = {
+  page?: number | string;
+  pageSize?: number | string;
+};
+
+export type BaseModel = {
+  findMany: (args: any) => Promise<any[]>;
+  count: (args: any) => Promise<number>;
+  fields?: Record<string, any>;
+};
+
+export type FindManyArgs<M> = M extends { findMany: (args: infer A) => any }
+  ? A
+  : never;

package/tsconfig.lib.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "declaration": true,
+    "outDir": "../../dist/libs/pagination"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "test", "**/*spec.ts"]
+}

package/tsconfig.production.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "experimentalDecorators": true,
+    "target": "es2017",
+    "module": "commonjs",
+    "lib": ["es2017", "es7", "es6"],
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "noImplicitAny": false,
+    "strictNullChecks": false,
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "emitDecoratorMetadata": true
+  },
+  "exclude": ["node_modules", "dist"]
+}