rez_core 1.1.2 → 1.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rez_core",
-  "version": "1.1.2",
+  "version": "1.1.4",
   "description": "",
   "author": "",
   "private": false,

package/src/module/filter/repository/saved-filter.repository.ts

@@ -72,6 +72,7 @@ export class SavedFilterRepositoryService {
       where: {
         user_id: userId,
         mapped_entity_type: entityType,
+        status: 'ACTIVE',
       },
       order: {
         modified_date: 'DESC',
@@ -84,9 +85,7 @@ export class SavedFilterRepositoryService {
     }));
   }
 
-  async getFilterById(
-    id: number,
-  ): Promise<
+  async getFilterById(id: number): Promise<
     {
       filter_attribute: string;
       filter_operator: string;

package/src/module/filter/service/filter.service.ts

@@ -23,28 +23,47 @@ export class FilterService {
   private async gettab_value_counts(
     tableName: string,
     column: string | undefined,
-    whereClauses: any[],
+    whereClauses: { query: string; params: Record<string, any> }[],
   ) {
     if (!column) return [];
 
-    const qb = this.dataSource
-      .getRepository(tableName)
-      .createQueryBuilder('e')
-      .select(`e.${column}`, 'tab_value')
-      .addSelect('COUNT(*)', 'tab_value_count')
-      .groupBy(`e.${column}`);
+    let whereSQL = '';
+    const values: any[] = [];
+
+    // Convert whereClauses to SQL
+    if (whereClauses.length > 0) {
+      const clauseParts = whereClauses.map((clause) => {
+        let parsedQuery = clause.query.replace(/\be\./g, ''); // removes e. prefix
+        Object.entries(clause.params).forEach(([key, val]) => {
+          parsedQuery = parsedQuery.replace(new RegExp(`:${key}`, 'g'), '?');
+          values.push(val);
+        });
+        return parsedQuery;
+      });
 
-    whereClauses.forEach((clause) => qb.andWhere(clause.query, clause.params));
+      whereSQL = `WHERE ${clauseParts.join(' AND ')}`;
+    }
 
-    const rows = await qb.getRawMany();
+    // Construct raw SQL
+    const rawSQL = `
+  SELECT ${column} AS tab_value, COUNT(*) AS tab_value_count
+  FROM ${tableName}
+  ${whereSQL}
+  GROUP BY ${column}
+`;
 
-    const total = rows.reduce((sum, r) => sum + parseInt(r.tab_value_count), 0);
+    const rows = await this.dataSource.query(rawSQL, values);
+
+    const total = rows.reduce(
+      (sum, r) => sum + parseInt(r.tab_value_count, 10),
+      0,
+    );
 
     return [
       { tab_value: 'All', tab_value_count: total },
       ...rows.map((r) => ({
-        tab_value: r.tab_value || 'UNKNOWN',
-        tab_value_count: parseInt(r.tab_value_count),
+        tab_value: r.tab_value ?? 'UNKNOWN',
+        tab_value_count: parseInt(r.tab_value_count, 10),
       })),
     ];
   }
@@ -131,10 +150,16 @@ export class FilterService {
       }
     }
 
-    // Final query for filtered data
-    // Final query for filtered data
-    const qb = this.dataSource.getRepository(tableName).createQueryBuilder('e');
-    dataWhere.forEach((clause) => qb.andWhere(clause.query, clause.params));
+    // Build raw SQL base
+    const qb = this.dataSource
+      .createQueryBuilder()
+      .select('e.*')
+      .from(tableName, 'e');
+
+    // Apply WHERE clauses
+    dataWhere.forEach((clause) => {
+      qb.andWhere(clause.query, clause.params);
+    });
 
     // Optional sorting
     if (Array.isArray(sortby)) {
@@ -151,7 +176,19 @@ export class FilterService {
     const size = dto.size && dto.size > 0 ? dto.size : 10;
     qb.skip((page - 1) * size).take(size);
 
-    const [entity_list, total] = await qb.getManyAndCount();
+    // Get paginated data
+    const entity_list = await qb.getRawMany();
+
+    // Count query (without pagination)
+    const countQb = this.dataSource
+      .createQueryBuilder()
+      .select('COUNT(*)', 'count')
+      .from(tableName, 'e');
+    dataWhere.forEach((clause) => {
+      countQb.andWhere(clause.query, clause.params);
+    });
+    const countResult = await countQb.getRawOne();
+    const total = parseInt(countResult.count, 10);
 
     return {
       success: true,
@@ -192,8 +229,6 @@ export class FilterService {
     if (!savedFilter) {
       throw new BadRequestException(`Saved filter not found for code: ${code}`);
     }
-
-    console.log(savedFilter);
     return savedFilter;
   }
 
@@ -300,6 +335,7 @@ export class FilterService {
     }
   }
 
+  // this can be inproved
   private buildSelectCondition(
     attr: string,
     op: string,
@@ -308,16 +344,16 @@ export class FilterService {
   ) {
     switch (op) {
       case 'equal':
-        return { query: `e.${attr} = :${key}`, params: { [key]: val } };
+        return { query: `e.${attr}_id = :${key}`, params: { [key]: val } };
 
       case 'not_equal':
-        return { query: `e.${attr} != :${key}`, params: { [key]: val } };
+        return { query: `e.${attr}_id != :${key}`, params: { [key]: val } };
 
       case 'empty':
-        return { query: `e.${attr} IS NULL`, params: {} };
+        return { query: `e.${attr}_id IS NULL`, params: {} };
 
       case 'not_empty':
-        return { query: `e.${attr} IS NOT NULL`, params: {} };
+        return { query: `e.${attr}_id IS NOT NULL`, params: {} };
 
       default:
         throw new BadRequestException(`Unsupported operator for select: ${op}`);
@@ -325,41 +361,41 @@ export class FilterService {
   }
 
   private buildMultiSelectCondition(
-    attr: string,
-    op: string,
-    val: any,
-    key: string,
-  ) {
-    switch (op) {
-      case 'equal':
-        if (!Array.isArray(val)) {
-          throw new BadRequestException(
-            `Value for multi-select must be an array for operator: ${op}`,
-          );
-        }
-        return { query: `e.${attr} IN (:...${key})`, params: { [key]: val } };
+  attr: string,
+  op: string,
+  val: any,
+  key: string,
+) {
+  if ((op === 'equal' || op === 'not_equal') && !Array.isArray(val)) {
+    throw new BadRequestException(
+      `Value for multi-select must be an array for operator: ${op}`,
+    );
+  }
 
-      case 'not_equal':
-        if (!Array.isArray(val)) {
-          throw new BadRequestException(
-            `Value for multi-select must be an array for operator: ${op}`,
-          );
-        }
-        return {
-          query: `e.${attr} NOT IN (:...${key})`,
-          params: { [key]: val },
-        };
+  switch (op) {
+    case 'equal':
+      return {
+        query: `e.${attr}_id IN (:${key})`, // ✅ use (:key)
+        params: { [key]: val },
+      };
 
-      case 'empty':
-        return { query: `e.${attr} IS NULL`, params: {} };
+    case 'not_equal':
+      return {
+        query: `e.${attr}_id NOT IN (:${key})`, // ✅ use (:key)
+        params: { [key]: val },
+      };
 
-      case 'not_empty':
-        return { query: `e.${attr} IS NOT NULL`, params: {} };
+    case 'empty':
+      return { query: `e.${attr}_id IS NULL`, params: {} };
 
-      default:
-        throw new BadRequestException(
-          `Unsupported operator for multiselect: ${op}`,
-        );
-    }
+    case 'not_empty':
+      return { query: `e.${attr}_id IS NOT NULL`, params: {} };
+
+    default:
+      throw new BadRequestException(
+        `Unsupported operator for multiselect: ${op}`,
+      );
   }
 }
+
+}