@punks/backend-entity-manager 0.0.164 → 0.0.166

package/dist/cjs/types/integrations/repository/typeorm/queryBuilder.d.ts

@@ -8,6 +8,9 @@ import { IEntitiesDeleteResult } from "../../../abstractions/repository";
 import { QueryClauseBuilder } from "./queryClauseBuilder";
 import { BooleanFacetsType, FacetType, NumberFacetsType, StringFacetsType } from "./facets";
 import { QueryBuilderOperation } from "../../../templates/queryBuilder";
+export type FacetRelations = {
+    columns: string[];
+};
 export declare abstract class TypeOrmQueryBuilder<TEntity extends ObjectLiteral, TEntityId, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, number>, TSorting extends SortingType, TFacets extends IEntityFacets, TUserContext> extends QueryBuilderBase<TEntity, TEntityId, TEntitySearchParameters, TSorting, number, TFacets, TUserContext> {
     private readonly services;
     private repository;
@@ -32,11 +35,16 @@ export declare abstract class TypeOrmQueryBuilder<TEntity extends ObjectLiteral,
     protected countQueryResults(request: TEntitySearchParameters, context?: IAuthenticationContext<TUserContext>): Promise<number>;
     protected abstract buildSortingClause(request: TEntitySearchParameters): FindOptionsOrder<TEntity>;
     protected abstract buildWhereClause(request: TEntitySearchParameters): FindOptionsWhere<TEntity>[] | FindOptionsWhere<TEntity>;
+    protected buildTextSearchClause(request: TEntitySearchParameters): FindOptionsWhere<TEntity>[] | FindOptionsWhere<TEntity>;
     protected abstract buildContextFilter(context?: IAuthenticationContext<TUserContext>): FindOptionsWhere<TEntity>[] | FindOptionsWhere<TEntity>;
     protected abstract calculateFacets(request: TEntitySearchParameters, context?: IAuthenticationContext<TUserContext>): Promise<TFacets>;
-    protected calculateFacet<TField extends keyof TEntity, TValue>(field: TField, request: TEntitySearchParameters, context: IAuthenticationContext<TUserContext> | undefined): Promise<FacetType<TValue>>;
-    protected calculateStringFieldFacets(field: keyof TEntity, request: TEntitySearchParameters, context: IAuthenticationContext<TUserContext> | undefined): Promise<StringFacetsType>;
-    protected calculateNumericFieldFacets(field: keyof TEntity, request: TEntitySearchParameters, context: IAuthenticationContext<TUserContext> | undefined): Promise<NumberFacetsType>;
-    protected calculateBooleanFieldFacets(field: keyof TEntity, request: TEntitySearchParameters, context: IAuthenticationContext<TUserContext> | undefined): Promise<BooleanFacetsType>;
+    protected calculateFacet<TField extends keyof TEntity, TValue>(field: TField, request: TEntitySearchParameters, context: IAuthenticationContext<TUserContext> | undefined, relations?: FacetRelations): Promise<FacetType<TValue>>;
+    protected calculateStringFieldFacets(field: keyof TEntity, request: TEntitySearchParameters, context: IAuthenticationContext<TUserContext> | undefined, relations?: FacetRelations): Promise<StringFacetsType>;
+    protected calculateNumericFieldFacets(field: keyof TEntity, request: TEntitySearchParameters, context: IAuthenticationContext<TUserContext> | undefined, relations?: FacetRelations): Promise<NumberFacetsType>;
+    protected calculateBooleanFieldFacets(field: keyof TEntity, request: TEntitySearchParameters, context: IAuthenticationContext<TUserContext> | undefined, relations?: FacetRelations): Promise<BooleanFacetsType>;
     protected getRepository(): TypeOrmRepository<TEntity, unknown>;
+    private buildSearchRelations;
+    private buildWhere;
+    private mergeWhereClauses;
+    private mergeWheres;
 }

package/dist/cjs/types/platforms/nest/__test__/server/database/core/entities/crmContact.entity.d.ts

@@ -1,11 +1,13 @@
 import { AppOrganizationEntity } from "./appOrganization.entity";
 import { IMultiOrganizationEntity } from "../../../../../extensions";
+import { FooEntity } from "./foo.entity";
 export declare class CrmContactEntity implements IMultiOrganizationEntity {
     id: string;
     email: string;
     firstName: string;
     lastName: string;
     organization: AppOrganizationEntity;
+    foos?: FooEntity[];
     createdOn: Date;
     updatedOn: Date;
 }

package/dist/cjs/types/platforms/nest/__test__/server/database/core/entities/foo.entity.d.ts

@@ -1,4 +1,5 @@
 import { AppTenantEntity } from "./appTenant.entity";
+import { CrmContactEntity } from "./crmContact.entity";
 export type FooEntityId = string;
 export declare class FooEntity {
     id: FooEntityId;
@@ -6,5 +7,6 @@ export declare class FooEntity {
     uid?: string;
     age?: number;
     tenant?: AppTenantEntity;
+    contact: CrmContactEntity;
     updatedOn: Date;
 }

package/dist/cjs/types/platforms/nest/__test__/server/entities/foos/foo.query.d.ts

@@ -6,6 +6,7 @@ import { EntityManagerRegistry } from "../../../../ioc/registry";
 import { AppUserContext, AppAuthContext } from "../../infrastructure/authentication";
 export declare class FooQueryBuilder extends NestTypeOrmQueryBuilder<FooEntity, FooEntityId, FooSearchParameters, FooSorting, FooFacets, AppUserContext> {
     constructor(registry: EntityManagerRegistry);
+    protected buildTextSearchClause(request: FooSearchParameters): FindOptionsWhere<FooEntity> | FindOptionsWhere<FooEntity>[];
     protected buildContextFilter(context?: AppAuthContext | undefined): FindOptionsWhere<FooEntity> | FindOptionsWhere<FooEntity>[];
     protected buildSortingClause(request: FooSearchParameters): FindOptionsOrder<FooEntity>;
     protected buildWhereClause(request: FooSearchParameters): FindOptionsWhere<FooEntity> | FindOptionsWhere<FooEntity>[];

package/dist/esm/index.js

@@ -440,9 +440,8 @@ class EntitiesSearchAction {
         this.services = services;
     }
     async execute(request) {
-        const results = await this.services
-            .resolveSearchQuery()
-            .execute(request);
+        const searchQuery = this.services.resolveSearchQuery();
+        const results = await searchQuery.execute(request);
         const converter = this.services.resolveConverter();
         return {
             facets: results.facets,
@@ -625,7 +624,7 @@ class EntitiesDeleteCommand {
             return undefined;
         }
         const contextService = this.services.resolveAuthenticationContextProvider();
-        return await contextService.getContext();
+        return await contextService?.getContext();
     }
     async authorize() {
         const authorization = this.services.resolveAuthorizationMiddleware();
@@ -1715,7 +1714,7 @@ class EntitiesCountQuery {
             return undefined;
         }
         const contextService = this.services.resolveAuthenticationContextProvider();
-        return await contextService.getContext();
+        return await contextService?.getContext();
     }
     async authorizeSearch(context) {
         const authorization = this.services.resolveAuthorizationMiddleware();
@@ -1746,7 +1745,7 @@ class EntityExistsQuery {
             return undefined;
         }
         const contextService = this.services.resolveAuthenticationContextProvider();
-        return await contextService.getContext();
+        return await contextService?.getContext();
     }
     async authorizeSearch(context) {
         const authorization = this.services.resolveAuthorizationMiddleware();
@@ -1852,9 +1851,8 @@ class EntitiesSearchQuery {
     async execute(request) {
         const context = await this.getContext();
         await this.authorizeSearch(context);
-        const result = await this.services
-            .resolveQueryBuilder()
-            .search(request, context);
+        const queryBuilder = this.services.resolveQueryBuilder();
+        const result = await queryBuilder.search(request, context);
         const filteredEntities = await this.filterAllowedEntities(result.items, context);
         return {
             ...result,
@@ -1921,7 +1919,7 @@ class EntityVersionsSearchQuery {
             return undefined;
         }
         const contextService = this.services.resolveAuthenticationContextProvider();
-        return await contextService.getContext();
+        return await contextService?.getContext();
     }
     async authorizeSearch(context) {
         const authorization = this.services.resolveAuthorizationMiddleware();
@@ -22214,10 +22212,7 @@ class TypeOrmQueryBuilder extends QueryBuilderBase {
         const request = {
             filters,
         };
-        return await this.getRepository().deleteBy({
-            ...(context ? this.buildContextFilter(context) : {}),
-            ...this.buildWhereClause(request),
-        });
+        return await this.getRepository().deleteBy(this.buildWhere(request, context));
     }
     async find(request, context) {
         const results = await this.findPagedQueryResults({
@@ -22249,20 +22244,13 @@ class TypeOrmQueryBuilder extends QueryBuilderBase {
     }
     async getFieldDistinctValues(field, request, context) {
         return await this.getRepository().distinct(field, {
-            where: {
-                ...(context ? this.buildContextFilter(context) : {}),
-                ...this.buildWhereClause(request),
-            },
+            where: this.buildWhere(request, context),
         });
     }
     async findPagedQueryResults(request, context) {
         return await this.getRepository().find({
-            where: {
-                ...(context ? this.buildContextFilter(context) : {}),
-                ...this.buildWhereClause(request),
-            },
-            relations: request.relations ??
-                this.getRelationsToLoad(request, context, QueryBuilderOperation.Search),
+            where: this.buildWhere(request, context),
+            relations: this.buildSearchRelations(request, context),
             order: this.buildSortingClause(request),
             ...this.buildPagingParameters(request),
         });
@@ -22280,23 +22268,23 @@ class TypeOrmQueryBuilder extends QueryBuilderBase {
     }
     async countQueryResults(request, context) {
         return await this.getRepository().count({
-            where: {
-                ...(context ? this.buildContextFilter(context) : {}),
-                ...this.buildWhereClause(request),
-            },
+            where: this.buildWhere(request, context),
         });
     }
-    async calculateFacet(field, request, context) {
-        const where = {
-            ...(context ? this.buildContextFilter(context) : {}),
-            ...this.buildWhereClause(request),
-        };
-        const results = await this.getRepository()
+    buildTextSearchClause(request) {
+        return {};
+    }
+    async calculateFacet(field, request, context, relations) {
+        let query = this.getRepository()
             .getInnerRepository()
-            .createQueryBuilder()
+            .createQueryBuilder("entity");
+        for (const relation of relations?.columns ?? []) {
+            query = query.leftJoin(`entity.${relation}`, relation);
+        }
+        const results = await query
             .select(field, "value")
             .addSelect(`COUNT(${field})`, "count")
-            .where(where)
+            .where(this.buildWhere(request, context))
             .addGroupBy(field)
             .orderBy(field)
             .getRawMany();
@@ -22307,34 +22295,67 @@ class TypeOrmQueryBuilder extends QueryBuilderBase {
             })),
         };
     }
-    async calculateStringFieldFacets(field, request, context) {
-        return await this.calculateFacet(field, request, context);
-    }
-    async calculateNumericFieldFacets(field, request, context) {
-        return await this.calculateFacet(field, request, context);
-    }
-    async calculateBooleanFieldFacets(field, request, context) {
-        return await this.calculateFacet(field, request, context);
-    }
-    // protected async calculateFacet<TField extends keyof TEntity, TValue>(
-    //   field: TField,
-    //   request: TEntitySearchParameters,
-    //   context: IAuthenticationContext<TUserContext> | undefined
-    // ): Promise<Facet<TValue>> {
-    //   const values = await this.getRepository().distinct<TField, TValue>(field, {
-    //     ...(context ? this.buildContextFilter(context) : {}),
-    //     ...this.buildWhereClause(request),
-    //   } as any)
-    //   return {
-    //     values,
-    //   }
-    // }
+    async calculateStringFieldFacets(field, request, context, relations) {
+        return await this.calculateFacet(field, request, context, relations);
+    }
+    async calculateNumericFieldFacets(field, request, context, relations) {
+        return await this.calculateFacet(field, request, context, relations);
+    }
+    async calculateBooleanFieldFacets(field, request, context, relations) {
+        return await this.calculateFacet(field, request, context, relations);
+    }
     getRepository() {
         if (!this.repository) {
             this.repository = this.services.resolveRepository();
         }
         return this.repository;
     }
+    buildSearchRelations(request, context) {
+        return (request.relations ??
+            this.getRelationsToLoad(request, context, QueryBuilderOperation.Search));
+    }
+    buildWhere(request, context) {
+        return this.mergeWhereClauses(context ? this.buildContextFilter(context) : {}, this.buildWhereClause(request), this.buildTextSearchClause(request));
+    }
+    mergeWhereClauses(...clauses) {
+        return clauses.reduce((a, b) => this.mergeWheres(a, b));
+    }
+    mergeWheres(a, b) {
+        if (Array.isArray(a) && Array.isArray(b)) {
+            const result = [];
+            for (const x of a) {
+                for (const y of b) {
+                    result.push({
+                        ...x,
+                        ...y,
+                    });
+                }
+            }
+            return result;
+        }
+        if (!Array.isArray(a) && !Array.isArray(b)) {
+            return {
+                ...a,
+                ...b,
+            };
+        }
+        if (Array.isArray(a) && !Array.isArray(b)) {
+            return a.map((x) => ({
+                ...x,
+                ...b,
+            }));
+        }
+        if (!Array.isArray(a) && Array.isArray(b)) {
+            return b.map((x) => ({
+                ...a,
+                ...x,
+            }));
+        }
+        return {
+            ...a,
+            ...b,
+        };
+    }
 }
 
 class TypeOrmRepository {