@punks/backend-entity-manager 0.0.96 → 0.0.98

package/dist/cjs/index.js

@@ -21442,10 +21442,90 @@ class QueryBuilderBase {
     }
 }
 
+class QueryClauseBuilder {
+    stringFilter(filter) {
+        const clauses = [];
+        if (!!filter?.gte) {
+            clauses.push(typeorm.MoreThanOrEqual(filter.gte));
+        }
+        if (!!filter?.gt) {
+            clauses.push(typeorm.MoreThan(filter.gt));
+        }
+        if (!!filter?.lte) {
+            clauses.push(typeorm.LessThanOrEqual(filter.lte));
+        }
+        if (!!filter?.lt) {
+            clauses.push(typeorm.LessThan(filter.lt));
+        }
+        if (!!filter?.in) {
+            clauses.push(typeorm.In(filter.in));
+        }
+        if (!!filter?.eq) {
+            clauses.push(typeorm.Equal(filter.eq));
+        }
+        if (!!filter?.like) {
+            clauses.push(typeorm.Like(filter.like.replaceAll("*", "%")));
+        }
+        if (!!filter?.ne) {
+            clauses.push(typeorm.Not(typeorm.Equal(filter.ne)));
+        }
+        if (!!filter?.notIn) {
+            clauses.push(typeorm.Not(typeorm.In(filter.notIn)));
+        }
+        if (!!filter?.notLike) {
+            clauses.push(typeorm.Not(typeorm.Like(filter.notLike.replaceAll("*", "%"))));
+        }
+        return typeorm.And(...clauses);
+    }
+    numericFilter(filter) {
+        const clauses = [];
+        if (!!filter?.gte) {
+            clauses.push(typeorm.MoreThanOrEqual(filter.gte));
+        }
+        if (!!filter?.gt) {
+            clauses.push(typeorm.MoreThan(filter.gt));
+        }
+        if (!!filter?.lte) {
+            clauses.push(typeorm.LessThanOrEqual(filter.lte));
+        }
+        if (!!filter?.lt) {
+            clauses.push(typeorm.LessThan(filter.lt));
+        }
+        return typeorm.And(...clauses);
+    }
+    dateFilter(filter) {
+        const clauses = [];
+        if (!!filter?.gte) {
+            clauses.push(typeorm.MoreThanOrEqual(filter.gte));
+        }
+        if (!!filter?.gt) {
+            clauses.push(typeorm.MoreThan(filter.gt));
+        }
+        if (!!filter?.lte) {
+            clauses.push(typeorm.LessThanOrEqual(filter.lte));
+        }
+        if (!!filter?.lt) {
+            clauses.push(typeorm.LessThan(filter.lt));
+        }
+        return typeorm.And(...clauses);
+    }
+    boolFilter(filter) {
+        const clauses = [];
+        if (!backendCore.isNullOrUndefined(filter?.eq)) {
+            clauses.push(typeorm.Equal(filter.eq));
+        }
+        if (!backendCore.isNullOrUndefined(filter?.ne)) {
+            clauses.push(typeorm.Not(typeorm.Equal(filter.ne)));
+        }
+        return typeorm.And(...clauses);
+    }
+}
+
 class TypeOrmQueryBuilder extends QueryBuilderBase {
     constructor(services) {
         super();
         this.services = services;
+        this.clause = new QueryClauseBuilder();
     }
     async exists(filters, context) {
         return (await this.count(filters, context)) > 0;
@@ -21469,7 +21549,9 @@ class TypeOrmQueryBuilder extends QueryBuilderBase {
         // todo: execute inside read transaction in order to perform the three queries on the same dataset
         const queryResults = await this.countQueryResults(request, context);
         const results = await this.findPagedQueryResults(request, context);
-        const facets = await this.calculateFacets(request, context);
+        const facets = request.options?.includeFacets
+            ? await this.calculateFacets(request, context)
+            : undefined;
         return {
             items: results,
             request,
@@ -21481,6 +21563,9 @@ class TypeOrmQueryBuilder extends QueryBuilderBase {
             facets,
         };
     }
+    async getFieldFacet() {
+        this.getRepository().find({});
+    }
     async findPagedQueryResults(request, context) {
         return await this.getRepository().find({
             where: {
@@ -21510,15 +21595,15 @@ class TypeOrmQueryBuilder extends QueryBuilderBase {
             },
         });
     }
-    // protected calculateFacet(
-    //   request: TEntitySearchParameters,
-    //   context: IAuthenticationContext<TUserContext> | undefined
-    // ) {
-    //   const repo = this.getRepository().getInnerRepository()
-    //   repo.createQueryBuilder().relation("xx").select([]).where({
-    //     whereFactory:
-    //   }).groupBy().getRawMany()
-    // }
+    async calculateFacet(field, request, context) {
+        const values = await this.getRepository().distinct(field, {
+            ...(context ? this.buildContextFilter(context) : {}),
+            ...this.buildWhereClause(request),
+        });
+        return {
+            values,
+        };
+    }
     getRepository() {
         if (!this.repository) {
             this.repository = this.services.resolveRepository();
@@ -21535,6 +21620,20 @@ class TypeOrmRepository {
     getInnerRepository() {
         return this.innerRepository;
     }
+    async distinct(field, condition) {
+        this.logger.debug("Getting distinct values", { field });
+        const columnName = this.innerRepository.metadata.findColumnWithPropertyName(field)?.databaseName;
+        if (!columnName) {
+            throw new Error(`Column '${field}' not found`);
+        }
+        const results = await this.innerRepository
+            .createQueryBuilder()
+            .select(`DISTINCT ${columnName}`)
+            .where(condition)
+            .orderBy(columnName)
+            .getRawMany();
+        return results.map((x) => x[columnName]);
+    }
     async exists(id) {
         if (backendCore.isNullOrUndefined(id)) {
             throw new Error("Invalid 'id' parameter.");