@hedhog/pagination 0.0.17 → 0.0.22

package/src/databases/database.factory.ts

@@ -0,0 +1,26 @@
+import * as chalk from 'chalk';
+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.info(chalk.yellow(`[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/pagination.service.ts

@@ -1,27 +1,23 @@
-import { itemTranslations } from '@hedhog/utils';
+import { itemTranslations } from '@hedhog/core';
 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 {
-  BaseModel,
-  FindManyArgs,
-  PaginatedResult,
-  PaginationParams,
-} from './types/pagination.types';
+import type { FindManyArgs, PaginationParams } from './types/pagination.types';
 
 @Injectable()
 export class PaginationService {
   private readonly logger = new Logger(PaginationService.name);
-
-  async paginate<T, M extends BaseModel>(
+  private db: any = null;
+  async paginate<T, M extends any>(
     model: M,
     paginationParams: PaginationParams,
     customQuery?: FindManyArgs<M>,
     translationKey?: string,
-  ): Promise<PaginatedResult<T>> {
+  ) /*: Promise<PaginatedResult<T>>*/ {
     try {
       if (!model) {
         throw new BadRequestException('Model is required');
@@ -49,16 +45,25 @@ export class PaginationService {
 
       if (sortField) {
         const invalid = this.isInvalidField(sortField, model);
+        let localeInvalid = false;
         if (invalid) {
-          this.logger.error(`Invalid field: ${sortField}`);
-          throw new BadRequestException(
-            `Invalid field: ${sortField}. Valid columns are: ${this.extractFieldNames(
-              model,
-            ).join(', ')}`,
-          );
-        }
+          localeInvalid = this.isInvalidLocaleField(sortField, model);
 
-        sortOrderCondition = { [sortField]: sortOrder };
+          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) {
@@ -94,29 +99,30 @@ export class PaginationService {
       const skip = page > 0 ? pageSize * (page - 1) : 0;
 
       if (
-        customQuery.where &&
-        customQuery.where.OR &&
-        customQuery.where.OR.length === 0
+        (customQuery as any).where &&
+        (customQuery as any).where.OR &&
+        (customQuery as any).where.OR.length === 0
       ) {
-        delete customQuery.where.OR;
+        delete (customQuery as any).where.OR;
       }
 
       const query: any = {
         select: selectCondition,
-        where: customQuery?.where || {},
+        where: (customQuery as any)?.where || {},
         orderBy: sortOrderCondition,
         take: pageSize,
         skip,
       };
 
-      if (customQuery?.include) {
-        query.include = customQuery?.include;
+      if ((customQuery as any)?.include) {
+        query.include = (customQuery as any)?.include;
         delete query.select;
       }
 
       let [total, data] = await Promise.all([
-        model.count({ where: customQuery?.where || {} }),
-        model.findMany(query),
+        (model as any).count({ where: (customQuery as any)?.where || {} }),
+        (model as any).findMany(query),
+        //this.query(model, query),
       ]);
 
       const lastPage = Math.ceil(total / pageSize);
@@ -159,13 +165,207 @@ export class PaginationService {
     return fieldNames;
   }
 
-  isInvalidField(sortField: string, model: BaseModel): boolean {
+  isInvalidField(sortField: string, model: any): boolean {
     return model && model.fields ? !model.fields[sortField] : true;
   }
 
-  isInvalidFields(fields: string[], model: BaseModel): boolean {
+  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));
+
+    console.log('sql', sql.join(' '));
+
+    const result = await db.query(sql.join(' '));
+
+    return result;
+  }
 }

package/src/types/pagination.types.ts

@@ -36,6 +36,7 @@ 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 }

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