@hed-hog/api-pagination 0.0.3 → 0.0.5

package/src/databases/abstract.database.ts

@@ -1,11 +1,11 @@
 import { Connection } from 'mysql2/promise';
 import { Client } from 'pg';
 import { DataSource } from 'typeorm';
+import { EventEmitter } from 'typeorm/platform/PlatformTools';
 import { QueryOption } from '../types/query-option';
 import { RelationN2NResult } from '../types/relation-n2n-result';
 import { TransactionQueries } from '../types/transaction-queries';
 import { Database } from './database';
-import { EventEmitter } from 'typeorm/platform/PlatformTools';
 
 export class AbstractDatabase {
   private client: Client | Connection | null = null;
@@ -827,4 +827,62 @@ export class AbstractDatabase {
 
     return result;
   }
+
+  /**
+   * Executa uma raw query e retorna os resultados
+   * Usado para queries parametrizadas com $1, $2, etc.
+   */
+  async queryRaw(query: string, values?: any[]): Promise<any[]> {
+    if (!this.client) {
+      await this.getClient();
+    }
+
+    try {
+      let result;
+
+      switch (this.type) {
+        case Database.POSTGRES:
+          const pgResult = await (this.client as Client).query(query, values);
+          result = pgResult.rows;
+          break;
+
+        case Database.MYSQL:
+          // Para MySQL, converter $1, $2 para ?
+          const mysqlQuery = query.replace(/\$\d+/g, '?');
+          const [rows] = await (this.client as Connection).query(mysqlQuery, values);
+          result = rows;
+          break;
+
+        default:
+          throw new Error(`Unsupported database type: ${this.type}`);
+      }
+
+      if (this.autoClose) {
+        await this.client?.end();
+        this.client = null;
+      }
+
+      return result;
+    } catch (error) {
+      console.error({
+        error,
+        query,
+        values,
+      });
+      
+      if (this.autoClose && this.client) {
+        await this.client.end();
+        this.client = null;
+      }
+
+      throw error;
+    }
+  }
+
+  /**
+   * Escapa um identificador (nome de tabela ou coluna)
+   */
+  escapeIdentifier(identifier: string): string {
+    return this.getColumnNameWithScaping(identifier).replace(/['"]/g, '');
+  }
 }

package/src/pagination.service.ts

@@ -10,14 +10,83 @@ import type { FindManyArgs, PaginationParams } from './types/pagination.types';
 
 @Injectable()
 export class PaginationService {
-  private readonly logger = new Logger(PaginationService.name);
+
+    private readonly logger = new Logger(PaginationService.name);
   private db: any = null;
+    
+    async paginatePrismaModel(model: any, options: {
+      page?: number;
+      pageSize?: number;
+      search?: string;
+      sortField?: string;
+      sortOrder?: 'asc' | 'desc';
+      validSortFields?: string[];
+      searchFields?: string[];
+      where?: any;
+      include?: any;
+    }) {
+
+      try {
+
+      const {
+        page = 1,
+        pageSize = 10,
+        search,
+        sortField = 'id',
+        sortOrder = 'desc',
+        validSortFields = ['id'],
+        searchFields = [],
+        where: customWhere,
+        include,
+      } = options;
+
+      const currentPage = Math.max(Number(page) || 1, 1);
+      const limit = Math.max(Number(pageSize) || 10, 1);
+      const skip = (currentPage - 1) * limit;
+
+      let where = customWhere || {};
+      if (search && searchFields.length > 0) {
+        where = {
+          ...where,
+          OR: searchFields.map((field) => ({
+            [field]: { contains: search, mode: 'insensitive' },
+          })),
+        };
+      }
+
+      const orderBy =
+        sortField && typeof sortField === 'string' && validSortFields.includes(sortField)
+          ? { [sortField]: sortOrder === 'asc' ? 'asc' : 'desc' }
+          : { id: 'desc' };
+
+      const [data, total] = await Promise.all([
+        model.findMany({ skip, take: limit, where, orderBy, include }),
+        model.count({ where }),
+      ]);
+
+      const lastPage = Math.max(1, Math.ceil(total / limit));
+
+      return {
+        total,
+        lastPage,
+        page: currentPage,
+        pageSize: limit,
+        data,
+      };
+
+    } catch (error) {
+      this.logger.error('Pagination Error:', error);
+      throw new BadRequestException(`Failed to paginate: ${error}`);
+    }
+    }
+
   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');
@@ -42,13 +111,22 @@ export class PaginationService {
       let sortOrderCondition: any = {
         id: paginationParams.sortOrder || PageOrderDirection.Asc,
       };
+      let needsRawQueryOrdering = false;
+      let localeTableName = '';
+      let localeSortField = '';
+
+      this.logger.debug(`Sort field: ${sortField}`);
 
       if (sortField) {
         const invalid = this.isInvalidField(sortField, model);
         let localeInvalid = false;
+        
+        this.logger.debug(`Field ${sortField} is invalid in main model: ${invalid}`);
+        
         if (invalid) {
           localeInvalid = this.isInvalidLocaleField(sortField, model);
-
+          this.logger.debug(`Field ${sortField} is invalid in locale model: ${localeInvalid}`);
+          
           if (localeInvalid) {
             this.logger.error(`Invalid field: ${sortField}`);
             throw new BadRequestException(
@@ -57,9 +135,11 @@ export class PaginationService {
               ).join(', ')}`,
             );
           } else {
-            sortOrderCondition = {
-              [`${(model as any).name}_locale`]: { [sortField]: sortOrder },
-            };
+            // Campo existe na tabela locale - precisa usar raw query
+            localeTableName = `${(model as any).name}_locale`;
+            localeSortField = sortField;
+            needsRawQueryOrdering = true;
+            this.logger.debug(`Will use raw query ordering for ${localeTableName}.${localeSortField}`);
           }
         } else {
           sortOrderCondition = { [sortField]: sortOrder };
@@ -106,28 +186,46 @@ export class PaginationService {
         delete (customQuery as any).where.OR;
       }
 
-      const query: any = {
-        select: selectCondition,
-        where: (customQuery as any)?.where || {},
-        orderBy: sortOrderCondition,
-        take: pageSize,
-        skip,
-      };
+      // Contar total sempre com Prisma normal
+      const total = await (model as any).count({ 
+        where: (customQuery as any)?.where || {} 
+      });
+
+      let data: any[];
+
+      if (needsRawQueryOrdering) {
+        // Usar raw query para ordenação por campo de tabela relacionada
+        data = await this.paginateWithLocaleOrdering(
+          model,
+          localeTableName,
+          localeSortField,
+          sortOrder,
+          skip,
+          pageSize,
+          customQuery,
+        );
+      } else {
+        // Usar Prisma normal
+        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;
+        }
 
-      if ((customQuery as any)?.include) {
-        query.include = (customQuery as any)?.include;
-        delete query.select;
+        data = await (model as any).findMany(query);
       }
 
-      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) {
+      if (translationKey !== undefined && translationKey !== null) {
+        this.logger.debug(`Applying translations with key: ${translationKey}`);
         data = data.map((item: any) => {
           return itemTranslations(translationKey, item);
         });
@@ -142,15 +240,177 @@ export class PaginationService {
         next: page < lastPage ? page + 1 : null,
         data,
       };
-    } catch (error) {
+    } catch (error: any) {
       this.logger.error('Pagination Error:', error);
 
       if (error instanceof BadRequestException) {
         throw error;
       }
 
-      throw new BadRequestException(`Failed to paginate: ${error}`);
+      throw new BadRequestException(`Failed to paginate: ${error.message || error}`);
+    }
+  }
+
+  /**
+   * Método auxiliar para paginação com ordenação por campos de tabela locale
+   * Usa raw query para ordenação, mas mantém estrutura aninhada do Prisma
+   */
+  private async paginateWithLocaleOrdering(
+    model: any,
+    localeTableName: string,
+    sortField: string,
+    sortOrder: string,
+    skip: number,
+    take: number,
+    customQuery?: any,
+  ): Promise<any[]> {
+    try {
+      const tableName = (model as any).name;
+      const db = await this.getDb(model);
+      
+      // Detectar locale code do include (se disponível)
+      let localeCode = 'en'; // fallback
+      if (customQuery?.include?.[localeTableName]?.where?.locale?.code) {
+        localeCode = customQuery.include[localeTableName].where.locale.code;
+      }
+
+      this.logger.debug(`Building raw query for ${tableName} ordered by ${localeTableName}.${sortField}`);
+
+      // Construir WHERE clause da raw query
+      const whereConditions: string[] = [];
+      let whereParams: any[] = [];
+      let paramIndex = 1;
+
+      if (customQuery?.where) {
+        const { conditions, params, nextIndex } = this.buildWhereClause(
+          customQuery.where,
+          tableName,
+          db,
+          paramIndex,
+        );
+        whereConditions.push(...conditions);
+        whereParams.push(...params);
+        paramIndex = nextIndex;
+      }
+
+      // Adicionar filtro de locale
+      whereConditions.push(`l.code = $${paramIndex}`);
+      whereParams.push(localeCode);
+      paramIndex++;
+
+      const whereClause = whereConditions.length > 0 
+        ? `WHERE ${whereConditions.join(' AND ')}` 
+        : '';
+
+      // Query para buscar IDs ordenados
+      const orderDirection = sortOrder.toUpperCase() === 'DESC' ? 'DESC' : 'ASC';
+      const orderByClause = `ORDER BY tl.${db.escapeIdentifier(sortField)} ${orderDirection}`;
+      
+      const rawQuery = `
+        SELECT DISTINCT t.id
+        FROM ${db.escapeIdentifier(tableName)} t
+        LEFT JOIN ${db.escapeIdentifier(localeTableName)} tl ON t.id = tl.${tableName}_id
+        LEFT JOIN locale l ON tl.locale_id = l.id
+        ${whereClause}
+        ${orderByClause}
+        LIMIT $${paramIndex} OFFSET $${paramIndex + 1}
+      `;
+
+      whereParams.push(take, skip);
+
+      this.logger.debug(`Raw query: ${rawQuery}`);
+      this.logger.debug(`Params: ${JSON.stringify(whereParams)}`);
+
+      // Executar raw query para obter IDs ordenados
+      const orderedIds = await db.queryRaw(rawQuery, whereParams);
+      
+      if (!orderedIds || orderedIds.length === 0) {
+        return [];
+      }
+
+      const ids = orderedIds.map((row: any) => row.id);
+
+      this.logger.debug(`Ordered IDs: ${ids.join(', ')}`);
+
+      // Buscar dados completos com Prisma mantendo estrutura aninhada
+      const query: any = {
+        where: {
+          id: { in: ids },
+          ...(customQuery?.where || {}),
+        },
+      };
+
+      if (customQuery?.include) {
+        query.include = customQuery.include;
+      }
+
+      if (customQuery?.select) {
+        query.select = customQuery.select;
+      }
+
+      const data = await model.findMany(query);
+
+      // Reordenar dados para manter a ordem da raw query
+      const orderedData = ids
+        .map(id => data.find((item: any) => item.id === id))
+        .filter(Boolean);
+
+      this.logger.debug(`Returning ${orderedData.length} ordered records`);
+
+      return orderedData;
+
+    } catch (error: any) {
+      this.logger.error(`Error in paginateWithLocaleOrdering: ${error.message}`, error.stack);
+      throw new BadRequestException(
+        `Failed to paginate with locale ordering: ${error.message}`
+      );
+    }
+  }
+
+  /**
+   * Constrói cláusula WHERE para raw queries
+   */
+  private buildWhereClause(
+    where: any,
+    tableName: string,
+    db: any,
+    startIndex: number = 1,
+  ): { conditions: string[]; params: any[]; nextIndex: number } {
+    const conditions: string[] = [];
+    const params: any[] = [];
+    let paramIndex = startIndex;
+
+    for (const key in where) {
+      if (key === 'OR' || key === 'AND') {
+        continue; // Simplificação: ignorar OR/AND por enquanto
+      }
+
+      const value = where[key];
+
+      if (typeof value === 'object' && value !== null) {
+        // Operadores especiais do Prisma
+        if ('in' in value) {
+          const placeholders = value.in.map(() => `$${paramIndex++}`).join(', ');
+          conditions.push(`t.${db.escapeIdentifier(key)} IN (${placeholders})`);
+          params.push(...value.in);
+        } else if ('contains' in value) {
+          conditions.push(`t.${db.escapeIdentifier(key)} ILIKE $${paramIndex}`);
+          params.push(`%${value.contains}%`);
+          paramIndex++;
+        } else if ('equals' in value) {
+          conditions.push(`t.${db.escapeIdentifier(key)} = $${paramIndex}`);
+          params.push(value.equals);
+          paramIndex++;
+        }
+      } else {
+        // Valor simples
+        conditions.push(`t.${db.escapeIdentifier(key)} = $${paramIndex}`);
+        params.push(value);
+        paramIndex++;
+      }
     }
+
+    return { conditions, params, nextIndex: paramIndex };
   }
 
   extractFieldNames(model: Record<string, any>): string[] {

package/tsconfig.json

@@ -1,5 +1,5 @@
 {
-  "extends": "@hed-hog/typescript-config/nestjs-library.json",
+  "extends": "@hed-hog/typescript-config/library.json",
   "include": ["src"],
   "compilerOptions": {
     "outDir": "dist",