@punks/backend-entity-manager 0.0.96 → 0.0.98

package/dist/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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/index.d.ts

@@ -13,7 +13,7 @@ import { Reflector, ModulesContainer as ModulesContainer$1 } from '@nestjs/core'
 import { JwtService } from '@nestjs/jwt';
 import * as express from 'express';
 import { Response, Request, NextFunction } from 'express';
-import { ObjectLiteral, FindOneOptions, FindManyOptions, Repository, ObjectId, FindOptionsWhere, FindOptionsRelations } from 'typeorm';
+import { ObjectLiteral, FindOneOptions, FindManyOptions, Repository, ObjectId, FindOptionsWhere, FindOperator, FindOptionsRelations } from 'typeorm';
 import { EventEmitter2 } from '@nestjs/event-emitter';
 import * as qs from 'qs';
 import * as express_serve_static_core from 'express-serve-static-core';
@@ -1852,6 +1852,7 @@ declare class TypeOrmRepository<TEntity extends ObjectLiteral, TEntityId> implem
     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>;
@@ -1868,14 +1869,60 @@ declare class TypeOrmRepository<TEntity extends ObjectLiteral, TEntityId> implem
     upsert(id: TEntityId, entity: Partial<TEntity>): Promise<TEntity>;
 }
 
+type NumericFilter = {
+    in?: number[];
+    eq?: number;
+    gt?: number;
+    gte?: number;
+    lt?: number;
+    lte?: number;
+};
+type StringFilter = {
+    gt?: string;
+    gte?: string;
+    lt?: string;
+    lte?: string;
+    in?: string[];
+    eq?: string;
+    like?: string;
+    ne?: string;
+    notIn?: string[];
+    notLike?: string;
+};
+type BooleanFilter = {
+    eq?: boolean;
+    ne?: boolean;
+};
+type DateFilter = {
+    in?: Date[];
+    eq?: Date;
+    gt?: Date;
+    gte?: Date;
+    lt?: Date;
+    lte?: Date;
+};
+
+declare class QueryClauseBuilder {
+    stringFilter(filter: StringFilter): FindOperator<string>;
+    numericFilter(filter: NumericFilter): FindOperator<number>;
+    dateFilter(filter: DateFilter): FindOperator<Date>;
+    boolFilter(filter: BooleanFilter): FindOperator<boolean>;
+}
+
+type Facet<T> = {
+    values: T[];
+};
+
 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): {
@@ -1885,7 +1932,8 @@ declare abstract class TypeOrmQueryBuilder<TEntity extends ObjectLiteral, TEntit
     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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@punks/backend-entity-manager",
-  "version": "0.0.96",
+  "version": "0.0.98",
   "description": "",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",