@hed-hog/api-pagination 0.0.4 → 0.0.5

package/src/pagination.service.ts

@@ -111,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(
@@ -126,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 };
@@ -175,29 +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;
+        }
 
-      let [total, data] = await Promise.all([
-        (model as any).count({ where: (customQuery as any)?.where || {} }),
-        (model as any).findMany(query),
-        //this.query(model, query),
-      ]);
+        data = await (model as any).findMany(query);
+      }
 
       const lastPage = Math.ceil(total / pageSize);
 
       if (translationKey !== undefined && translationKey !== null) {
-        console.log(typeof translationKey, translationKey)
+        this.logger.debug(`Applying translations with key: ${translationKey}`);
         data = data.map((item: any) => {
           return itemTranslations(translationKey, item);
         });
@@ -212,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[] {