@punks/backend-entity-manager 0.0.71 → 0.0.73

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

@@ -5,14 +5,16 @@ import { IEntitySearchParameters } from "../../abstractions/searchParameters";
 import { IEntitiesSearchResults } from "../../models";
 import { EntityServiceLocator } from "../../providers/services";
 import { InMemoryRepository } from "../../testing/mocks/repository";
-import { IEntityManager } from "../../abstractions";
+import { IAuthenticationContext, IEntityManager } from "../../abstractions";
+import { FooDeleteParameters } from "../providers/typeorm/entity/foo";
+import { IEntitiesDeleteResult } from "../../abstractions/repository";
 export interface FooEntity {
     id: string;
     name: string;
     age: number;
     updatedAt: Date;
 }
-export type FooEntityManager = IEntityManager<FooEntity, string, Partial<FooEntity>, Partial<FooEntity>, FooSearchParameters, FooSorting, FooCursor, FooFacets>;
+export type FooEntityManager = IEntityManager<FooEntity, string, Partial<FooEntity>, Partial<FooEntity>, FooDeleteParameters, FooSearchParameters, FooSorting, FooCursor, FooFacets>;
 export declare class FooRepository extends InMemoryRepository<FooEntity> {
 }
 export interface FooSearchFilters {
@@ -32,6 +34,9 @@ export interface FooFacets {
 export declare class FooQueryBuilder implements IEntitiesQueryBuilder<FooEntity, FooSearchParameters, FooSorting, FooCursor, FooFacets, unknown> {
     private readonly repository;
     constructor(services: EntityServiceLocator<FooEntity, string>);
+    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>;
     search(request: FooSearchParameters): Promise<IEntitiesSearchResults<FooSearchParameters, FooEntity, FooSorting, FooCursor, FooFacets>>;
 }
 export interface FooDto {

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

@@ -1,15 +1,16 @@
 import { DataSource, Repository, FindOptionsWhere } from "typeorm";
-import { IAuthenticationContext, IEntityConverter, IEntityManager, IEntityManagerServiceRoot, IEntitySearchParameters } from "../../../../abstractions";
+import { 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";
 export declare class FooEntity {
     id: string;
     name: string;
     age: number;
     updatedAt: Date;
 }
-export type FooEntityManager = IEntityManager<FooEntity, string, Partial<FooEntity>, Partial<FooEntity>, FooSearchParameters, FooSorting, FooCursor, FooFacets>;
+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>);
 }
@@ -25,6 +26,17 @@ 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> {

package/dist/cjs/types/abstractions/actions.d.ts

@@ -1,16 +1,26 @@
 import { IEntitiesSearchResults } from "../models";
+import { IEntitiesDeleteParameters } from "./commands";
 import { SortingType } from "./common";
 import { IEntityFacets } from "./queries";
-import { IEntitySearchParameters } from "./searchParameters";
+import { IEntitySearchParameters, ISearchFilters } from "./searchParameters";
 export interface IEntityCreateAction<TEntity, TEntityCreateDto, TEntityDto> {
     execute(input: TEntityCreateDto): Promise<TEntityDto>;
 }
 export interface IEntityDeleteAction<TEntity, TEntityId> {
     execute(id: TEntityId): Promise<void>;
 }
+export interface IEntitiesDeleteAction<TEntity, TEntitiesDeleteParameters extends IEntitiesDeleteParameters<TSorting>, TSorting> {
+    execute(params: TEntitiesDeleteParameters): Promise<void>;
+}
 export interface IEntityGetAction<TEntity, TEntityId, TEntityDto> {
     execute(id: TEntityId): Promise<TEntityDto | undefined>;
 }
+export interface IEntityExistsAction<TEntity, TEntityFilters extends ISearchFilters> {
+    execute(filters: TEntityFilters): Promise<boolean>;
+}
+export interface IEntitiesCountAction<TEntity, TEntityFilters extends ISearchFilters> {
+    execute(filters: TEntityFilters): Promise<number>;
+}
 export interface IEntityUpdateAction<TEntity, TEntityId, TEntityUpdateDto, TEntityDto> {
     execute(id: TEntityId, data: TEntityUpdateDto): Promise<TEntityDto>;
 }
@@ -20,11 +30,14 @@ export interface IEntityUpsertAction<TEntity, TEntityId, TEntityUpdateDto, TEnti
 export interface IEntitiesSearchAction<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TEntityListItemDto, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets> {
     execute(request: TEntitySearchParameters): Promise<IEntitiesSearchResults<TEntitySearchParameters, TEntityListItemDto, TSorting, TCursor, TFacets>>;
 }
-export interface IEntityActions<TEntity, TEntityId, TEntityCreateDto, TEntityUpdateDto, TEntityDto, TEntityListItemDto, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets> {
-    get(): IEntityGetAction<TEntity, TEntityId, TEntityDto>;
-    search(): IEntitiesSearchAction<TEntity, TEntitySearchParameters, TEntityListItemDto, TSorting, TCursor, TFacets>;
-    create(): IEntityCreateAction<TEntity, TEntityCreateDto, TEntityDto>;
-    update(): IEntityUpdateAction<TEntity, TEntityId, TEntityUpdateDto, TEntityDto>;
-    upsert(): IEntityUpsertAction<TEntity, TEntityId, TEntityUpdateDto, TEntityDto>;
-    delete(): IEntityDeleteAction<TEntity, TEntityId>;
+export interface IEntityActions<TEntity, TEntityId, TEntityCreateDto, TEntityUpdateDto, TEntityDto, TEntityListItemDto, TEntitiesDeleteParameters extends IEntitiesDeleteParameters<TSorting>, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets> {
+    get get(): IEntityGetAction<TEntity, TEntityId, TEntityDto>;
+    get search(): IEntitiesSearchAction<TEntity, TEntitySearchParameters, TEntityListItemDto, TSorting, TCursor, TFacets>;
+    get exists(): IEntityExistsAction<TEntity, NonNullable<TEntitySearchParameters["filters"]>>;
+    get count(): IEntitiesCountAction<TEntity, NonNullable<TEntitySearchParameters["filters"]>>;
+    get create(): IEntityCreateAction<TEntity, TEntityCreateDto, TEntityDto>;
+    get update(): IEntityUpdateAction<TEntity, TEntityId, TEntityUpdateDto, TEntityDto>;
+    get upsert(): IEntityUpsertAction<TEntity, TEntityId, TEntityUpdateDto, TEntityDto>;
+    get delete(): IEntityDeleteAction<TEntity, TEntityId>;
+    get deleteItems(): IEntitiesDeleteAction<TEntity, TEntitiesDeleteParameters, TSorting>;
 }

package/dist/cjs/types/abstractions/adapters.d.ts

@@ -1,8 +1,9 @@
+import { DeepPartial } from "../types";
 export interface IEntityCreateCommandAdapter<TEntity, TEntityCreateData> {
-    createDataToEntity(data: TEntityCreateData): Partial<TEntity>;
+    createDataToEntity(data: TEntityCreateData): DeepPartial<TEntity>;
 }
 export interface IEntityUpdateCommandAdapter<TEntity, TEntityUpdateData> {
-    updateDataToEntity(data: TEntityUpdateData): Partial<TEntity>;
+    updateDataToEntity(data: TEntityUpdateData): DeepPartial<TEntity>;
 }
 export interface IEntityAdapter<TEntity, TEntityCreateData, TEntityUpdateData> extends IEntityCreateCommandAdapter<TEntity, TEntityCreateData>, IEntityUpdateCommandAdapter<TEntity, TEntityUpdateData> {
 }

package/dist/cjs/types/abstractions/authorization.d.ts

@@ -1,11 +1,13 @@
+import { DeepPartial } from "../types";
 import { IAuthenticationContext } from "./authentication";
 export interface IAuthorizationResult {
     isAuthorized: boolean;
 }
 export interface IEntityAuthorizationMiddleware<TEntity, TAuthenticationContext extends IAuthenticationContext<TUserContext>, TUserContext> {
     canSearch(context: TAuthenticationContext): Promise<IAuthorizationResult>;
-    canRead(entity: Partial<TEntity>, context: TAuthenticationContext): Promise<IAuthorizationResult>;
-    canCreate(entity: Partial<TEntity>, context: TAuthenticationContext): Promise<IAuthorizationResult>;
-    canUpdate(entity: Partial<TEntity>, context: TAuthenticationContext): Promise<IAuthorizationResult>;
-    canDelete(entity: Partial<TEntity>, context: TAuthenticationContext): Promise<IAuthorizationResult>;
+    canRead(entity: DeepPartial<TEntity>, context: TAuthenticationContext): Promise<IAuthorizationResult>;
+    canCreate(entity: DeepPartial<TEntity>, context: TAuthenticationContext): Promise<IAuthorizationResult>;
+    canUpdate(entity: DeepPartial<TEntity>, context: TAuthenticationContext): Promise<IAuthorizationResult>;
+    canDelete(entity: DeepPartial<TEntity>, context: TAuthenticationContext): Promise<IAuthorizationResult>;
+    canDeleteItems(context: TAuthenticationContext): Promise<IAuthorizationResult>;
 }

package/dist/cjs/types/abstractions/commands.d.ts

@@ -1,3 +1,4 @@
+import { ISearchFilters, ISearchSorting } from "./searchParameters";
 export interface IEntityCreateCommand<TEntity, TEntityCreateData> {
     execute(input: TEntityCreateData): Promise<TEntity>;
 }
@@ -10,3 +11,13 @@ export interface IEntityUpsertCommand<TEntity, TEntityId, TEntityUpdateData> {
 export interface IEntityDeleteCommand<TEntity, TEntityId> {
     execute(id: TEntityId): Promise<void>;
 }
+export interface IEntitiesDeleteParameters<TSorting> {
+    filters?: ISearchFilters;
+    sorting?: ISearchSorting<TSorting>;
+}
+export interface IEntitiesDeleteResult {
+    deletedCount: number;
+}
+export interface IEntitiesDeleteCommand<TEntity, TEntitiesDeleteParameters extends IEntitiesDeleteParameters<TSorting>, TSorting> {
+    execute(params: TEntitiesDeleteParameters): Promise<IEntitiesDeleteResult>;
+}

package/dist/cjs/types/abstractions/errors.d.ts

@@ -1,3 +1,4 @@
+import { DeepPartial } from "../types";
 export declare class EntityManagerException extends Error {
     constructor(message: string);
 }
@@ -14,8 +15,8 @@ export declare abstract class EntityManagerUnauthorizedException extends EntityM
 export declare class EntityOperationUnauthorizedException<TEntity> extends EntityManagerUnauthorizedException {
     private readonly operation;
     private readonly entity?;
-    constructor(operationType: EntityOperationType, entityName: string, entity?: Partial<TEntity>);
-    get getEntity(): Partial<TEntity> | undefined;
+    constructor(operationType: EntityOperationType, entityName: string, entity?: DeepPartial<TEntity>);
+    get getEntity(): DeepPartial<TEntity> | undefined;
     get getOperation(): EntityOperationType;
 }
 export declare class EntityNotFoundException<TEntityId> extends EntityManagerException {

package/dist/cjs/types/abstractions/index.d.ts

@@ -13,7 +13,8 @@ export * from "./filters";
 export * from "./localization";
 export { IEntityManager } from "./manager";
 export { IEntityMapper } from "./mappers";
-export { IEntitiesSearchQuery, IEntityGetQuery, IEntitiesQueryBuilder, IEntityFacet, IEntityFacets, IEntityFacetItem, } from "./queries";
+export {} from "./pipelines";
+export { IEntitiesSearchQuery, IEntityGetQuery, IEntitiesQueryBuilder, IEntityFacet, IEntityFacets, IEntityFacetItem, IEntityExistsQuery, IEntitiesCountQuery, } from "./queries";
 export { IReplicasConfiguration, ReplicationMode, ReplicaOptions, ReplicaConfiguration, IEntityReplicaDeleteManager, IEntityReplicaSyncManager, } from "./replication";
 export { IEntityRepository } from "./repository";
 export * from "./searchParameters";

package/dist/cjs/types/abstractions/manager.d.ts

@@ -1,12 +1,15 @@
-import { IEntityCreateCommand, IEntityDeleteCommand, IEntityUpdateCommand, IEntityUpsertCommand } from "./commands";
+import { IEntitiesDeleteCommand, IEntitiesDeleteParameters, IEntityCreateCommand, IEntityDeleteCommand, IEntityUpdateCommand, IEntityUpsertCommand } from "./commands";
 import { SortingType } from "./common";
-import { IEntitiesSearchQuery, IEntityFacets, IEntityGetQuery } from "./queries";
+import { IEntitiesCountQuery, IEntitiesSearchQuery, IEntityExistsQuery, IEntityFacets, IEntityGetQuery } from "./queries";
 import { IEntitySearchParameters } from "./searchParameters";
-export interface IEntityManager<TEntity, TEntityId, TEntityCreateData, TEntityUpdateData, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets> {
-    get(): IEntityGetQuery<TEntity, TEntityId>;
-    search(): IEntitiesSearchQuery<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets>;
-    create(): IEntityCreateCommand<TEntity, TEntityCreateData>;
-    update(): IEntityUpdateCommand<TEntity, TEntityId, TEntityUpdateData>;
-    upsert(): IEntityUpsertCommand<TEntity, TEntityId, TEntityUpdateData>;
-    delete(): IEntityDeleteCommand<TEntity, TEntityId>;
+export interface IEntityManager<TEntity, TEntityId, TEntityCreateData, TEntityUpdateData, TEntitiesDeleteParameters extends IEntitiesDeleteParameters<TSorting>, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets> {
+    get get(): IEntityGetQuery<TEntity, TEntityId>;
+    get search(): IEntitiesSearchQuery<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets>;
+    get exists(): IEntityExistsQuery<TEntity, NonNullable<TEntitySearchParameters["filters"]>>;
+    get count(): IEntitiesCountQuery<TEntity, NonNullable<TEntitySearchParameters["filters"]>>;
+    get create(): IEntityCreateCommand<TEntity, TEntityCreateData>;
+    get update(): IEntityUpdateCommand<TEntity, TEntityId, TEntityUpdateData>;
+    get upsert(): IEntityUpsertCommand<TEntity, TEntityId, TEntityUpdateData>;
+    get delete(): IEntityDeleteCommand<TEntity, TEntityId>;
+    get deleteItems(): IEntitiesDeleteCommand<TEntity, TEntitiesDeleteParameters, TSorting>;
 }

package/dist/cjs/types/abstractions/pipelines.d.ts

@@ -0,0 +1,10 @@
+import { PipelineDefinition, PipelineOperationResult, PipelineResult } from "../types";
+export interface IPipelineInstance<TPipelineInput, TPipelineOutput, TContext> {
+    execute(): Promise<PipelineResult<TPipelineInput, TPipelineOutput>>;
+}
+export interface IPipelinesController {
+    createInstance<TPipelineInput, TPipelineOutput, TContext>(definition: PipelineDefinition<TPipelineInput, TPipelineOutput, TContext>, input: TPipelineInput, context: TContext | undefined): Promise<IPipelineInstance<TPipelineInput, TPipelineOutput, TContext>>;
+}
+export interface IPipelineOperationExecutor<TPipelineInput, TPipelineOutput, TContext> {
+    execute(input: TPipelineInput, context: TContext): Promise<PipelineOperationResult<TPipelineInput, TPipelineOutput>>;
+}

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

@@ -1,7 +1,8 @@
 import { IEntitiesSearchResults } from "../models";
 import { IAuthenticationContext } from "./authentication";
 import { SortingType } from "./common";
-import { IEntitySearchParameters } from "./searchParameters";
+import { IEntitiesDeleteResult } from "./repository";
+import { IEntitySearchParameters, ISearchFilters } from "./searchParameters";
 export interface IEntityFacetItem<T> {
     value: T;
     name?: string;
@@ -18,6 +19,15 @@ export interface IEntitiesSearchQuery<TEntity, TEntitySearchParameters extends I
 export interface IEntityGetQuery<TEntity, TEntityId> {
     execute(id: TEntityId): Promise<TEntity | undefined>;
 }
+export interface IEntityExistsQuery<TEntity, TEntityFilters extends ISearchFilters> {
+    execute(filters: TEntityFilters): Promise<boolean>;
+}
+export interface IEntitiesCountQuery<TEntity, TEntityFilters extends ISearchFilters> {
+    execute(filters: TEntityFilters): Promise<number>;
+}
 export interface IEntitiesQueryBuilder<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets, TUserContext> {
     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>;
+    delete(filters: NonNullable<TEntitySearchParameters["filters"]>, context?: IAuthenticationContext<TUserContext>): Promise<IEntitiesDeleteResult>;
 }

package/dist/cjs/types/abstractions/repository.d.ts

@@ -1,3 +1,7 @@
+import { DeepPartial } from "../types";
+export interface IEntitiesDeleteResult {
+    deletedCount: number;
+}
 export interface IEntityRepository<TEntity, TEntityId, TGetConditions, TFindCondition, TUpdateCondition, TDeleteCondition> {
     exists(id: TEntityId): Promise<boolean>;
     existsBy(condition: TGetConditions): Promise<boolean>;
@@ -8,9 +12,9 @@ export interface IEntityRepository<TEntity, TEntityId, TGetConditions, TFindCond
     findById(id: TEntityId[]): Promise<TEntity[]>;
     count(condition: TFindCondition): Promise<number>;
     delete(id: TEntityId): Promise<void>;
-    deleteBy(condition: TDeleteCondition): Promise<void>;
-    create(entity: Partial<TEntity>): Promise<TEntity>;
-    update(id: TEntityId, entity: Partial<TEntity>): Promise<TEntity>;
-    updateBy(entity: Partial<TEntity>, condition: TUpdateCondition): Promise<TEntity[]>;
-    upsert(id: TEntityId, entity: Partial<TEntity>): Promise<TEntity>;
+    deleteBy(condition: TDeleteCondition): Promise<IEntitiesDeleteResult>;
+    create(entity: DeepPartial<TEntity>): Promise<TEntity>;
+    update(id: TEntityId, entity: DeepPartial<TEntity>): Promise<TEntity>;
+    updateBy(entity: DeepPartial<TEntity>, condition: TUpdateCondition): Promise<TEntity[]>;
+    upsert(id: TEntityId, entity: DeepPartial<TEntity>): Promise<TEntity>;
 }

package/dist/cjs/types/actions/count.d.ts

@@ -0,0 +1,8 @@
+import { ISearchFilters } from "../abstractions";
+import { IEntitiesCountAction } from "../abstractions/actions";
+import { EntityServiceLocator } from "../providers/services";
+export declare class EntitiesCountAction<TEntity, TEntityFilters extends ISearchFilters> implements IEntitiesCountAction<TEntity, TEntityFilters> {
+    private readonly services;
+    constructor(services: EntityServiceLocator<TEntity, unknown>);
+    execute(filters: TEntityFilters): Promise<number>;
+}

package/dist/cjs/types/actions/deleteItems.d.ts

@@ -0,0 +1,8 @@
+import { IEntitiesDeleteAction } from "../abstractions/actions";
+import { IEntitiesDeleteParameters } from "../abstractions/commands";
+import { EntityServiceLocator } from "../providers/services";
+export declare class EntitiesDeleteAction<TEntity, TEntitiesDeleteParameters extends IEntitiesDeleteParameters<TSorting>, TSorting> implements IEntitiesDeleteAction<TEntity, TEntitiesDeleteParameters, TSorting> {
+    private readonly services;
+    constructor(services: EntityServiceLocator<TEntity, unknown>);
+    execute(params: TEntitiesDeleteParameters): Promise<void>;
+}

package/dist/cjs/types/actions/exists.d.ts

@@ -0,0 +1,8 @@
+import { ISearchFilters } from "../abstractions";
+import { IEntityExistsAction } from "../abstractions/actions";
+import { EntityServiceLocator } from "../providers/services";
+export declare class EntityExistsAction<TEntity, TEntityFilters extends ISearchFilters> implements IEntityExistsAction<TEntity, TEntityFilters> {
+    private readonly services;
+    constructor(services: EntityServiceLocator<TEntity, unknown>);
+    execute(filters: TEntityFilters): Promise<boolean>;
+}

package/dist/cjs/types/authorization/allowAll.d.ts

@@ -11,4 +11,5 @@ export declare class AllowAllAuthorizationMiddleware<TEntity> implements IEntity
     canDelete(entity: TEntity): Promise<{
         isAuthorized: boolean;
     }>;
+    canDeleteItems(): Promise<IAuthorizationResult>;
 }

package/dist/cjs/types/commands/deleteItems.d.ts

@@ -0,0 +1,9 @@
+import { IEntitiesDeleteCommand, IEntitiesDeleteParameters, IEntitiesDeleteResult } from "../abstractions/commands";
+import { EntityServiceLocator } from "../providers/services";
+export declare class EntitiesDeleteCommand<TEntity, TEntitiesDeleteParameters extends IEntitiesDeleteParameters<TSorting>, TSorting, TUserContext> implements IEntitiesDeleteCommand<TEntity, TEntitiesDeleteParameters, TSorting> {
+    private readonly services;
+    constructor(services: EntityServiceLocator<TEntity, unknown>);
+    execute(params: TEntitiesDeleteParameters): Promise<IEntitiesDeleteResult>;
+    private getContext;
+    private authorize;
+}

package/dist/cjs/types/concrete/index.d.ts

@@ -1,27 +1,33 @@
-import { IEntitiesSearchAction, IEntityActions, IEntityCreateAction, IEntityDeleteAction, IEntityGetAction, IEntityUpdateAction, IEntityUpsertAction } from "../abstractions/actions";
-import { IEntityCreateCommand, IEntityDeleteCommand, IEntityUpdateCommand, IEntityUpsertCommand } from "../abstractions/commands";
+import { IEntitiesCountAction, IEntitiesDeleteAction, IEntitiesSearchAction, IEntityActions, IEntityCreateAction, IEntityDeleteAction, IEntityExistsAction, IEntityGetAction, IEntityUpdateAction, IEntityUpsertAction } from "../abstractions/actions";
+import { IEntitiesDeleteCommand, IEntitiesDeleteParameters, IEntityCreateCommand, IEntityDeleteCommand, IEntityUpdateCommand, IEntityUpsertCommand } from "../abstractions/commands";
 import { SortingType } from "../abstractions/common";
 import { IEntityManager } from "../abstractions/manager";
-import { IEntitiesSearchQuery, IEntityFacets, IEntityGetQuery } from "../abstractions/queries";
+import { IEntitiesCountQuery, IEntitiesSearchQuery, IEntityExistsQuery, IEntityFacets, IEntityGetQuery } from "../abstractions/queries";
 import { IEntitySearchParameters } from "../abstractions/searchParameters";
 import { EntityServiceLocator } from "../providers/services";
-export declare class EntityManager<TEntity, TEntityId, TEntityCreateData, TEntityUpdateData, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets> implements IEntityManager<TEntity, TEntityId, TEntityCreateData, TEntityUpdateData, TEntitySearchParameters, TSorting, TCursor, TFacets> {
+export declare class EntityManager<TEntity, TEntityId, TEntityCreateData, TEntityUpdateData, TEntitiesDeleteParameters extends IEntitiesDeleteParameters<TSorting>, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets> implements IEntityManager<TEntity, TEntityId, TEntityCreateData, TEntityUpdateData, TEntitiesDeleteParameters, TEntitySearchParameters, TSorting, TCursor, TFacets> {
     private readonly services;
     constructor(services: EntityServiceLocator<TEntity, TEntityId>);
-    get(): IEntityGetQuery<TEntity, TEntityId>;
-    search(): IEntitiesSearchQuery<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets>;
-    create(): IEntityCreateCommand<TEntity, TEntityCreateData>;
-    update(): IEntityUpdateCommand<TEntity, TEntityId, TEntityUpdateData>;
-    upsert(): IEntityUpsertCommand<TEntity, TEntityId, TEntityUpdateData>;
-    delete(): IEntityDeleteCommand<TEntity, TEntityId>;
+    get exists(): IEntityExistsQuery<TEntity, NonNullable<TEntitySearchParameters["filters"]>>;
+    get count(): IEntitiesCountQuery<TEntity, NonNullable<TEntitySearchParameters["filters"]>>;
+    get deleteItems(): IEntitiesDeleteCommand<TEntity, TEntitiesDeleteParameters, TSorting>;
+    get get(): IEntityGetQuery<TEntity, TEntityId>;
+    get search(): IEntitiesSearchQuery<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets>;
+    get create(): IEntityCreateCommand<TEntity, TEntityCreateData>;
+    get update(): IEntityUpdateCommand<TEntity, TEntityId, TEntityUpdateData>;
+    get upsert(): IEntityUpsertCommand<TEntity, TEntityId, TEntityUpdateData>;
+    get delete(): IEntityDeleteCommand<TEntity, TEntityId>;
 }
-export declare class EntityActions<TEntity, TEntityId, TEntityCreateDto, TEntityUpdateDto, TEntityDto, TEntityListItemDto, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets> implements IEntityActions<TEntity, TEntityId, TEntityCreateDto, TEntityUpdateDto, TEntityDto, TEntityListItemDto, TEntitySearchParameters, TSorting, TCursor, TFacets> {
+export declare class EntityActions<TEntity, TEntityId, TEntityCreateDto, TEntityUpdateDto, TEntityDto, TEntityListItemDto, TEntitiesDeleteParameters extends IEntitiesDeleteParameters<TSorting>, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets> implements IEntityActions<TEntity, TEntityId, TEntityCreateDto, TEntityUpdateDto, TEntityDto, TEntityListItemDto, TEntitiesDeleteParameters, TEntitySearchParameters, TSorting, TCursor, TFacets> {
     private readonly services;
     constructor(services: EntityServiceLocator<TEntity, TEntityId>);
-    get(): IEntityGetAction<TEntity, TEntityId, TEntityDto>;
-    search(): IEntitiesSearchAction<TEntity, TEntitySearchParameters, TEntityListItemDto, TSorting, TCursor, TFacets>;
-    create(): IEntityCreateAction<TEntity, TEntityCreateDto, TEntityDto>;
-    update(): IEntityUpdateAction<TEntity, TEntityId, TEntityUpdateDto, TEntityDto>;
-    upsert(): IEntityUpsertAction<TEntity, TEntityId, TEntityUpdateDto, TEntityDto>;
-    delete(): IEntityDeleteAction<TEntity, TEntityId>;
+    get exists(): IEntityExistsAction<TEntity, NonNullable<TEntitySearchParameters["filters"]>>;
+    get count(): IEntitiesCountAction<TEntity, NonNullable<TEntitySearchParameters["filters"]>>;
+    get deleteItems(): IEntitiesDeleteAction<TEntity, TEntitiesDeleteParameters, TSorting>;
+    get get(): IEntityGetAction<TEntity, TEntityId, TEntityDto>;
+    get search(): IEntitiesSearchAction<TEntity, TEntitySearchParameters, TEntityListItemDto, TSorting, TCursor, TFacets>;
+    get create(): IEntityCreateAction<TEntity, TEntityCreateDto, TEntityDto>;
+    get update(): IEntityUpdateAction<TEntity, TEntityId, TEntityUpdateDto, TEntityDto>;
+    get upsert(): IEntityUpsertAction<TEntity, TEntityId, TEntityUpdateDto, TEntityDto>;
+    get delete(): IEntityDeleteAction<TEntity, TEntityId>;
 }

package/dist/cjs/types/index.d.ts

@@ -5,4 +5,5 @@ export * from "./events";
 export * from "./platforms";
 export * from "./templates";
 export * from "./settings";
+export * from "./types";
 export * from "./utils";

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

@@ -4,10 +4,14 @@ import { IEntitiesSearchResults } from "../../../models";
 import { QueryBuilderBase } from "../../../templates";
 import { TypeOrmRepository } from "./repository";
 import { EntityServiceLocator } from "../../../providers/services";
+import { IEntitiesDeleteResult } from "../../../abstractions/repository";
 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;
     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 findPagedQueryResults(request: TEntitySearchParameters, context?: IAuthenticationContext<TUserContext>): Promise<TEntity[]>;
     protected getRelationsToLoad(request: TEntitySearchParameters, context: IAuthenticationContext<TUserContext> | undefined): FindOptionsRelations<TEntity> | undefined;

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

@@ -1,7 +1,8 @@
 import { FindManyOptions, FindOneOptions, FindOptionsWhere, ObjectId, ObjectLiteral, Repository } from "typeorm";
 import { IEntityRepository } from "../../../abstractions";
-type UpdateCriteria<TEntity extends ObjectLiteral> = string | string[] | number | number[] | Date | Date[] | ObjectId | ObjectId[] | FindOptionsWhere<TEntity>;
-type DeleteCriteria<TEntity extends ObjectLiteral> = string | string[] | number | number[] | Date | Date[] | ObjectId | ObjectId[] | FindOptionsWhere<TEntity>;
+import { IEntitiesDeleteResult } from "../../../abstractions/repository";
+export type UpdateCriteria<TEntity extends ObjectLiteral> = string | string[] | number | number[] | Date | Date[] | ObjectId | ObjectId[] | FindOptionsWhere<TEntity>;
+export type DeleteCriteria<TEntity extends ObjectLiteral> = string | string[] | number | number[] | Date | Date[] | ObjectId | ObjectId[] | FindOptionsWhere<TEntity>;
 export declare class TypeOrmRepository<TEntity extends ObjectLiteral, TEntityId> implements IEntityRepository<TEntity, TEntityId, FindOneOptions<TEntity>, FindManyOptions<TEntity>, UpdateCriteria<TEntity>, DeleteCriteria<TEntity>> {
     protected readonly innerRepository: Repository<TEntity>;
     constructor(innerRepository: Repository<TEntity>);
@@ -15,10 +16,9 @@ export declare class TypeOrmRepository<TEntity extends ObjectLiteral, TEntityId>
     find(condition: FindManyOptions<TEntity>): Promise<TEntity[]>;
     findById(id: TEntityId[]): Promise<TEntity[]>;
     delete(id: TEntityId): Promise<void>;
-    deleteBy(condition: DeleteCriteria<TEntity>): Promise<void>;
+    deleteBy(condition: DeleteCriteria<TEntity>): Promise<IEntitiesDeleteResult>;
     create(entity: Partial<TEntity>): Promise<TEntity>;
     update(id: TEntityId, entity: Partial<TEntity>): Promise<TEntity>;
     updateBy(entity: Partial<TEntity>, condition: UpdateCriteria<TEntity>): Promise<TEntity[]>;
     upsert(id: TEntityId, entity: Partial<TEntity>): Promise<TEntity>;
 }
-export {};

package/dist/cjs/types/platforms/nest/__test__/server/app/auth/auth.dto.d.ts

@@ -1,20 +1,12 @@
 import { UserRegistrationError } from "../../../../extensions";
+import { AuthUserContext, AuthUserRegistrationData } from "../../infrastructure/authentication/models";
 export declare class OperationCallbackTemplate {
     urlTemplate: string;
     tokenPlaceholder: string;
 }
-export declare class UserRegistrationData {
-    userName: string;
-    firstName: string;
-    lastName: string;
-    birthDate: string;
-}
-export declare class UserContext {
-    organizationUid: string;
-}
 export declare class UserLoginRequest {
     userName: string;
-    userContext?: UserContext;
+    userContext?: AuthUserContext;
     password: string;
 }
 export declare class UserLoginResponse {
@@ -25,8 +17,8 @@ export declare class UserRegisterRequest {
     email: string;
     userName: string;
     password: string;
-    data: UserRegistrationData;
-    userContext: UserContext;
+    data: AuthUserRegistrationData;
+    userContext?: AuthUserContext;
     callback: OperationCallbackTemplate;
     languageId: string;
 }
@@ -36,7 +28,7 @@ export declare class UserRegisterResponse {
 }
 export declare class UserPasswordResetRequest {
     userName: string;
-    userContext?: UserContext;
+    userContext?: AuthUserContext;
     callback: OperationCallbackTemplate;
     languageId: string;
 }
@@ -49,7 +41,7 @@ export declare class UserEmailVerifyCompleteRequest {
 }
 export declare class UserEmailVerifyRequest {
     email: string;
-    userContext: UserContext;
+    userContext?: AuthUserContext;
     callback: OperationCallbackTemplate;
     languageId: string;
 }

package/dist/cjs/types/platforms/nest/__test__/server/app/companies/company.actions.d.ts

@@ -1,7 +1,7 @@
 import { EntityManagerRegistry, NestEntityActions } from "../../../../../..";
 import { CompanyCreateDto, CompanyDto, CompanyListItemDto, CompanyUpdateDto } from "./company.dto";
 import { CompanyEntity } from "../../database/core/entities/company.entity";
-import { CompanyCursor, CompanyEntityId, CompanyFacets, CompanySearchParameters, CompanySorting } from "../../entities/companies/company.models";
-export declare class CompanyActions extends NestEntityActions<CompanyEntity, CompanyEntityId, CompanyCreateDto, CompanyUpdateDto, CompanyDto, CompanyListItemDto, CompanySearchParameters, CompanySorting, CompanyCursor, CompanyFacets> {
+import { CompanyCursor, CompanyDeleteParameters, CompanyEntityId, CompanyFacets, CompanySearchParameters, CompanySorting } from "../../entities/companies/company.models";
+export declare class CompanyActions extends NestEntityActions<CompanyEntity, CompanyEntityId, CompanyCreateDto, CompanyUpdateDto, CompanyDto, CompanyListItemDto, CompanyDeleteParameters, CompanySearchParameters, CompanySorting, CompanyCursor, CompanyFacets> {
     constructor(registry: EntityManagerRegistry);
 }

package/dist/cjs/types/platforms/nest/__test__/server/app/divisions/division.actions.d.ts

@@ -1,7 +1,7 @@
 import { EntityManagerRegistry, NestEntityActions } from "../../../../../..";
 import { DivisionCreateDto, DivisionDto, DivisionListItemDto, DivisionUpdateDto } from "./division.dto";
 import { DivisionEntity } from "../../database/core/entities/division.entity";
-import { DivisionCursor, DivisionEntityId, DivisionFacets, DivisionSearchParameters, DivisionSorting } from "../../entities/divisions/division.models";
-export declare class DivisionActions extends NestEntityActions<DivisionEntity, DivisionEntityId, DivisionCreateDto, DivisionUpdateDto, DivisionDto, DivisionListItemDto, DivisionSearchParameters, DivisionSorting, DivisionCursor, DivisionFacets> {
+import { DivisionCursor, DivisionDeleteParameters, DivisionEntityId, DivisionFacets, DivisionSearchParameters, DivisionSorting } from "../../entities/divisions/division.models";
+export declare class DivisionActions extends NestEntityActions<DivisionEntity, DivisionEntityId, DivisionCreateDto, DivisionUpdateDto, DivisionDto, DivisionListItemDto, DivisionDeleteParameters, DivisionSearchParameters, DivisionSorting, DivisionCursor, DivisionFacets> {
     constructor(registry: EntityManagerRegistry);
 }

package/dist/cjs/types/platforms/nest/__test__/server/app/organizations/organization.actions.d.ts

@@ -1,7 +1,7 @@
 import { EntityManagerRegistry, NestEntityActions } from "../../../../../..";
 import { OrganizationCreateDto, OrganizationDto, OrganizationListItemDto, OrganizationUpdateDto } from "./organization.dto";
 import { OrganizationEntity } from "../../database/core/entities/organization.entity";
-import { OrganizationCursor, OrganizationEntityId, OrganizationFacets, OrganizationSearchParameters, OrganizationSorting } from "../../entities/organizations/organization.models";
-export declare class OrganizationActions extends NestEntityActions<OrganizationEntity, OrganizationEntityId, OrganizationCreateDto, OrganizationUpdateDto, OrganizationDto, OrganizationListItemDto, OrganizationSearchParameters, OrganizationSorting, OrganizationCursor, OrganizationFacets> {
+import { OrganizationCursor, OrganizationDeleteParameters, OrganizationEntityId, OrganizationFacets, OrganizationSearchParameters, OrganizationSorting } from "../../entities/organizations/organization.models";
+export declare class OrganizationActions extends NestEntityActions<OrganizationEntity, OrganizationEntityId, OrganizationCreateDto, OrganizationUpdateDto, OrganizationDto, OrganizationListItemDto, OrganizationDeleteParameters, OrganizationSearchParameters, OrganizationSorting, OrganizationCursor, OrganizationFacets> {
     constructor(registry: EntityManagerRegistry);
 }

package/dist/cjs/types/platforms/nest/__test__/server/app/organizations/organization.controller.d.ts

@@ -1,11 +1,15 @@
 import { OrganizationActions } from "./organization.actions";
 import { OrganizationCreateDto, OrganizationDto, OrganizationSearchRequest, OrganizationSearchResponse, OrganizationUpdateDto } from "./organization.dto";
+import { OrganizationRegisterTemplate } from "./templates/organization-register";
+import { OrganizationRegisterRequest, OrganizationRegisterResponse } from "./templates/organization-register/models";
 export declare class OrganizationController {
     private readonly actions;
-    constructor(actions: OrganizationActions);
+    private readonly registerPipeline;
+    constructor(actions: OrganizationActions, registerPipeline: OrganizationRegisterTemplate);
     item(id: string): Promise<OrganizationDto | undefined>;
     create(data: OrganizationCreateDto): Promise<OrganizationDto>;
     update(id: string, item: OrganizationUpdateDto): Promise<OrganizationDto>;
     delete(id: string): Promise<void>;
     search(request: OrganizationSearchRequest): Promise<OrganizationSearchResponse>;
+    register(request: OrganizationRegisterRequest): Promise<OrganizationRegisterResponse>;
 }

package/dist/cjs/types/platforms/nest/__test__/server/app/organizations/templates/index.d.ts

@@ -0,0 +1,2 @@
+import { OrganizationRegisterTemplate } from "./organization-register";
+export declare const OrganizationTemplates: (typeof OrganizationRegisterTemplate)[];

package/dist/cjs/types/platforms/nest/__test__/server/app/organizations/templates/organization-register/index.d.ts

@@ -0,0 +1,18 @@
+import { PipelineDefinition } from "../../../../../../../../types";
+import { IPipelineTemplateBuilder } from "../../../../../../pipelines/builder/types";
+import { NestPipelineTemplate } from "../../../../../../pipelines/template";
+import { CompanyEntityManager } from "../../../../entities/companies/company.manager";
+import { AppAuthContext } from "../../../../infrastructure/authentication";
+import { UserGroupEntityManager } from "../../../../entities/userGroups/userGroup.manager";
+import { OrganizationEntityManager } from "../../../../entities/organizations/organization.manager";
+import { TenantEntityManager } from "../../../../entities/tenants/tenant.manager";
+import { OrganizationRegisterRequest, OrganizationRegisterResponse } from "./models";
+export declare class OrganizationRegisterTemplate extends NestPipelineTemplate<OrganizationRegisterRequest, OrganizationRegisterResponse, AppAuthContext> {
+    private readonly organizations;
+    private readonly tenants;
+    private readonly companies;
+    private readonly userGroups;
+    constructor(organizations: OrganizationEntityManager, tenants: TenantEntityManager, companies: CompanyEntityManager, userGroups: UserGroupEntityManager);
+    protected isAuthorized(context: AppAuthContext): boolean;
+    protected buildTemplate(builder: IPipelineTemplateBuilder<OrganizationRegisterRequest, AppAuthContext>): PipelineDefinition<OrganizationRegisterRequest, OrganizationRegisterResponse, AppAuthContext>;
+}

package/dist/cjs/types/platforms/nest/__test__/server/app/organizations/templates/organization-register/models.d.ts

@@ -0,0 +1,17 @@
+export declare class OrganizationRegistrationInfo {
+    tenantId: string;
+    name: string;
+    uid: string;
+}
+export declare class CompanyRegistrationInfo {
+    name: string;
+    uid: string;
+}
+export declare class OrganizationRegisterRequest {
+    organization: OrganizationRegistrationInfo;
+    company: CompanyRegistrationInfo;
+}
+export declare class OrganizationRegisterResponse {
+    organizationId: string;
+    companyId: string;
+}

package/dist/cjs/types/platforms/nest/__test__/server/app/roles/role.actions.d.ts

@@ -1,7 +1,7 @@
 import { EntityManagerRegistry, NestEntityActions } from "../../../../../..";
 import { RoleCreateDto, RoleDto, RoleListItemDto, RoleUpdateDto } from "./role.dto";
 import { RoleEntity } from "../../database/core/entities/role.entity";
-import { RoleCursor, RoleEntityId, RoleFacets, RoleSearchParameters, RoleSorting } from "../../entities/roles/role.models";
-export declare class RoleActions extends NestEntityActions<RoleEntity, RoleEntityId, RoleCreateDto, RoleUpdateDto, RoleDto, RoleListItemDto, RoleSearchParameters, RoleSorting, RoleCursor, RoleFacets> {
+import { RoleCursor, RoleDeleteParameters, RoleEntityId, RoleFacets, RoleSearchParameters, RoleSorting } from "../../entities/roles/role.models";
+export declare class RoleActions extends NestEntityActions<RoleEntity, RoleEntityId, RoleCreateDto, RoleUpdateDto, RoleDto, RoleListItemDto, RoleDeleteParameters, RoleSearchParameters, RoleSorting, RoleCursor, RoleFacets> {
     constructor(registry: EntityManagerRegistry);
 }

package/dist/cjs/types/platforms/nest/__test__/server/app/tenants/templates/index.d.ts

@@ -0,0 +1,3 @@
+import { InstanceInitializeTemplate } from "./instance-initialize";
+import { TenantInitializeTemplate } from "./tenant-initialize";
+export declare const TenantTemplates: (typeof TenantInitializeTemplate | typeof InstanceInitializeTemplate)[];