@punks/backend-entity-manager 0.0.315 → 0.0.316

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

@@ -1,5 +1,7 @@
+import { IAuthenticationContext } from "../../../abstractions/authentication";
 export type FacetValueType<T> = {
     value: T;
+    label: string;
     count: number;
 };
 export type FacetType<T> = {
@@ -9,3 +11,13 @@ export type StringFacetsType = FacetType<string>;
 export type NumberFacetsType = FacetType<number>;
 export type BooleanFacetsType = FacetType<boolean>;
 export type DateFacetsType = FacetType<Date>;
+export type FacetRelations = {
+    columns: string[];
+};
+export type FacetBuilderInput<TEntity, TEntitySearchParameters, TUserContext> = {
+    field: keyof TEntity;
+    request: TEntitySearchParameters;
+    context: IAuthenticationContext<TUserContext> | undefined;
+    relations?: FacetRelations;
+    labelSelector?: string[];
+};

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

@@ -1,2 +1,3 @@
 export { TypeOrmQueryBuilder } from "./queryBuilder";
 export { TypeOrmRepository } from "./repository";
+export * from "./facets";

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

@@ -6,13 +6,10 @@ import { TypeOrmRepository } from "./repository";
 import { EntityServiceLocator } from "../../../providers/services";
 import { IEntitiesDeleteResult } from "../../../abstractions/repository";
 import { QueryClauseBuilder } from "./queryClauseBuilder";
-import { BooleanFacetsType, FacetType, NumberFacetsType, StringFacetsType } from "./facets";
+import { BooleanFacetsType, FacetRelations, FacetType, NumberFacetsType, FacetBuilderInput, StringFacetsType } from "./facets";
 import { QueryBuilderOperation } from "../../../templates/queryBuilder";
 import { ChildrenMap } from "./traverse";
 import { PermissionsChecker } from "./permissionsChecker";
-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;
@@ -48,10 +45,10 @@ export declare abstract class TypeOrmQueryBuilder<TEntity extends ObjectLiteral,
         idField: TField;
         parentField: TField;
     }): Promise<ChildrenMap>;
-    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 calculateStringFieldFacets({ field, request, context, relations, }: FacetBuilderInput<TEntity, TEntitySearchParameters, TUserContext>): Promise<StringFacetsType>;
+    protected calculateNumericFieldFacets({ field, request, context, relations, }: FacetBuilderInput<TEntity, TEntitySearchParameters, TUserContext>): Promise<NumberFacetsType>;
     protected calculateBooleanFieldFacets(field: keyof TEntity, request: TEntitySearchParameters, context: IAuthenticationContext<TUserContext> | undefined, relations?: FacetRelations): Promise<BooleanFacetsType>;
-    protected calculateFacet<TField extends keyof TEntity, TValue>(field: TField, request: TEntitySearchParameters, context: IAuthenticationContext<TUserContext> | undefined, relations?: FacetRelations): Promise<FacetType<TValue>>;
+    protected calculateFacet<TValue>({ field, request, context, relations, labelSelector, }: FacetBuilderInput<TEntity, TEntitySearchParameters, TUserContext>): Promise<FacetType<TValue>>;
     protected getRepository(): TypeOrmRepository<TEntity, unknown>;
     private buildSearchRelations;
     private buildWhere;

package/dist/esm/index.js

@@ -3283,16 +3283,31 @@ class TypeOrmQueryBuilder extends QueryBuilderBase {
             return acc;
         }, {});
     }
-    async calculateStringFieldFacets(field, request, context, relations) {
-        return await this.calculateFacet(field, request, context, relations);
+    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 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);
+        return await this.calculateFacet({
+            field,
+            request,
+            context,
+            relations,
+        });
     }
-    async calculateFacet(field, request, context, relations) {
+    async calculateFacet({ field, request, context, relations, labelSelector, }) {
         let query = this.getRepository()
             .getInnerRepository()
             .createQueryBuilder("entity");
@@ -3300,16 +3315,21 @@ class TypeOrmQueryBuilder extends QueryBuilderBase {
             query = query.leftJoin(`entity.${relation}`, relation);
         }
         const fieldName = `"${field}"`;
-        const results = await query
+        query = query
             .select(fieldName, "value")
             .addSelect(`COUNT(${fieldName})`, "count")
             .where(this.buildWhere(request, context))
-            .addGroupBy(fieldName)
-            .orderBy(fieldName)
-            .getRawMany();
+            .addGroupBy(fieldName);
+        if (labelSelector) {
+            query
+                .addSelect(labelSelector.join("."), "label")
+                .addGroupBy(labelSelector.join("."));
+        }
+        const results = await query.orderBy(fieldName).getRawMany();
         return {
             values: results.map((x) => ({
                 value: x.value,
+                label: String(x.label ?? x.value ?? ""),
                 count: Number(x.count),
             })),
         };