@punks/backend-entity-manager 0.0.96 → 0.0.98

package/dist/cjs/types/__test__/entity/foo.d.ts

@@ -6,9 +6,9 @@ import { IEntitiesSearchResults } from "../../models";
 import { EntityServiceLocator } from "../../providers/services";
 import { InMemoryRepository } from "../../testing/mocks/repository";
 import { EntitySerializerSheetDefinition, IAuthenticationContext, IEntityManager } from "../../abstractions";
-import { FooDeleteParameters } from "../providers/typeorm/entity/foo";
 import { IEntitiesDeleteResult } from "../../abstractions/repository";
 import { EntitySerializer } from "../../base";
+import { FooDeleteParameters } from "../providers/typeorm/models/foo";
 export interface FooEntity {
     id: string;
     name: string;

package/dist/cjs/types/__test__/providers/typeorm/converter/foo.d.ts

@@ -0,0 +1,9 @@
+import { IEntityConverter } from "../../../../abstractions";
+import { FooEntity } from "../entity/foo";
+import { FooCreateInput, FooDto, FooListItemDto, FooUpdateInput } from "../models/foo";
+export declare class FooConverter implements IEntityConverter<FooEntity, FooDto, FooListItemDto, FooCreateInput, FooUpdateInput> {
+    toListItemDto(entity: FooEntity): FooListItemDto;
+    toEntityDto(entity: FooEntity): FooDto;
+    createDtoToEntity(input: FooCreateInput): Partial<FooEntity>;
+    updateDtoToEntity(input: FooUpdateInput): Partial<FooEntity>;
+}

package/dist/cjs/types/__test__/providers/typeorm/entity/foo.d.ts

@@ -1,89 +1,7 @@
-import { DataSource, Repository, FindOptionsWhere } from "typeorm";
-import { EntitySerializerSheetDefinition, IAuthenticationContext, IEntityConverter, IEntityManager, IEntityManagerServiceRoot, IEntitySearchParameters, ISearchSorting, ISearchSortingField, SortDirection } from "../../../../abstractions";
-import { TypeOrmRepository } from "../../../../integrations/repository/typeorm";
-import { EntityServiceLocator } from "../../../../providers/services";
-import { TypeOrmQueryBuilder } from "../../../../integrations/repository/typeorm";
-import { IEntitiesDeleteParameters } from "../../../../abstractions/commands";
-import { EntitySerializer } from "../../../../base";
 export declare class FooEntity {
     id: string;
     name: string;
     age: number;
+    enabled: boolean;
     updatedOn: Date;
 }
-export type FooEntityManager = IEntityManager<FooEntity, string, Partial<FooEntity>, Partial<FooEntity>, FooDeleteParameters, FooSearchParameters, FooSorting, FooCursor, FooFacets>;
-export declare class FooTypeOrmRepo extends TypeOrmRepository<FooEntity, string> {
-    constructor(repository: Repository<FooEntity>);
-}
-export interface FooSearchFilters {
-    minAge?: number;
-    maxAge?: number;
-}
-export declare enum FooSorting {
-    Name = "Name",
-    Age = "Age"
-}
-export type FooCursor = number;
-export interface FooSearchParameters extends IEntitySearchParameters<FooSorting, FooCursor> {
-    filters?: FooSearchFilters;
-}
-export interface FooSearchSortingField extends ISearchSortingField<FooSorting> {
-    field: FooSorting;
-    direction: SortDirection;
-}
-export interface FooQuerySorting extends ISearchSorting<FooSorting> {
-    fields: FooSearchSortingField[];
-}
-export interface FooDeleteParameters extends IEntitiesDeleteParameters<FooSorting> {
-    filters?: FooSearchFilters;
-    sorting?: FooQuerySorting;
-}
-export interface FooFacets {
-}
-export declare class FooQueryBuilder extends TypeOrmQueryBuilder<FooEntity, FooSearchParameters, FooSorting, FooFacets, unknown> {
-    constructor(services: EntityServiceLocator<FooEntity, string>);
-    protected buildContextFilter(context?: IAuthenticationContext<unknown> | undefined): FindOptionsWhere<FooEntity> | FindOptionsWhere<FooEntity>[];
-    protected buildWhereClause(request: FooSearchParameters): FindOptionsWhere<FooEntity> | FindOptionsWhere<FooEntity>[];
-    private buildAgeWhereClause;
-    protected calculateFacets(request: FooSearchParameters): Promise<FooFacets | undefined>;
-}
-export interface FooDto {
-    id: string;
-    profile: {
-        name: string;
-        age: number;
-    };
-    updatedOn: Date;
-}
-export interface FooListItemDto {
-    id: string;
-    profile: {
-        name: string;
-        age: number;
-    };
-}
-export interface FooCreateInput {
-    profile: {
-        name: string;
-        age: number;
-    };
-}
-export interface FooUpdateInput {
-    id: string;
-    profile: {
-        name: string;
-        age: number;
-    };
-}
-export declare class FooConverter implements IEntityConverter<FooEntity, FooDto, FooListItemDto, FooCreateInput, FooUpdateInput> {
-    toListItemDto(entity: FooEntity): FooListItemDto;
-    toEntityDto(entity: FooEntity): FooDto;
-    createDtoToEntity(input: FooCreateInput): Partial<FooEntity>;
-    updateDtoToEntity(input: FooUpdateInput): Partial<FooEntity>;
-}
-export declare class FooSerializer extends EntitySerializer<FooEntity, string> {
-    protected getDefinition(): EntitySerializerSheetDefinition<FooEntity>;
-}
-export declare const registerFooTypeOrmEntity: (container: IEntityManagerServiceRoot, dataSource: DataSource, options?: {
-    useConverter?: boolean;
-}) => import("../../../../abstractions").IEntityManagerServiceCollection<FooEntity, string>;

package/dist/cjs/types/__test__/providers/typeorm/init/foo.d.ts

@@ -0,0 +1,6 @@
+import { DataSource } from "typeorm";
+import { IEntityManagerServiceRoot } from "../../../../abstractions";
+import { FooEntity } from "../entity/foo";
+export declare const registerFooTypeOrmEntity: (container: IEntityManagerServiceRoot, dataSource: DataSource, options?: {
+    useConverter?: boolean;
+}) => import("../../../../abstractions").IEntityManagerServiceCollection<FooEntity, string>;

package/dist/cjs/types/__test__/providers/typeorm/manager/foo.d.ts

@@ -0,0 +1,4 @@
+import { IEntityManager } from "../../../../abstractions/manager";
+import { FooEntity } from "../entity/foo";
+import { FooCursor, FooDeleteParameters, FooFacets, FooSearchParameters, FooSorting } from "../models/foo";
+export type FooEntityManager = IEntityManager<FooEntity, string, Partial<FooEntity>, Partial<FooEntity>, FooDeleteParameters, FooSearchParameters, FooSorting, FooCursor, FooFacets>;

package/dist/cjs/types/__test__/providers/typeorm/models/foo.d.ts

@@ -0,0 +1,56 @@
+import { IEntitiesDeleteParameters, IEntitySearchParameters, ISearchSorting, ISearchSortingField, SortDirection } from "../../../../abstractions";
+import { BooleanFilter, NumericFilter, StringFilter } from "../../../../integrations/repository/typeorm/clause";
+export interface FooSearchFilters {
+    age?: NumericFilter;
+    name?: StringFilter;
+    enabled?: BooleanFilter;
+}
+export declare enum FooSorting {
+    Name = "Name",
+    Age = "Age"
+}
+export type FooCursor = number;
+export interface FooSearchParameters extends IEntitySearchParameters<FooSorting, FooCursor> {
+    filters?: FooSearchFilters;
+}
+export interface FooSearchSortingField extends ISearchSortingField<FooSorting> {
+    field: FooSorting;
+    direction: SortDirection;
+}
+export interface FooQuerySorting extends ISearchSorting<FooSorting> {
+    fields: FooSearchSortingField[];
+}
+export interface FooDeleteParameters extends IEntitiesDeleteParameters<FooSorting> {
+    filters?: FooSearchFilters;
+    sorting?: FooQuerySorting;
+}
+export interface FooFacets {
+}
+export interface FooDto {
+    id: string;
+    profile: {
+        name: string;
+        age: number;
+    };
+    updatedOn: Date;
+}
+export interface FooListItemDto {
+    id: string;
+    profile: {
+        name: string;
+        age: number;
+    };
+}
+export interface FooCreateInput {
+    profile: {
+        name: string;
+        age: number;
+    };
+}
+export interface FooUpdateInput {
+    id: string;
+    profile: {
+        name: string;
+        age: number;
+    };
+}

package/dist/cjs/types/__test__/providers/typeorm/queries/foo.d.ts

@@ -0,0 +1,12 @@
+import { FindOptionsWhere } from "typeorm";
+import { IAuthenticationContext } from "../../../../abstractions";
+import { TypeOrmQueryBuilder } from "../../../../integrations";
+import { EntityServiceLocator } from "../../../../providers/services";
+import { FooEntity } from "../entity/foo";
+import { FooFacets, FooSearchParameters, FooSorting } from "../models/foo";
+export declare class FooQueryBuilder extends TypeOrmQueryBuilder<FooEntity, FooSearchParameters, FooSorting, FooFacets, unknown> {
+    constructor(services: EntityServiceLocator<FooEntity, string>);
+    protected buildContextFilter(context?: IAuthenticationContext<unknown> | undefined): FindOptionsWhere<FooEntity> | FindOptionsWhere<FooEntity>[];
+    protected buildWhereClause(request: FooSearchParameters): FindOptionsWhere<FooEntity> | FindOptionsWhere<FooEntity>[];
+    protected calculateFacets(request: FooSearchParameters): Promise<FooFacets>;
+}

package/dist/cjs/types/__test__/providers/typeorm/repository/foo.d.ts

@@ -0,0 +1,6 @@
+import { Repository } from "typeorm";
+import { TypeOrmRepository } from "../../../../integrations";
+import { FooEntity } from "../entity/foo";
+export declare class FooTypeOrmRepo extends TypeOrmRepository<FooEntity, string> {
+    constructor(repository: Repository<FooEntity>);
+}

package/dist/cjs/types/__test__/providers/typeorm/serializer/foo.d.ts

@@ -0,0 +1,6 @@
+import { EntitySerializerSheetDefinition } from "../../../../abstractions";
+import { EntitySerializer } from "../../../../base";
+import { FooEntity } from "../entity/foo";
+export declare class FooSerializer extends EntitySerializer<FooEntity, string> {
+    protected getDefinition(): EntitySerializerSheetDefinition<FooEntity>;
+}

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

@@ -0,0 +1,32 @@
+export type NumericFilter = {
+    in?: number[];
+    eq?: number;
+    gt?: number;
+    gte?: number;
+    lt?: number;
+    lte?: number;
+};
+export type StringFilter = {
+    gt?: string;
+    gte?: string;
+    lt?: string;
+    lte?: string;
+    in?: string[];
+    eq?: string;
+    like?: string;
+    ne?: string;
+    notIn?: string[];
+    notLike?: string;
+};
+export type BooleanFilter = {
+    eq?: boolean;
+    ne?: boolean;
+};
+export type DateFilter = {
+    in?: Date[];
+    eq?: Date;
+    gt?: Date;
+    gte?: Date;
+    lt?: Date;
+    lte?: Date;
+};

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

@@ -0,0 +1,7 @@
+export type Facet<T> = {
+    values: T[];
+};
+export type StringFacets = Facet<string>;
+export type NumberFacets = Facet<number>;
+export type BooleanFacets = Facet<boolean>;
+export type DateFacets = Facet<Date>;

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

@@ -5,14 +5,18 @@ import { QueryBuilderBase } from "../../../templates";
 import { TypeOrmRepository } from "./repository";
 import { EntityServiceLocator } from "../../../providers/services";
 import { IEntitiesDeleteResult } from "../../../abstractions/repository";
+import { QueryClauseBuilder } from "./queryClauseBuilder";
+import { Facet } from "./facets";
 export declare abstract class TypeOrmQueryBuilder<TEntity extends ObjectLiteral, TEntitySearchParameters extends IEntitySearchParameters<TSorting, number>, TSorting extends SortingType, TFacets extends IEntityFacets, TUserContext> extends QueryBuilderBase<TEntity, TEntitySearchParameters, TSorting, number, TFacets, TUserContext> {
     private readonly services;
     private repository;
+    protected clause: QueryClauseBuilder;
     constructor(services: EntityServiceLocator<TEntity, unknown>);
     exists(filters: NonNullable<TEntitySearchParameters["filters"]>, context?: IAuthenticationContext<TUserContext> | undefined): Promise<boolean>;
     count(filters: NonNullable<TEntitySearchParameters["filters"]>, context?: IAuthenticationContext<TUserContext> | undefined): Promise<number>;
     delete(filters: NonNullable<TEntitySearchParameters["filters"]>, context?: IAuthenticationContext<TUserContext> | undefined): Promise<IEntitiesDeleteResult>;
     search(request: TEntitySearchParameters, context?: IAuthenticationContext<TUserContext>): Promise<IEntitiesSearchResults<TEntitySearchParameters, TEntity, TSorting, number, TFacets>>;
+    protected getFieldFacet(): Promise<void>;
     protected findPagedQueryResults(request: TEntitySearchParameters, context?: IAuthenticationContext<TUserContext>): Promise<TEntity[]>;
     protected getRelationsToLoad(request: TEntitySearchParameters, context: IAuthenticationContext<TUserContext> | undefined): FindOptionsRelations<TEntity> | undefined;
     protected buildPagingParameters(request: TEntitySearchParameters): {
@@ -22,6 +26,7 @@ export declare abstract class TypeOrmQueryBuilder<TEntity extends ObjectLiteral,
     protected countQueryResults(request: TEntitySearchParameters, context?: IAuthenticationContext<TUserContext>): Promise<number>;
     protected abstract buildWhereClause(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 | undefined>;
+    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<Facet<TValue>>;
     protected getRepository(): TypeOrmRepository<TEntity, unknown>;
 }

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

@@ -0,0 +1,8 @@
+import { FindOperator } from "typeorm";
+import { BooleanFilter, DateFilter, NumericFilter, StringFilter } from "./clause";
+export declare class QueryClauseBuilder {
+    stringFilter(filter: StringFilter): FindOperator<string>;
+    numericFilter(filter: NumericFilter): FindOperator<number>;
+    dateFilter(filter: DateFilter): FindOperator<Date>;
+    boolFilter(filter: BooleanFilter): FindOperator<boolean>;
+}

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

@@ -8,6 +8,7 @@ export declare class TypeOrmRepository<TEntity extends ObjectLiteral, TEntityId>
     private readonly logger;
     constructor(innerRepository: Repository<TEntity>);
     getInnerRepository(): Repository<TEntity>;
+    distinct<TField extends keyof TEntity, TValue>(field: TField, condition: FindManyOptions<TEntity>): Promise<any[]>;
     exists(id: TEntityId): Promise<boolean>;
     existsBy(condition: FindOneOptions<TEntity>): Promise<boolean>;
     get(id: TEntityId): Promise<TEntity | undefined>;

package/dist/cjs/types/platforms/nest/__test__/server/entities/appCompanies/appCompany.query.d.ts

@@ -7,5 +7,5 @@ export declare class AppCompanyQueryBuilder extends NestTypeOrmQueryBuilder<AppC
     constructor(registry: EntityManagerRegistry);
     protected buildContextFilter(context?: IAuthenticationContext<AppAuthContext> | undefined): FindOptionsWhere<AppCompanyEntity> | FindOptionsWhere<AppCompanyEntity>[];
     protected buildWhereClause(request: AppCompanySearchParameters): FindOptionsWhere<AppCompanyEntity> | FindOptionsWhere<AppCompanyEntity>[];
-    protected calculateFacets(request: AppCompanySearchParameters): Promise<AppCompanyFacets | undefined>;
+    protected calculateFacets(request: AppCompanySearchParameters): Promise<AppCompanyFacets>;
 }

package/dist/cjs/types/platforms/nest/__test__/server/entities/appDivisions/appDivision.query.d.ts

@@ -7,5 +7,5 @@ export declare class AppDivisionQueryBuilder extends NestTypeOrmQueryBuilder<App
     constructor(registry: EntityManagerRegistry);
     protected buildContextFilter(context?: IAuthenticationContext<AppAuthContext> | undefined): FindOptionsWhere<AppDivisionEntity> | FindOptionsWhere<AppDivisionEntity>[];
     protected buildWhereClause(request: AppDivisionSearchParameters): FindOptionsWhere<AppDivisionEntity> | FindOptionsWhere<AppDivisionEntity>[];
-    protected calculateFacets(request: AppDivisionSearchParameters): Promise<AppDivisionFacets | undefined>;
+    protected calculateFacets(request: AppDivisionSearchParameters): Promise<AppDivisionFacets>;
 }

package/dist/cjs/types/platforms/nest/__test__/server/entities/appOrganizations/appOrganization.query.d.ts

@@ -7,5 +7,5 @@ export declare class AppOrganizationQueryBuilder extends NestTypeOrmQueryBuilder
     constructor(registry: EntityManagerRegistry);
     protected buildContextFilter(context?: IAuthenticationContext<AppAuthContext> | undefined): FindOptionsWhere<AppOrganizationEntity> | FindOptionsWhere<AppOrganizationEntity>[];
     protected buildWhereClause(request: AppOrganizationSearchParameters): FindOptionsWhere<AppOrganizationEntity> | FindOptionsWhere<AppOrganizationEntity>[];
-    protected calculateFacets(request: AppOrganizationSearchParameters): Promise<AppOrganizationFacets | undefined>;
+    protected calculateFacets(request: AppOrganizationSearchParameters): Promise<AppOrganizationFacets>;
 }

package/dist/cjs/types/platforms/nest/__test__/server/entities/appRoles/appRole.query.d.ts

@@ -7,6 +7,6 @@ export declare class AppRoleQueryBuilder extends NestTypeOrmQueryBuilder<AppRole
     constructor(registry: EntityManagerRegistry);
     protected buildContextFilter(context?: IAuthenticationContext<AppAuthContext> | undefined): FindOptionsWhere<AppRoleEntity> | FindOptionsWhere<AppRoleEntity>[];
     protected buildWhereClause(request: AppRoleSearchParameters, context?: IAuthenticationContext<AppAuthContext> | undefined): FindOptionsWhere<AppRoleEntity> | FindOptionsWhere<AppRoleEntity>[];
-    protected calculateFacets(request: AppRoleSearchParameters): Promise<AppRoleFacets | undefined>;
+    protected calculateFacets(request: AppRoleSearchParameters): Promise<AppRoleFacets>;
     protected getRelationsToLoad(request: AppRoleSearchParameters, context?: IAuthenticationContext<AppAuthContext> | undefined): FindOptionsRelations<AppRoleEntity> | undefined;
 }

package/dist/cjs/types/platforms/nest/__test__/server/entities/appTenants/appTenant.query.d.ts

@@ -7,5 +7,5 @@ export declare class AppTenantQueryBuilder extends NestTypeOrmQueryBuilder<AppTe
     constructor(registry: EntityManagerRegistry);
     protected buildContextFilter(context?: IAuthenticationContext<AppAuthContext> | undefined): FindOptionsWhere<AppTenantEntity> | FindOptionsWhere<AppTenantEntity>[];
     protected buildWhereClause(request: AppTenantSearchParameters): FindOptionsWhere<AppTenantEntity> | FindOptionsWhere<AppTenantEntity>[];
-    protected calculateFacets(request: AppTenantSearchParameters): Promise<AppTenantFacets | undefined>;
+    protected calculateFacets(request: AppTenantSearchParameters): Promise<AppTenantFacets>;
 }

package/dist/cjs/types/platforms/nest/__test__/server/entities/appUserGroupMembers/appUserGroupMember.query.d.ts

@@ -7,5 +7,5 @@ export declare class AppUserGroupMemberQueryBuilder extends NestTypeOrmQueryBuil
     constructor(registry: EntityManagerRegistry);
     protected buildContextFilter(context?: IAuthenticationContext<AppAuthContext> | undefined): FindOptionsWhere<AppUserGroupMemberEntity> | FindOptionsWhere<AppUserGroupMemberEntity>[];
     protected buildWhereClause(request: AppUserGroupMemberSearchParameters): FindOptionsWhere<AppUserGroupMemberEntity> | FindOptionsWhere<AppUserGroupMemberEntity>[];
-    protected calculateFacets(request: AppUserGroupMemberSearchParameters): Promise<AppUserGroupMemberFacets | undefined>;
+    protected calculateFacets(request: AppUserGroupMemberSearchParameters): Promise<AppUserGroupMemberFacets>;
 }

package/dist/cjs/types/platforms/nest/__test__/server/entities/appUserGroups/appUserGroup.query.d.ts

@@ -7,5 +7,5 @@ export declare class AppUserGroupQueryBuilder extends NestTypeOrmQueryBuilder<Ap
     constructor(registry: EntityManagerRegistry);
     protected buildContextFilter(context?: IAuthenticationContext<AppAuthContext> | undefined): FindOptionsWhere<AppUserGroupEntity> | FindOptionsWhere<AppUserGroupEntity>[];
     protected buildWhereClause(request: AppUserGroupSearchParameters): FindOptionsWhere<AppUserGroupEntity> | FindOptionsWhere<AppUserGroupEntity>[];
-    protected calculateFacets(request: AppUserGroupSearchParameters): Promise<AppUserGroupFacets | undefined>;
+    protected calculateFacets(request: AppUserGroupSearchParameters): Promise<AppUserGroupFacets>;
 }

package/dist/cjs/types/platforms/nest/__test__/server/entities/appUserProfiles/appUserProfile.query.d.ts

@@ -7,5 +7,5 @@ export declare class AppUserProfileQueryBuilder extends NestTypeOrmQueryBuilder<
     constructor(registry: EntityManagerRegistry);
     protected buildContextFilter(context?: IAuthenticationContext<AppAuthContext> | undefined): FindOptionsWhere<AppUserProfileEntity> | FindOptionsWhere<AppUserProfileEntity>[];
     protected buildWhereClause(request: AppUserProfileSearchParameters): FindOptionsWhere<AppUserProfileEntity> | FindOptionsWhere<AppUserProfileEntity>[];
-    protected calculateFacets(request: AppUserProfileSearchParameters): Promise<AppUserProfileFacets | undefined>;
+    protected calculateFacets(request: AppUserProfileSearchParameters): Promise<AppUserProfileFacets>;
 }

package/dist/cjs/types/platforms/nest/__test__/server/entities/appUserRoles/appUserRole.query.d.ts

@@ -7,6 +7,6 @@ export declare class AppUserRoleQueryBuilder extends NestTypeOrmQueryBuilder<App
     constructor(registry: EntityManagerRegistry);
     protected buildContextFilter(context?: IAuthenticationContext<AppAuthContext> | undefined): FindOptionsWhere<AppUserRoleEntity> | FindOptionsWhere<AppUserRoleEntity>[];
     protected buildWhereClause(request: AppUserRoleSearchParameters): FindOptionsWhere<AppUserRoleEntity> | FindOptionsWhere<AppUserRoleEntity>[];
-    protected calculateFacets(request: AppUserRoleSearchParameters): Promise<AppUserRoleFacets | undefined>;
+    protected calculateFacets(request: AppUserRoleSearchParameters): Promise<AppUserRoleFacets>;
     protected getRelationsToLoad(request: AppUserRoleSearchParameters, context: IAuthenticationContext<AppAuthContext> | undefined): FindOptionsRelations<AppUserRoleEntity> | undefined;
 }

package/dist/cjs/types/platforms/nest/__test__/server/entities/appUsers/appUser.query.d.ts

@@ -7,5 +7,5 @@ export declare class AppUserQueryBuilder extends NestTypeOrmQueryBuilder<AppUser
     constructor(registry: EntityManagerRegistry);
     protected buildContextFilter(context?: IAuthenticationContext<AppAuthContext> | undefined): FindOptionsWhere<AppUserEntity> | FindOptionsWhere<AppUserEntity>[];
     protected buildWhereClause(request: AppUserSearchParameters): FindOptionsWhere<AppUserEntity> | FindOptionsWhere<AppUserEntity>[];
-    protected calculateFacets(request: AppUserSearchParameters): Promise<AppUserFacets | undefined>;
+    protected calculateFacets(request: AppUserSearchParameters): Promise<AppUserFacets>;
 }

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

@@ -2,6 +2,7 @@ import { IEntitySearchParameters, ISearchSorting, ISearchSortingField, SortDirec
 import { IEntitiesSearchResults, IEntitiesSearchResultsPaging } from "../../../../../../models";
 import { FooEntity } from "../../database/core/entities/foo.entity";
 import { IEntitiesDeleteParameters } from "../../../../../../abstractions/commands";
+import { NumberFacets } from "../../../../../../integrations/repository/typeorm/facets";
 export type FooEntityId = string;
 export type FooCreateData = Partial<FooEntity>;
 export type FooUpdateData = Partial<FooEntity>;
@@ -9,6 +10,7 @@ export interface FooSearchParameters extends IEntitySearchParameters<FooSorting,
     filters?: FooSearchFilters;
 }
 export interface FooFacets {
+    age: NumberFacets;
 }
 export interface FooSearchFilters {
     minAge?: number;

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

@@ -10,5 +10,5 @@ export declare class FooQueryBuilder extends NestTypeOrmQueryBuilder<FooEntity,
     protected buildContextFilter(context?: IAuthenticationContext<AppAuthContext> | undefined): FindOptionsWhere<FooEntity> | FindOptionsWhere<FooEntity>[];
     protected buildWhereClause(request: FooSearchParameters): FindOptionsWhere<FooEntity> | FindOptionsWhere<FooEntity>[];
     private buildAgeWhereClause;
-    protected calculateFacets(request: FooSearchParameters, context?: IAuthenticationContext<AppAuthContext>): Promise<FooFacets | undefined>;
+    protected calculateFacets(request: FooSearchParameters, context?: IAuthenticationContext<AppAuthContext>): Promise<FooFacets>;
 }

package/dist/esm/index.js

@@ -9,7 +9,7 @@ import { STATIC_CONTEXT } from '@nestjs/core/injector/constants';
 import { MetadataScanner } from '@nestjs/core/metadata-scanner';
 import { JwtService, JwtModule } from '@nestjs/jwt';
 import { EventEmitter2, EventEmitterModule } from '@nestjs/event-emitter';
-import { In } from 'typeorm';
+import { MoreThanOrEqual, MoreThan, LessThanOrEqual, LessThan, In, Equal, Like, Not, And } from 'typeorm';
 import { ListObjectsCommand, PutObjectCommand, GetObjectCommand, DeleteObjectCommand, S3Client } from '@aws-sdk/client-s3';
 import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
 import { SendEmailCommand, SESClient } from '@aws-sdk/client-ses';
@@ -21434,10 +21434,90 @@ class QueryBuilderBase {
     }
 }
 
+class QueryClauseBuilder {
+    stringFilter(filter) {
+        const clauses = [];
+        if (!!filter?.gte) {
+            clauses.push(MoreThanOrEqual(filter.gte));
+        }
+        if (!!filter?.gt) {
+            clauses.push(MoreThan(filter.gt));
+        }
+        if (!!filter?.lte) {
+            clauses.push(LessThanOrEqual(filter.lte));
+        }
+        if (!!filter?.lt) {
+            clauses.push(LessThan(filter.lt));
+        }
+        if (!!filter?.in) {
+            clauses.push(In(filter.in));
+        }
+        if (!!filter?.eq) {
+            clauses.push(Equal(filter.eq));
+        }
+        if (!!filter?.like) {
+            clauses.push(Like(filter.like.replaceAll("*", "%")));
+        }
+        if (!!filter?.ne) {
+            clauses.push(Not(Equal(filter.ne)));
+        }
+        if (!!filter?.notIn) {
+            clauses.push(Not(In(filter.notIn)));
+        }
+        if (!!filter?.notLike) {
+            clauses.push(Not(Like(filter.notLike.replaceAll("*", "%"))));
+        }
+        return And(...clauses);
+    }
+    numericFilter(filter) {
+        const clauses = [];
+        if (!!filter?.gte) {
+            clauses.push(MoreThanOrEqual(filter.gte));
+        }
+        if (!!filter?.gt) {
+            clauses.push(MoreThan(filter.gt));
+        }
+        if (!!filter?.lte) {
+            clauses.push(LessThanOrEqual(filter.lte));
+        }
+        if (!!filter?.lt) {
+            clauses.push(LessThan(filter.lt));
+        }
+        return And(...clauses);
+    }
+    dateFilter(filter) {
+        const clauses = [];
+        if (!!filter?.gte) {
+            clauses.push(MoreThanOrEqual(filter.gte));
+        }
+        if (!!filter?.gt) {
+            clauses.push(MoreThan(filter.gt));
+        }
+        if (!!filter?.lte) {
+            clauses.push(LessThanOrEqual(filter.lte));
+        }
+        if (!!filter?.lt) {
+            clauses.push(LessThan(filter.lt));
+        }
+        return And(...clauses);
+    }
+    boolFilter(filter) {
+        const clauses = [];
+        if (!isNullOrUndefined(filter?.eq)) {
+            clauses.push(Equal(filter.eq));
+        }
+        if (!isNullOrUndefined(filter?.ne)) {
+            clauses.push(Not(Equal(filter.ne)));
+        }
+        return 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;
@@ -21461,7 +21541,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,
@@ -21473,6 +21555,9 @@ class TypeOrmQueryBuilder extends QueryBuilderBase {
             facets,
         };
     }
+    async getFieldFacet() {
+        this.getRepository().find({});
+    }
     async findPagedQueryResults(request, context) {
         return await this.getRepository().find({
             where: {
@@ -21502,15 +21587,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();
@@ -21527,6 +21612,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 (isNullOrUndefined(id)) {
             throw new Error("Invalid 'id' parameter.");