@hed-hog/api-pagination 0.0.1

package/src/databases/database.factory.ts

@@ -0,0 +1,25 @@
+import { Database } from './database';
+import { PostgresDatabase } from './postgres.database';
+import { MySQLDatabase } from './mysql.database';
+
+export class DatabaseFactory {
+  public static create(
+    type: Database,
+    host: string,
+    user: string,
+    password: string,
+    database: string,
+    port: number,
+  ) {
+    switch (type) {
+      case Database.POSTGRES:
+        return new PostgresDatabase(host, user, password, database, port);
+
+      case Database.MYSQL:
+        return new MySQLDatabase(host, user, password, database, port);
+
+      default:
+        console.warn(`[WARN] Unsupported Database: ${type}`);
+    }
+  }
+}

package/src/databases/database.ts

@@ -0,0 +1,4 @@
+export enum Database {
+  POSTGRES = 'postgres',
+  MYSQL = 'mysql',
+}

package/src/databases/index.ts

@@ -0,0 +1,3 @@
+export * from './database';
+export * from './database.factory';
+export * from './abstract.database';

package/src/databases/mysql.database.ts

@@ -0,0 +1,14 @@
+import { AbstractDatabase } from './abstract.database';
+import { Database } from './database';
+
+export class MySQLDatabase extends AbstractDatabase {
+  constructor(
+    protected host: string,
+    protected user: string,
+    protected password: string,
+    protected database: string,
+    protected port: number,
+  ) {
+    super(Database.MYSQL, host, user, password, database, port);
+  }
+}

package/src/databases/postgres.database.ts

@@ -0,0 +1,14 @@
+import { AbstractDatabase } from './abstract.database';
+import { Database } from './database';
+
+export class PostgresDatabase extends AbstractDatabase {
+  constructor(
+    protected host: string,
+    protected user: string,
+    protected password: string,
+    protected database: string,
+    protected port: number,
+  ) {
+    super(Database.POSTGRES, host, user, password, database, port);
+  }
+}

package/src/decorator/pagination.decorator.ts

@@ -0,0 +1,84 @@
+import {
+  BadRequestException,
+  createParamDecorator,
+  ExecutionContext,
+} from '@nestjs/common';
+import { plainToClass } from 'class-transformer';
+import { validateSync } from 'class-validator';
+import {
+  DEFAULT_PAGE,
+  DEFAULT_PAGE_SIZE,
+} from '../constants/pagination.constants';
+import { PaginationDTO } from '../dto/pagination.dto';
+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;
+
+    const finalData = {
+      page,
+      pageSize,
+      search,
+      sortField,
+      sortOrder: validSortOrder,
+      fields,
+    };
+
+    const paginationDtoInstance = plainToClass(PaginationDTO, finalData);
+
+    const errors = validateSync(paginationDtoInstance);
+
+    if (errors.length > 0) {
+      throw new BadRequestException(
+        'Pagination data is not valid according to PaginationDto: ' +
+          errors
+            .map((error) => Object.values(error.constraints).join(', '))
+            .join(', '),
+      );
+    }
+
+    if (data) {
+      switch (data) {
+        case PaginationField.Page:
+        case PaginationField.PageSize:
+          return finalData[data] ? +finalData[data] : defaultOptions[data];
+        case PaginationField.SortOrder:
+          return validSortOrder || defaultOptions[data];
+        default:
+          return finalData[data];
+      }
+    }
+
+    return finalData;
+  },
+);

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',
+  SortField = 'sortOrder',
+  SortOrder = 'sortOrder',
+  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.ts

@@ -0,0 +1,371 @@
+import { itemTranslations } from '@hed-hog/api';
+import { BadRequestException, Injectable, Logger } from '@nestjs/common';
+import {
+  DEFAULT_PAGE,
+  DEFAULT_PAGE_SIZE,
+} from './constants/pagination.constants';
+import { AbstractDatabase, Database, DatabaseFactory } from './databases';
+import { PageOrderDirection } from './enums/patination.enums';
+import type { FindManyArgs, PaginationParams } from './types/pagination.types';
+
+@Injectable()
+export class PaginationService {
+  private readonly logger = new Logger(PaginationService.name);
+  private db: any = null;
+  async paginate<T, M extends any>(
+    model: M,
+    paginationParams: PaginationParams,
+    customQuery?: FindManyArgs<M>,
+    translationKey?: string,
+  ) /*: Promise<PaginatedResult<T>>*/ {
+    try {
+      if (!model) {
+        throw new BadRequestException('Model is required');
+      }
+
+      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 (sortField) {
+        const invalid = this.isInvalidField(sortField, model);
+        let localeInvalid = false;
+        if (invalid) {
+          localeInvalid = this.isInvalidLocaleField(sortField, model);
+
+          if (localeInvalid) {
+            this.logger.error(`Invalid field: ${sortField}`);
+            throw new BadRequestException(
+              `Invalid field: ${sortField}. Valid columns are: ${this.extractFieldNames(
+                model,
+              ).join(', ')}`,
+            );
+          } else {
+            sortOrderCondition = {
+              [`${(model as any).name}_locale`]: { [sortField]: sortOrder },
+            };
+          }
+        } else {
+          sortOrderCondition = { [sortField]: sortOrder };
+        }
+      }
+
+      if (search) {
+        if (typeof search !== 'string') {
+          this.logger.error('Search must be a string');
+          throw new BadRequestException('Search must be a string');
+        }
+      }
+
+      if (fields) {
+        const invalidFields = this.isInvalidFields(fields, model);
+
+        if (invalidFields) {
+          this.logger.error(
+            `Invalid fields: ${fields.join(', ')}. Valid columns are: ${this.extractFieldNames(
+              model,
+            ).join(', ')}`,
+          );
+
+          throw new BadRequestException(
+            `Invalid fields: ${fields.join(', ')}. Valid columns are: ${this.extractFieldNames(
+              model,
+            ).join(', ')}`,
+          );
+        }
+
+        selectCondition = fields.reduce((acc, field) => {
+          acc[field] = true;
+          return acc;
+        }, {});
+      }
+
+      const skip = page > 0 ? pageSize * (page - 1) : 0;
+
+      if (
+        (customQuery as any).where &&
+        (customQuery as any).where.OR &&
+        (customQuery as any).where.OR.length === 0
+      ) {
+        delete (customQuery as any).where.OR;
+      }
+
+      const query: any = {
+        select: selectCondition,
+        where: (customQuery as any)?.where || {},
+        orderBy: sortOrderCondition,
+        take: pageSize,
+        skip,
+      };
+
+      if ((customQuery as any)?.include) {
+        query.include = (customQuery as any)?.include;
+        delete query.select;
+      }
+
+      let [total, data] = await Promise.all([
+        (model as any).count({ where: (customQuery as any)?.where || {} }),
+        (model as any).findMany(query),
+        //this.query(model, query),
+      ]);
+
+      const lastPage = Math.ceil(total / pageSize);
+
+      if (translationKey) {
+        data = data.map((item: any) => {
+          return itemTranslations(translationKey, item);
+        });
+      }
+
+      return {
+        total,
+        lastPage,
+        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}`);
+    }
+  }
+
+  extractFieldNames(model: Record<string, any>): string[] {
+    const fieldNames: string[] = [];
+
+    const fields = model.fields;
+
+    for (const key in fields) {
+      if (fields && fields.hasOwnProperty(key)) {
+        fieldNames.push(key);
+      }
+    }
+
+    return fieldNames;
+  }
+
+  isInvalidField(sortField: string, model: any): boolean {
+    return model && model.fields ? !model.fields[sortField] : true;
+  }
+
+  isInvalidLocaleField(sortField: string, model: any): boolean {
+    const fields = model['$parent'][`${model.name}_locale`].fields;
+
+    return model && fields ? !fields[sortField] : true;
+  }
+
+  isInvalidFields(fields: string[], model: any): boolean {
+    return !fields.every((field) =>
+      model.fields ? model && model.fields[field] : false,
+    );
+  }
+
+  isInvalidLocaleFields(fields: string[], model: any): boolean {
+    const localeFields = model['$parent'][`${model.name}_locale`].fields;
+
+    return !fields.every((field) =>
+      localeFields ? !localeFields[field] : false,
+    );
+  }
+
+  async getDb(model: any): Promise<any> {
+    const {
+      DATABASE_URL,
+      DB_HOST,
+      DB_PORT,
+      DB_USERNAME,
+      DB_PASSWORD,
+      DB_DATABASE,
+    } = model['$parent']._engine.config.env;
+
+    const type = DATABASE_URL.split(':')[0];
+
+    this.db = DatabaseFactory.create(
+      type === 'mysql' ? Database.MYSQL : Database.POSTGRES,
+      DB_HOST,
+      DB_USERNAME,
+      DB_PASSWORD,
+      DB_DATABASE,
+      Number(DB_PORT),
+    );
+
+    return this.db;
+  }
+
+  async getBuilder(
+    model: any,
+    tableName: string,
+    query: any,
+    builder: any,
+  ): Promise<any> {
+    const db = await this.getDb(model);
+
+    if (!builder) {
+      builder = {
+        joinTables: [],
+        select: [],
+        where: [],
+        order: [],
+        join: [],
+        from: db.getColumnNameWithScaping(tableName),
+      };
+    }
+
+    if (query.orderBy) {
+      for (const key in query.orderBy) {
+        if (typeof query.orderBy[key] === 'object') {
+          if (!builder.joinTables.includes(key)) {
+            builder.joinTables.push(key);
+            const foreignKey = await db.getColumnNameFromRelation(
+              tableName,
+              `${tableName}_locale`,
+            );
+
+            const primaryKeys = await db.getPrimaryKeys(tableName);
+
+            if (primaryKeys.length !== 1) {
+              throw new Error('Only single primary key is supported');
+            }
+
+            const primaryKey = primaryKeys[0];
+
+            builder.join.push(
+              `LEFT JOIN ${db.getColumnNameWithScaping(key)} ON ${db.getColumnNameWithScaping(key)}.${db.getColumnNameWithScaping(foreignKey)} = ${db.getColumnNameWithScaping(tableName)}.${db.getColumnNameWithScaping(primaryKey)}`,
+            );
+
+            for (const k in query.orderBy[key]) {
+              builder.order.push(
+                `${db.getColumnNameWithScaping(key)}.${db.getColumnNameWithScaping(k)} ${query.orderBy[key][k]}`,
+              );
+            }
+          }
+        }
+      }
+    }
+
+    if (query.select) {
+      builder.select = [
+        ...builder.select,
+        ...Object.keys(query.select).map(
+          (key) =>
+            `${db.getColumnNameWithScaping(tableName)}.${db.getColumnNameWithScaping(key)}`,
+        ),
+      ];
+      for (const key in query.select) {
+        if (typeof query.select[key] === 'object') {
+          builder = await this.getBuilder(
+            model,
+            key,
+            query.select[key],
+            builder,
+          );
+        }
+      }
+    } else if (query.include) {
+      builder.select = [
+        ...builder.select,
+        `${db.getColumnNameWithScaping(tableName)}.*`,
+      ];
+      for (const key in query.include) {
+        if (typeof query.include[key] === 'object') {
+          if (!builder.joinTables.includes(key)) {
+            builder.joinTables.push(key);
+
+            const foreignKey = await db.getColumnNameFromRelation(
+              tableName,
+              key,
+            );
+
+            const primaryKeys = await db.getPrimaryKeys(tableName);
+
+            const primaryKey = primaryKeys[0];
+
+            builder.join.push(
+              `LEFT JOIN ${db.getColumnNameWithScaping(key)} ON ${db.getColumnNameWithScaping(key)}.${db.getColumnNameWithScaping(foreignKey)} = ${db.getColumnNameWithScaping(tableName)}.${db.getColumnNameWithScaping(primaryKey)}`,
+            );
+
+            builder = await this.getBuilder(
+              model,
+              key,
+              query.include[key],
+              builder,
+            );
+          }
+        }
+      }
+    }
+
+    if (query.where) {
+      for (const key in query.where) {
+        if (typeof query.where[key] === 'object') {
+          if (!builder.joinTables.includes(key)) {
+            builder.joinTables.push(key);
+            const foreignKey = await db.getColumnNameFromRelation(
+              key,
+              tableName,
+            );
+            const primaryKeys = await db.getPrimaryKeys(key);
+
+            builder.join.push(
+              `LEFT JOIN ${db.getColumnNameWithScaping(key)} ON ${db.getColumnNameWithScaping(key)}.${db.getColumnNameWithScaping(primaryKeys[0])} = ${db.getColumnNameWithScaping(tableName)}.${db.getColumnNameWithScaping(foreignKey)}`,
+            );
+
+            for (const k in query.where[key]) {
+              builder.where.push(
+                `${db.getColumnNameWithScaping(key)}.${db.getColumnNameWithScaping(k)} = ${AbstractDatabase.addSimpleQuotes(query.where[key][k])}`,
+              );
+            }
+          }
+        } else {
+          builder.where.push(
+            `${db.getColumnNameWithScaping(tableName)}.${db.getColumnNameWithScaping(key)} = ${AbstractDatabase.addSimpleQuotes(query.where[key])}`,
+          );
+        }
+      }
+    }
+
+    return builder;
+  }
+
+  async query(model: any, query: any): Promise<any[]> {
+    const db = await this.getDb(model);
+    const builder = await this.getBuilder(model, model.name, query, null);
+
+    const sql = [];
+
+    sql.push(`SELECT ${builder.select.join(', ')}`);
+    sql.push(`FROM ${builder.from}`);
+    if (builder.join.length) sql.push(builder.join.join(' '));
+    if (builder.where.length) sql.push(`WHERE ${builder.where.join(' AND ')}`);
+    if (builder.order.length) sql.push(`ORDER BY ${builder.order.join(', ')}`);
+    if (query.take >= 0 && query.skip >= 0)
+      sql.push(db.getLimit(query.take, query.skip));
+
+    const result = await db.query(sql.join(' '));
+
+    return result;
+  }
+}

package/src/types/pagination.types.ts

@@ -0,0 +1,44 @@
+import { PageOrderDirection } from '../enums/patination.enums';
+
+export type PaginatedResult<T> = {
+  total: number;
+  lastPage: number;
+  page: 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>;
+  name: string;
+};
+
+export type FindManyArgs<M> = M extends { findMany: (args: infer A) => any }
+  ? A
+  : never;

package/src/types/query-option.ts

@@ -0,0 +1,4 @@
+export type QueryOption = {
+  returning?: string[] | string;
+  primaryKeys?: string[] | string;
+};

package/src/types/relation-n2n-result.ts

@@ -0,0 +1,6 @@
+export type RelationN2NResult = {
+  tableNameIntermediate: string;
+  columnNameOrigin: string;
+  columnNameDestination: string;
+  primaryKeyDestination: string;
+};

package/src/types/transaction-queries.ts

@@ -0,0 +1,7 @@
+import { QueryOption } from './query-option';
+
+export type TransactionQueries = {
+  query: string;
+  values?: any[];
+  options?: QueryOption;
+};

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "@hed-hog/typescript-config/nestjs-library.json",
+  "include": ["src"],
+  "compilerOptions": {
+    "composite": true,
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "dist",
+    "rootDir": "src"
+  }
+}