@punks/backend-entity-manager 0.0.118 → 0.0.121

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

@@ -32,9 +32,10 @@ export interface FooSearchParameters extends IEntitySearchParameters<FooSorting,
 }
 export interface FooFacets {
 }
-export declare class FooQueryBuilder implements IEntitiesQueryBuilder<FooEntity, FooSearchParameters, FooSorting, FooCursor, FooFacets, unknown> {
+export declare class FooQueryBuilder implements IEntitiesQueryBuilder<FooEntity, string, FooSearchParameters, FooSorting, FooCursor, FooFacets, unknown> {
     private readonly repository;
     constructor(services: EntityServiceLocator<FooEntity, string>);
+    get(id: string): Promise<FooEntity | undefined>;
     exists(filters: FooSearchFilters, context?: IAuthenticationContext<unknown> | undefined): Promise<boolean>;
     count(filters: FooSearchFilters, context?: IAuthenticationContext<unknown> | undefined): Promise<number>;
     delete(filters: FooSearchFilters, context?: IAuthenticationContext<unknown> | undefined): Promise<IEntitiesDeleteResult>;

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

@@ -4,7 +4,7 @@ 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> {
+export declare class FooQueryBuilder extends TypeOrmQueryBuilder<FooEntity, unknown, FooSearchParameters, FooSorting, FooFacets, unknown> {
     constructor(services: EntityServiceLocator<FooEntity, string>);
     protected buildContextFilter(context?: IAuthenticationContext<unknown> | undefined): FindOptionsWhere<FooEntity> | FindOptionsWhere<FooEntity>[];
     protected buildSortingClause(request: FooSearchParameters): FindOptionsOrder<FooEntity>;

package/dist/esm/types/abstractions/configuration.d.ts

@@ -29,7 +29,7 @@ export interface IEntityManagerServiceRoot {
 }
 export interface IEntityManagerServiceCollection<TEntity, TEntityId> {
     getServiceLocator(): EntityServiceLocator<TEntity, TEntityId>;
-    mapCrudOperations<TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets, TEntitiesQueryBuilder extends IEntitiesQueryBuilder<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets, unknown>>(input: EntitiesMapOperationsInput<TEntitiesQueryBuilder>): IEntityManagerServiceCollection<TEntity, TEntityId>;
+    mapCrudOperations<TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets, TEntitiesQueryBuilder extends IEntitiesQueryBuilder<TEntity, unknown, TEntitySearchParameters, TSorting, TCursor, TFacets, unknown>>(input: EntitiesMapOperationsInput<TEntitiesQueryBuilder>): IEntityManagerServiceCollection<TEntity, TEntityId>;
     addSerializer<TEntitySerializer extends IEntitySerializer<TEntity, TEntityId>>(serializer: TEntitySerializer): IEntityManagerServiceCollection<TEntity, TEntityId>;
     addConverter<TEntityDto, TListItemDto, TEntityCreateInput, TEntityUpdateInput, TEntityConverter extends IEntityConverter<TEntity, TEntityDto, TListItemDto, TEntityCreateInput, TEntityUpdateInput>>(converter: TEntityConverter): IEntityManagerServiceCollection<TEntity, TEntityId>;
     addAdapter<TEntityCreateData, TEntityUpdateData, TEntityAdapter extends IEntityAdapter<TEntity, TEntityCreateData, TEntityUpdateData>>(adapter: TEntityAdapter): IEntityManagerServiceCollection<TEntity, TEntityId>;

package/dist/esm/types/abstractions/queries.d.ts

@@ -19,7 +19,8 @@ export interface IEntitiesCountQuery<TEntity, TEntityFilters extends ISearchFilt
 export interface IEntityVersionsSearchQuery<TEntity, TCursor> {
     execute(params: IEntityVersionsSearchParameters<TCursor>): Promise<IEntityVersionsSearchResults<TEntity, TCursor>>;
 }
-export interface IEntitiesQueryBuilder<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets, TUserContext> {
+export interface IEntitiesQueryBuilder<TEntity, TEntityId, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets, TUserContext> {
+    get(id: TEntityId, context?: IAuthenticationContext<TUserContext>): Promise<TEntity | undefined>;
     search(request: TEntitySearchParameters, context?: IAuthenticationContext<TUserContext>): Promise<IEntitiesSearchResults<TEntitySearchParameters, TEntity, TSorting, TCursor, TFacets>>;
     exists(filters: NonNullable<TEntitySearchParameters["filters"]>, context?: IAuthenticationContext<TUserContext>): Promise<boolean>;
     count(filters: NonNullable<TEntitySearchParameters["filters"]>, context?: IAuthenticationContext<TUserContext>): Promise<number>;

package/dist/esm/types/abstractions/settings.d.ts

@@ -1,6 +1,7 @@
 import { EntitiesImportExportSettings } from "./export";
 export type EntityManagerSettings = {
     importExport: EntitiesImportExportSettings;
+    defaultBuckerProvider: string;
 };
 export type EntityVersioningOptions = {
     enabled: boolean;

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

@@ -7,18 +7,19 @@ 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> {
+export declare abstract class TypeOrmQueryBuilder<TEntity extends ObjectLiteral, TEntityId, TEntitySearchParameters extends IEntitySearchParameters<TSorting, number>, TSorting extends SortingType, TFacets extends IEntityFacets, TUserContext> extends QueryBuilderBase<TEntity, TEntityId, TEntitySearchParameters, TSorting, number, TFacets, TUserContext> {
     private readonly services;
     private repository;
     protected clause: QueryClauseBuilder;
     constructor(services: EntityServiceLocator<TEntity, unknown>);
+    get(id: TEntityId, context?: IAuthenticationContext<TUserContext>): Promise<TEntity | undefined>;
     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 getRelationsToLoad(request: TEntitySearchParameters | undefined, context: IAuthenticationContext<TUserContext> | undefined): FindOptionsRelations<TEntity> | undefined;
     protected buildPagingParameters(request: TEntitySearchParameters): {
         skip: number | undefined;
         take: number | undefined;

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

@@ -1,4 +1,4 @@
-import { FindManyOptions, FindOneOptions, FindOptionsWhere, ObjectId, ObjectLiteral, Repository } from "typeorm";
+import { FindManyOptions, FindOneOptions, FindOptionsRelations, FindOptionsWhere, ObjectId, ObjectLiteral, Repository } from "typeorm";
 import { IEntityRepository } from "../../../abstractions";
 import { IEntitiesDeleteResult } from "../../../abstractions/repository";
 export type UpdateCriteria<TEntity extends ObjectLiteral> = string | string[] | number | number[] | Date | Date[] | ObjectId | ObjectId[] | FindOptionsWhere<TEntity>;
@@ -11,7 +11,9 @@ export declare class TypeOrmRepository<TEntity extends ObjectLiteral, TEntityId>
     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>;
+    get(id: TEntityId, options?: {
+        relations?: FindOptionsRelations<TEntity>;
+    }): Promise<TEntity | undefined>;
     getBy(condition: FindOneOptions<TEntity>): Promise<TEntity | undefined>;
     all(): Promise<TEntity[]>;
     count(condition: FindManyOptions<TEntity>): Promise<number>;

package/dist/esm/types/ioc/index.d.ts

@@ -2,13 +2,17 @@ import { Type } from "../abstractions/common";
 import { IResolveServiceOptions, IServiceLocator } from "../abstractions/ioc";
 export declare class ServiceLocator implements IServiceLocator {
     private services;
+    private multipleServices;
     all(): {
         [key: string]: any;
     };
     register<T>(name: string, service: T): void;
+    registerMultiple<T>(serviceName: string, instanceName: string, service: T): void;
     registerEntityService<T>(serviceName: string, entityName: string, service: T): void;
     registerEntityServiceType<T>(serviceType: Type<T>, entityName: string, service: T): void;
     resolve<T>(name: string, options?: IResolveServiceOptions): T;
+    resolveMultiple<T>(serviceName: string, options?: IResolveServiceOptions): T[];
+    resolveMultipleNamed<T>(serviceName: string, instanceName: string, options?: IResolveServiceOptions): T;
     resolveEntityService<T>(serviceName: string, entityName: string, options?: IResolveServiceOptions): T;
     resolveEntityServiceType<T>(serviceType: Type<T>, entityName: string, options?: IResolveServiceOptions): T;
     private buildServiceTypeName;

package/dist/esm/types/platforms/nest/__test__/server/app/{auth/auth.actions.d.ts → appAuth/appAuth.actions.d.ts}

@@ -1,6 +1,6 @@
 import { AuthenticationService } from "../../../../extensions";
-import { UserEmailVerifyCompleteRequest, UserEmailVerifyRequest, UserLoginRequest, UserPasswordResetCompleteRequest, UserPasswordResetRequest, UserRegisterRequest } from "./auth.dto";
-export declare class AuthActions {
+import { UserEmailVerifyCompleteRequest, UserEmailVerifyRequest, UserLoginRequest, UserPasswordResetCompleteRequest, UserPasswordResetRequest, UserRegisterRequest } from "./appAuth.dto";
+export declare class AppAuthActions {
     private readonly auth;
     constructor(auth: AuthenticationService);
     login(data: UserLoginRequest): Promise<import("../../../../extensions").UserLoginResult>;

package/dist/esm/types/platforms/nest/__test__/server/app/{auth/auth.controller.d.ts → appAuth/appAuth.controller.d.ts}

@@ -1,8 +1,8 @@
-import { AuthActions } from "./auth.actions";
-import { UserEmailVerifyCompleteRequest, UserEmailVerifyRequest, UserLoginRequest, UserLoginResponse, UserPasswordResetCompleteRequest, UserPasswordResetRequest, UserRegisterRequest, UserRegisterResponse } from "./auth.dto";
-export declare class AuthController {
+import { AppAuthActions } from "./appAuth.actions";
+import { UserEmailVerifyCompleteRequest, UserEmailVerifyRequest, UserLoginRequest, UserLoginResponse, UserPasswordResetCompleteRequest, UserPasswordResetRequest, UserRegisterRequest, UserRegisterResponse } from "./appAuth.dto";
+export declare class AppAuthController {
     private readonly actions;
-    constructor(actions: AuthActions);
+    constructor(actions: AppAuthActions);
     login(data: UserLoginRequest): Promise<UserLoginResponse>;
     register(data: UserRegisterRequest): Promise<UserRegisterResponse>;
     verify(data: UserEmailVerifyRequest): Promise<void>;

package/dist/esm/types/platforms/nest/__test__/server/app/appAuth/appAuth.module.d.ts

@@ -0,0 +1,2 @@
+export declare class AppAuthAppModule {
+}

package/dist/esm/types/platforms/nest/__test__/server/app/{auth/auth.test-controller.d.ts → appAuth/appAuth.test-controller.d.ts}

@@ -1,4 +1,4 @@
-export declare class AuthTestController {
+export declare class AppAuthTestController {
     getPublicData(): {
         data: string;
     };

package/dist/esm/types/platforms/nest/__test__/server/app/appOrganizations/appOrganization.converter.d.ts

@@ -1,6 +1,7 @@
 import { IEntityConverter } from "../../../../../..";
-import { AppOrganizationCreateDto, AppOrganizationDto, AppOrganizationListItemDto, AppOrganizationUpdateDto } from "./appOrganization.dto";
+import { AppOrganizationCreateDto, AppOrganizationDto, AppOrganizationListItemDto, AppOrganizationReferenceDto, AppOrganizationUpdateDto } from "./appOrganization.dto";
 import { AppOrganizationEntity } from "../../database/core/entities/appOrganization.entity";
+export declare const toAppOrganizationReferenceDto: (entity: AppOrganizationEntity) => AppOrganizationReferenceDto;
 export declare class AppOrganizationConverter implements IEntityConverter<AppOrganizationEntity, AppOrganizationDto, AppOrganizationListItemDto, AppOrganizationCreateDto, AppOrganizationUpdateDto> {
     toListItemDto(entity: AppOrganizationEntity): AppOrganizationListItemDto;
     toEntityDto(entity: AppOrganizationEntity): AppOrganizationDto;

package/dist/esm/types/platforms/nest/__test__/server/app/appOrganizations/appOrganization.dto.d.ts

@@ -1,4 +1,9 @@
 import { AppOrganizationSearchParameters, AppOrganizationSearchResults } from "../../entities/appOrganizations/appOrganization.models";
+export declare class AppOrganizationReferenceDto {
+    id: string;
+    uid: string;
+    name: string;
+}
 export declare class AppOrganizationDto {
     id: string;
     createdOn: Date;

package/dist/esm/types/platforms/nest/__test__/server/app/appOrganizations/appOrganization.utils.d.ts

@@ -0,0 +1,3 @@
+import { AppOrganizationEntity } from "../../database/core/entities/appOrganization.entity";
+import { AppOrganizationReferenceDto } from "./appOrganization.dto";
+export declare const toAppOrganizationReferenceDto: (entity: AppOrganizationEntity) => AppOrganizationReferenceDto;

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

@@ -1,9 +1,9 @@
 import { FindOptionsOrder, FindOptionsWhere } from "typeorm";
 import { EntityManagerRegistry, NestTypeOrmQueryBuilder } from "../../../../../..";
 import { AppCompanyEntity } from "../../database/core/entities/appCompany.entity";
-import { AppCompanyFacets, AppCompanySearchParameters, AppCompanySorting } from "./appCompany.models";
+import { AppCompanyEntityId, AppCompanyFacets, AppCompanySearchParameters, AppCompanySorting } from "./appCompany.models";
 import { AppUserContext, AppAuthContext } from "../../infrastructure/authentication/types";
-export declare class AppCompanyQueryBuilder extends NestTypeOrmQueryBuilder<AppCompanyEntity, AppCompanySearchParameters, AppCompanySorting, AppCompanyFacets, AppUserContext> {
+export declare class AppCompanyQueryBuilder extends NestTypeOrmQueryBuilder<AppCompanyEntity, AppCompanyEntityId, AppCompanySearchParameters, AppCompanySorting, AppCompanyFacets, AppUserContext> {
     constructor(registry: EntityManagerRegistry);
     protected buildContextFilter(context?: AppAuthContext | undefined): FindOptionsWhere<AppCompanyEntity> | FindOptionsWhere<AppCompanyEntity>[];
     protected buildSortingClause(request: AppCompanySearchParameters): FindOptionsOrder<AppCompanyEntity>;

package/dist/esm/types/platforms/nest/__test__/server/entities/appDirectories/appDirectory.query.d.ts

@@ -1,10 +1,10 @@
 import { FindOptionsOrder, FindOptionsWhere } from "typeorm";
 import { EntityManagerRegistry, NestTypeOrmQueryBuilder } from "../../../../../..";
 import { AppDirectoryEntity } from "../../database/core/entities/appDirectory.entity";
-import { AppDirectoryFacets, AppDirectorySorting } from "./appDirectory.models";
+import { AppDirectoryEntityId, AppDirectoryFacets, AppDirectorySorting } from "./appDirectory.models";
 import { AppDirectorySearchParameters } from "./appDirectory.types";
 import { AppUserContext, AppAuthContext } from "../../infrastructure/authentication/types";
-export declare class AppDirectoryQueryBuilder extends NestTypeOrmQueryBuilder<AppDirectoryEntity, AppDirectorySearchParameters, AppDirectorySorting, AppDirectoryFacets, AppUserContext> {
+export declare class AppDirectoryQueryBuilder extends NestTypeOrmQueryBuilder<AppDirectoryEntity, AppDirectoryEntityId, AppDirectorySearchParameters, AppDirectorySorting, AppDirectoryFacets, AppUserContext> {
     constructor(registry: EntityManagerRegistry);
     protected buildContextFilter(context?: AppAuthContext): FindOptionsWhere<AppDirectoryEntity> | FindOptionsWhere<AppDirectoryEntity>[];
     protected buildSortingClause(request: AppDirectorySearchParameters): FindOptionsOrder<AppDirectoryEntity>;

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

@@ -1,9 +1,9 @@
 import { FindOptionsOrder, FindOptionsWhere } from "typeorm";
 import { EntityManagerRegistry, NestTypeOrmQueryBuilder } from "../../../../../..";
 import { AppDivisionEntity } from "../../database/core/entities/appDivision.entity";
-import { AppDivisionFacets, AppDivisionSearchParameters, AppDivisionSorting } from "./appDivision.models";
+import { AppDivisionEntityId, AppDivisionFacets, AppDivisionSearchParameters, AppDivisionSorting } from "./appDivision.models";
 import { AppUserContext, AppAuthContext } from "../../infrastructure/authentication/types";
-export declare class AppDivisionQueryBuilder extends NestTypeOrmQueryBuilder<AppDivisionEntity, AppDivisionSearchParameters, AppDivisionSorting, AppDivisionFacets, AppUserContext> {
+export declare class AppDivisionQueryBuilder extends NestTypeOrmQueryBuilder<AppDivisionEntity, AppDivisionEntityId, AppDivisionSearchParameters, AppDivisionSorting, AppDivisionFacets, AppUserContext> {
     constructor(registry: EntityManagerRegistry);
     protected buildContextFilter(context?: AppAuthContext | undefined): FindOptionsWhere<AppDivisionEntity> | FindOptionsWhere<AppDivisionEntity>[];
     protected buildSortingClause(request: AppDivisionSearchParameters): FindOptionsOrder<AppDivisionEntity>;

package/dist/esm/types/platforms/nest/__test__/server/entities/appEntityVersions/appEntityVersion.query.d.ts

@@ -1,10 +1,10 @@
 import { FindOptionsOrder, FindOptionsWhere } from "typeorm";
 import { EntityManagerRegistry, NestTypeOrmQueryBuilder } from "../../../../../..";
 import { AppEntityVersionEntity } from "../../database/core/entities/appEntityVersion.entity";
-import { AppEntityVersionFacets, AppEntityVersionSorting } from "./appEntityVersion.models";
+import { AppEntityVersionEntityId, AppEntityVersionFacets, AppEntityVersionSorting } from "./appEntityVersion.models";
 import { AppEntityVersionSearchParameters } from "./appEntityVersion.types";
 import { AppUserContext, AppAuthContext } from "../../infrastructure/authentication/types";
-export declare class AppEntityVersionQueryBuilder extends NestTypeOrmQueryBuilder<AppEntityVersionEntity, AppEntityVersionSearchParameters, AppEntityVersionSorting, AppEntityVersionFacets, AppUserContext> {
+export declare class AppEntityVersionQueryBuilder extends NestTypeOrmQueryBuilder<AppEntityVersionEntity, AppEntityVersionEntityId, AppEntityVersionSearchParameters, AppEntityVersionSorting, AppEntityVersionFacets, AppUserContext> {
     constructor(registry: EntityManagerRegistry);
     protected buildContextFilter(context?: AppAuthContext): FindOptionsWhere<AppEntityVersionEntity> | FindOptionsWhere<AppEntityVersionEntity>[];
     protected buildSortingClause(request: AppEntityVersionSearchParameters): FindOptionsOrder<AppEntityVersionEntity>;

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

@@ -1,9 +1,9 @@
 import { FindOptionsOrder, FindOptionsWhere } from "typeorm";
 import { EntityManagerRegistry, NestTypeOrmQueryBuilder } from "../../../../../..";
 import { AppOrganizationEntity } from "../../database/core/entities/appOrganization.entity";
-import { AppOrganizationFacets, AppOrganizationSearchParameters, AppOrganizationSorting } from "./appOrganization.models";
+import { AppOrganizationEntityId, AppOrganizationFacets, AppOrganizationSearchParameters, AppOrganizationSorting } from "./appOrganization.models";
 import { AppAuthContext, AppUserContext } from "../../infrastructure/authentication/types";
-export declare class AppOrganizationQueryBuilder extends NestTypeOrmQueryBuilder<AppOrganizationEntity, AppOrganizationSearchParameters, AppOrganizationSorting, AppOrganizationFacets, AppUserContext> {
+export declare class AppOrganizationQueryBuilder extends NestTypeOrmQueryBuilder<AppOrganizationEntity, AppOrganizationEntityId, AppOrganizationSearchParameters, AppOrganizationSorting, AppOrganizationFacets, AppUserContext> {
     constructor(registry: EntityManagerRegistry);
     protected buildContextFilter(context?: AppAuthContext | undefined): FindOptionsWhere<AppOrganizationEntity> | FindOptionsWhere<AppOrganizationEntity>[];
     protected buildSortingClause(request: AppOrganizationSearchParameters): FindOptionsOrder<AppOrganizationEntity>;

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

@@ -1,9 +1,9 @@
 import { FindOptionsOrder, FindOptionsRelations, FindOptionsWhere } from "typeorm";
 import { EntityManagerRegistry, NestTypeOrmQueryBuilder } from "../../../../../..";
 import { AppRoleEntity } from "../../database/core/entities/appRole.entity";
-import { AppRoleFacets, AppRoleSearchParameters, AppRoleSorting } from "./appRole.models";
+import { AppRoleEntityId, AppRoleFacets, AppRoleSearchParameters, AppRoleSorting } from "./appRole.models";
 import { AppAuthContext, AppUserContext } from "../../infrastructure/authentication/types";
-export declare class AppRoleQueryBuilder extends NestTypeOrmQueryBuilder<AppRoleEntity, AppRoleSearchParameters, AppRoleSorting, AppRoleFacets, AppUserContext> {
+export declare class AppRoleQueryBuilder extends NestTypeOrmQueryBuilder<AppRoleEntity, AppRoleEntityId, AppRoleSearchParameters, AppRoleSorting, AppRoleFacets, AppUserContext> {
     constructor(registry: EntityManagerRegistry);
     protected buildContextFilter(context?: AppAuthContext | undefined): FindOptionsWhere<AppRoleEntity> | FindOptionsWhere<AppRoleEntity>[];
     protected buildSortingClause(request: AppRoleSearchParameters): FindOptionsOrder<AppRoleEntity>;

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

@@ -1,9 +1,9 @@
 import { FindOptionsOrder, FindOptionsWhere } from "typeorm";
 import { EntityManagerRegistry, NestTypeOrmQueryBuilder } from "../../../../../..";
 import { AppTenantEntity } from "../../database/core/entities/appTenant.entity";
-import { AppTenantFacets, AppTenantSearchParameters, AppTenantSorting } from "./appTenant.models";
+import { AppTenantEntityId, AppTenantFacets, AppTenantSearchParameters, AppTenantSorting } from "./appTenant.models";
 import { AppAuthContext, AppUserContext } from "../../infrastructure/authentication/types";
-export declare class AppTenantQueryBuilder extends NestTypeOrmQueryBuilder<AppTenantEntity, AppTenantSearchParameters, AppTenantSorting, AppTenantFacets, AppUserContext> {
+export declare class AppTenantQueryBuilder extends NestTypeOrmQueryBuilder<AppTenantEntity, AppTenantEntityId, AppTenantSearchParameters, AppTenantSorting, AppTenantFacets, AppUserContext> {
     constructor(registry: EntityManagerRegistry);
     protected buildContextFilter(context?: AppAuthContext | undefined): FindOptionsWhere<AppTenantEntity> | FindOptionsWhere<AppTenantEntity>[];
     protected buildSortingClause(request: AppTenantSearchParameters): FindOptionsOrder<AppTenantEntity>;

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

@@ -1,9 +1,9 @@
 import { FindOptionsOrder, FindOptionsWhere } from "typeorm";
 import { EntityManagerRegistry, NestTypeOrmQueryBuilder } from "../../../../../..";
 import { AppUserGroupMemberEntity } from "../../database/core/entities/appUserGroupMember.entity";
-import { AppUserGroupMemberFacets, AppUserGroupMemberSearchParameters, AppUserGroupMemberSorting } from "./appUserGroupMember.models";
+import { AppUserGroupMemberEntityId, AppUserGroupMemberFacets, AppUserGroupMemberSearchParameters, AppUserGroupMemberSorting } from "./appUserGroupMember.models";
 import { AppAuthContext, AppUserContext } from "../../infrastructure/authentication/types";
-export declare class AppUserGroupMemberQueryBuilder extends NestTypeOrmQueryBuilder<AppUserGroupMemberEntity, AppUserGroupMemberSearchParameters, AppUserGroupMemberSorting, AppUserGroupMemberFacets, AppUserContext> {
+export declare class AppUserGroupMemberQueryBuilder extends NestTypeOrmQueryBuilder<AppUserGroupMemberEntity, AppUserGroupMemberEntityId, AppUserGroupMemberSearchParameters, AppUserGroupMemberSorting, AppUserGroupMemberFacets, AppUserContext> {
     constructor(registry: EntityManagerRegistry);
     protected buildContextFilter(context?: AppAuthContext | undefined): FindOptionsWhere<AppUserGroupMemberEntity> | FindOptionsWhere<AppUserGroupMemberEntity>[];
     protected buildSortingClause(request: AppUserGroupMemberSearchParameters): FindOptionsOrder<AppUserGroupMemberEntity>;

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

@@ -1,9 +1,9 @@
 import { FindOptionsOrder, FindOptionsWhere } from "typeorm";
 import { EntityManagerRegistry, NestTypeOrmQueryBuilder } from "../../../../../..";
 import { AppUserGroupEntity } from "../../database/core/entities/appUserGroup.entity";
-import { AppUserGroupFacets, AppUserGroupSearchParameters, AppUserGroupSorting } from "./appUserGroup.models";
+import { AppUserGroupEntityId, AppUserGroupFacets, AppUserGroupSearchParameters, AppUserGroupSorting } from "./appUserGroup.models";
 import { AppAuthContext, AppUserContext } from "../../infrastructure/authentication/types";
-export declare class AppUserGroupQueryBuilder extends NestTypeOrmQueryBuilder<AppUserGroupEntity, AppUserGroupSearchParameters, AppUserGroupSorting, AppUserGroupFacets, AppUserContext> {
+export declare class AppUserGroupQueryBuilder extends NestTypeOrmQueryBuilder<AppUserGroupEntity, AppUserGroupEntityId, AppUserGroupSearchParameters, AppUserGroupSorting, AppUserGroupFacets, AppUserContext> {
     constructor(registry: EntityManagerRegistry);
     protected buildContextFilter(context?: AppAuthContext | undefined): FindOptionsWhere<AppUserGroupEntity> | FindOptionsWhere<AppUserGroupEntity>[];
     protected buildSortingClause(request: AppUserGroupSearchParameters): FindOptionsOrder<AppUserGroupEntity>;

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

@@ -1,9 +1,9 @@
 import { FindOptionsOrder, FindOptionsWhere } from "typeorm";
 import { EntityManagerRegistry, NestTypeOrmQueryBuilder } from "../../../../../..";
 import { AppUserProfileEntity } from "../../database/core/entities/appUserProfile.entity";
-import { AppUserProfileFacets, AppUserProfileSearchParameters, AppUserProfileSorting } from "./appUserProfile.models";
+import { AppUserProfileEntityId, AppUserProfileFacets, AppUserProfileSearchParameters, AppUserProfileSorting } from "./appUserProfile.models";
 import { AppAuthContext, AppUserContext } from "../../infrastructure/authentication/types";
-export declare class AppUserProfileQueryBuilder extends NestTypeOrmQueryBuilder<AppUserProfileEntity, AppUserProfileSearchParameters, AppUserProfileSorting, AppUserProfileFacets, AppUserContext> {
+export declare class AppUserProfileQueryBuilder extends NestTypeOrmQueryBuilder<AppUserProfileEntity, AppUserProfileEntityId, AppUserProfileSearchParameters, AppUserProfileSorting, AppUserProfileFacets, AppUserContext> {
     constructor(registry: EntityManagerRegistry);
     protected buildContextFilter(context?: AppAuthContext | undefined): FindOptionsWhere<AppUserProfileEntity> | FindOptionsWhere<AppUserProfileEntity>[];
     protected buildSortingClause(request: AppUserProfileSearchParameters): FindOptionsOrder<AppUserProfileEntity>;

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

@@ -1,9 +1,9 @@
 import { FindOptionsOrder, FindOptionsRelations, FindOptionsWhere } from "typeorm";
 import { EntityManagerRegistry, NestTypeOrmQueryBuilder } from "../../../../../..";
 import { AppUserRoleEntity } from "../../database/core/entities/appUserRole.entity";
-import { AppUserRoleFacets, AppUserRoleSearchParameters, AppUserRoleSorting } from "./appUserRole.models";
+import { AppUserRoleEntityId, AppUserRoleFacets, AppUserRoleSearchParameters, AppUserRoleSorting } from "./appUserRole.models";
 import { AppAuthContext, AppUserContext } from "../../infrastructure/authentication/types";
-export declare class AppUserRoleQueryBuilder extends NestTypeOrmQueryBuilder<AppUserRoleEntity, AppUserRoleSearchParameters, AppUserRoleSorting, AppUserRoleFacets, AppUserContext> {
+export declare class AppUserRoleQueryBuilder extends NestTypeOrmQueryBuilder<AppUserRoleEntity, AppUserRoleEntityId, AppUserRoleSearchParameters, AppUserRoleSorting, AppUserRoleFacets, AppUserContext> {
     constructor(registry: EntityManagerRegistry);
     protected buildContextFilter(context?: AppAuthContext | undefined): FindOptionsWhere<AppUserRoleEntity> | FindOptionsWhere<AppUserRoleEntity>[];
     protected buildSortingClause(request: AppUserRoleSearchParameters): FindOptionsOrder<AppUserRoleEntity>;

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

@@ -1,9 +1,9 @@
 import { FindOptionsOrder, FindOptionsWhere } from "typeorm";
 import { EntityManagerRegistry, NestTypeOrmQueryBuilder } from "../../../../../..";
 import { AppUserEntity } from "../../database/core/entities/appUser.entity";
-import { AppUserFacets, AppUserSearchParameters, AppUserSorting } from "./appUser.models";
+import { AppUserEntityId, AppUserFacets, AppUserSearchParameters, AppUserSorting } from "./appUser.models";
 import { AppAuthContext, AppUserContext } from "../../infrastructure/authentication/types";
-export declare class AppUserQueryBuilder extends NestTypeOrmQueryBuilder<AppUserEntity, AppUserSearchParameters, AppUserSorting, AppUserFacets, AppUserContext> {
+export declare class AppUserQueryBuilder extends NestTypeOrmQueryBuilder<AppUserEntity, AppUserEntityId, AppUserSearchParameters, AppUserSorting, AppUserFacets, AppUserContext> {
     constructor(registry: EntityManagerRegistry);
     protected buildContextFilter(context?: AppAuthContext | undefined): FindOptionsWhere<AppUserEntity> | FindOptionsWhere<AppUserEntity>[];
     protected buildSortingClause(request: AppUserSearchParameters): FindOptionsOrder<AppUserEntity>;

package/dist/esm/types/platforms/nest/__test__/server/entities/crmContacts/crmContact.query.d.ts

@@ -1,10 +1,10 @@
 import { FindOptionsOrder, FindOptionsWhere } from "typeorm";
 import { EntityManagerRegistry, NestTypeOrmQueryBuilder } from "../../../../../..";
 import { CrmContactEntity } from "../../database/core/entities/crmContact.entity";
-import { CrmContactFacets, CrmContactSorting } from "./crmContact.models";
+import { CrmContactEntityId, CrmContactFacets, CrmContactSorting } from "./crmContact.models";
 import { CrmContactSearchParameters } from "./crmContact.types";
 import { AppAuthContext, AppUserContext } from "../../infrastructure/authentication/types";
-export declare class CrmContactQueryBuilder extends NestTypeOrmQueryBuilder<CrmContactEntity, CrmContactSearchParameters, CrmContactSorting, CrmContactFacets, AppUserContext> {
+export declare class CrmContactQueryBuilder extends NestTypeOrmQueryBuilder<CrmContactEntity, CrmContactEntityId, CrmContactSearchParameters, CrmContactSorting, CrmContactFacets, AppUserContext> {
     constructor(registry: EntityManagerRegistry);
     protected buildContextFilter(context?: AppAuthContext): FindOptionsWhere<CrmContactEntity> | FindOptionsWhere<CrmContactEntity>[];
     protected buildSortingClause(request: CrmContactSearchParameters): FindOptionsOrder<CrmContactEntity>;

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

@@ -1,10 +1,10 @@
 import { FindOptionsWhere, FindOptionsOrder } from "typeorm";
 import { FooEntity } from "../../database/core/entities/foo.entity";
-import { FooFacets, FooSearchParameters, FooSorting } from "./foo.models";
+import { FooEntityId, FooFacets, FooSearchParameters, FooSorting } from "./foo.models";
 import { NestTypeOrmQueryBuilder } from "../../../../integrations/typeorm";
 import { EntityManagerRegistry } from "../../../../ioc/registry";
 import { AppUserContext, AppAuthContext } from "../../infrastructure/authentication";
-export declare class FooQueryBuilder extends NestTypeOrmQueryBuilder<FooEntity, FooSearchParameters, FooSorting, FooFacets, AppUserContext> {
+export declare class FooQueryBuilder extends NestTypeOrmQueryBuilder<FooEntity, FooEntityId, FooSearchParameters, FooSorting, FooFacets, AppUserContext> {
     constructor(registry: EntityManagerRegistry);
     protected buildContextFilter(context?: AppAuthContext | undefined): FindOptionsWhere<FooEntity> | FindOptionsWhere<FooEntity>[];
     protected buildSortingClause(request: FooSearchParameters): FindOptionsOrder<FooEntity>;

package/dist/esm/types/platforms/nest/integrations/typeorm/queryBuilder.d.ts

@@ -2,6 +2,6 @@ import { ObjectLiteral } from "typeorm";
 import { TypeOrmQueryBuilder } from "../../../../integrations";
 import { IEntityFacets, IEntitySearchParameters, SortingType } from "../../../../abstractions";
 import { EntityManagerRegistry } from "../../ioc/registry";
-export declare abstract class NestTypeOrmQueryBuilder<TEntity extends ObjectLiteral, TEntitySearchParameters extends IEntitySearchParameters<TSorting, number>, TSorting extends SortingType, TFacets extends IEntityFacets, TUserContext> extends TypeOrmQueryBuilder<TEntity, TEntitySearchParameters, TSorting, TFacets, TUserContext> {
+export declare abstract class NestTypeOrmQueryBuilder<TEntity extends ObjectLiteral, TEntityId, TEntitySearchParameters extends IEntitySearchParameters<TSorting, number>, TSorting extends SortingType, TFacets extends IEntityFacets, TUserContext> extends TypeOrmQueryBuilder<TEntity, TEntityId, TEntitySearchParameters, TSorting, TFacets, TUserContext> {
     constructor(entityName: string, registry: EntityManagerRegistry);
 }

package/dist/esm/types/platforms/nest/plugins/buckets/aws-s3/errors/index.d.ts

@@ -1,3 +1,3 @@
-export declare class AwsS2BucketError extends Error {
+export declare class AwsS3BucketError extends Error {
     constructor(message: string);
 }

package/dist/esm/types/platforms/nest/plugins/buckets/aws-s3/index.d.ts

@@ -1,4 +1,4 @@
-export { AwsS2BucketError } from "./errors";
+export { AwsS3BucketError as AwsS2BucketError } from "./errors";
 export { AwsBucketModule } from "./module";
 export { AwsS3BucketProvider } from "./provider";
 export { AwsBucketSettings } from "./settings";

package/dist/esm/types/providers/services.d.ts

@@ -13,7 +13,7 @@ import { IEntitiesCountQuery, IEntitiesQueryBuilder, IEntitiesSearchQuery, IEnti
 import { IEntityReplicaDeleteManager, IEntityReplicaSyncManager, IReplicasConfiguration } from "../abstractions/replication";
 import { IEntityRepository } from "../abstractions/repository";
 import { IEntitySearchParameters, ISearchFilters } from "../abstractions/searchParameters";
-import { IEntityConfiguration } from "../abstractions/settings";
+import { EntityManagerSettings, IEntityConfiguration } from "../abstractions/settings";
 import { ServiceLocator } from "../ioc";
 export declare class EntityServiceLocator<TEntity, TEntityId> {
     private readonly services;
@@ -63,21 +63,24 @@ export declare class EntityServiceLocator<TEntity, TEntityId> {
     resolveImportAction(): IEntitiesImportAction<TEntity>;
     resolveSampleDownloadAction(): IEntitiesSampleDownloadAction<TEntity>;
     resolveExportAction<TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor>(): IEntitiesExportAction<TEntity, TEntitySearchParameters, TSorting, TCursor>;
-    resolveQueryBuilder<TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets, TUserContext>(): IEntitiesQueryBuilder<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets, TUserContext>;
+    resolveQueryBuilder<TEntityId, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets, TUserContext>(): IEntitiesQueryBuilder<TEntity, TEntityId, TEntitySearchParameters, TSorting, TCursor, TFacets, TUserContext>;
     getEntityName(): string;
 }
 export declare class EntitiesServiceLocator {
     private readonly provider;
     constructor(provider: ServiceLocator);
     getProvider(): ServiceLocator;
+    registerSettings(settings: EntityManagerSettings): this;
+    resolveSettings(): EntityManagerSettings;
     resolveEventEmitter<TEventEmitter extends IEventEmitter>(): TEventEmitter;
     registerEventEmitter<TEventEmitter extends IEventEmitter>(instance: TEventEmitter): void;
     resolveEmailProvider<TEmailProvider extends IEmailProvider<unknown>>(): TEmailProvider;
     registerEmailProvider<TEmailProvider extends IEmailProvider<unknown>>(instance: TEmailProvider): void;
     resolveEntityVersioningProvider<TEntityVersioningProvider extends IEntityVersioningProvider>(): TEntityVersioningProvider;
     registerEntityVersioningProvider<TEntityVersioningProvider extends IEntityVersioningProvider>(instance: TEntityVersioningProvider): void;
-    resolveBucketProvider<TBucketProvider extends IBucketProvider>(): TBucketProvider;
-    registerBucketProvider<TBucketProvider extends IBucketProvider>(instance: TBucketProvider): void;
+    resolveDefaultBucketProvider<TBucketProvider extends IBucketProvider>(): TBucketProvider;
+    resolveBucketProviders<TBucketProvider extends IBucketProvider>(): TBucketProvider[];
+    registerBucketProvider<TBucketProvider extends IBucketProvider>(name: string, instance: TBucketProvider): void;
     resolveEventsTracker<TEventsTracker extends IEventsTracker<TEventLog>, TEventLog extends IEventLog<unknown>>(): TEventsTracker;
     registerEventsTracker<TEventsTracker extends IEventsTracker<TEventLog>, TEventLog extends IEventLog<unknown>>(instance: TEventsTracker): void;
     resolveEmailTemplatesCollection(): IEmailTemplatesCollection;
@@ -168,6 +171,6 @@ export declare class EntitiesServiceLocator {
     registerSampleDownloadAction<TEntity>(entityName: string, instance: IEntitiesSampleDownloadAction<TEntity>): void;
     resolveImportAction<TEntity>(entityName: string): IEntitiesImportAction<TEntity>;
     registerImportAction<TEntity>(entityName: string, instance: IEntitiesImportAction<TEntity>): void;
-    resolveQueryBuilder<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets, TUserContext>(entityName: string): IEntitiesQueryBuilder<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets, TUserContext>;
-    registerQueryBuilder<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets, TUserContext>(entityName: string, instance: IEntitiesQueryBuilder<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets, TUserContext>): void;
+    resolveQueryBuilder<TEntity, TEntityId, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets, TUserContext>(entityName: string): IEntitiesQueryBuilder<TEntity, TEntityId, TEntitySearchParameters, TSorting, TCursor, TFacets, TUserContext>;
+    registerQueryBuilder<TEntity, TEntityId, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets, TUserContext>(entityName: string, instance: IEntitiesQueryBuilder<TEntity, TEntityId, TEntitySearchParameters, TSorting, TCursor, TFacets, TUserContext>): void;
 }

package/dist/esm/types/queries/get.d.ts

@@ -5,4 +5,5 @@ export declare class EntityGetQuery<TEntity, TEntityId> implements IEntityGetQue
     constructor(services: EntityServiceLocator<TEntity, TEntityId>);
     execute(id: TEntityId): Promise<TEntity | undefined>;
     private authorize;
+    private getContext;
 }

package/dist/esm/types/symbols/ioc.d.ts

@@ -82,6 +82,9 @@ export declare const GlobalServices: {
         IEmailTemplatesCollection: string;
         IBucketProvider: string;
     };
+    Settings: {
+        EntityManagerSettings: string;
+    };
     Versioning: {
         IEntityVersioningProvider: string;
     };

package/dist/esm/types/templates/queryBuilder/index.d.ts

@@ -2,7 +2,8 @@ import { IAuthenticationContext, IEntitiesQueryBuilder, IEntityFacets, IEntitySe
 import { SortingType } from "../../abstractions/common";
 import { IEntitiesDeleteResult } from "../../abstractions/repository";
 import { IEntitiesSearchResults, IEntitiesSearchResultsPaging } from "../../models";
-export declare abstract class QueryBuilderBase<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets, TUserContext> implements IEntitiesQueryBuilder<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets, TUserContext> {
+export declare abstract class QueryBuilderBase<TEntity, TEntityId, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets, TUserContext> implements IEntitiesQueryBuilder<TEntity, TEntityId, TEntitySearchParameters, TSorting, TCursor, TFacets, TUserContext> {
+    abstract get(id: TEntityId, context?: IAuthenticationContext<TUserContext> | undefined): Promise<TEntity | undefined>;
     abstract exists(filters: NonNullable<TEntitySearchParameters["filters"]>, context?: IAuthenticationContext<TUserContext> | undefined): Promise<boolean>;
     abstract count(filters: NonNullable<TEntitySearchParameters["filters"]>, context?: IAuthenticationContext<TUserContext> | undefined): Promise<number>;
     abstract delete(filters: NonNullable<TEntitySearchParameters["filters"]>, context?: IAuthenticationContext<TUserContext> | undefined): Promise<IEntitiesDeleteResult>;