@punks/backend-entity-manager 0.0.71 → 0.0.73

package/dist/esm/types/platforms/nest/pipelines/template/index.d.ts

@@ -0,0 +1,22 @@
+import { PipelineDefinition, PipelineResult } from "../../../../types";
+import { IPipelineTemplateBuilder } from "../builder/types";
+import { PipelineUtils } from "./utils";
+import { PipelineTemplateProps } from "../../decorators";
+export declare abstract class NestPipelineTemplate<TPipelineInput, TPipelineOutput, TContext> {
+    private readonly logger;
+    protected readonly utils: PipelineUtils<TPipelineInput, TPipelineOutput, TContext>;
+    private cachedDefinition;
+    protected abstract buildTemplate(builder: IPipelineTemplateBuilder<TPipelineInput, TContext>): PipelineDefinition<TPipelineInput, TPipelineOutput, TContext>;
+    protected isAuthorized(context: TContext): boolean;
+    invoke(input: TPipelineInput): Promise<TPipelineOutput>;
+    execute(data: {
+        input: TPipelineInput;
+        context: TContext;
+    }): Promise<PipelineResult<TPipelineInput, TPipelineOutput>>;
+    private getDefinition;
+    private buildDefinition;
+    private getContext;
+    private get controller();
+    private get registry();
+    protected get metadata(): PipelineTemplateProps;
+}

package/dist/esm/types/platforms/nest/pipelines/template/utils.d.ts

@@ -0,0 +1,6 @@
+import { PipelineCompletedStepState } from "../../../../types";
+export declare class PipelineUtils<TPipelineInput, TPipelineOutput, TContext> {
+    getStep: (step: PipelineCompletedStepState<TPipelineInput, TContext, unknown, unknown>, index: number) => PipelineCompletedStepState<TPipelineInput, TContext, unknown, unknown>;
+    getStepInput: <TStepInput>(step: PipelineCompletedStepState<TPipelineInput, TContext, unknown, unknown>, index: number) => TStepInput;
+    getStepOutput: <TStepOutput>(step: PipelineCompletedStepState<TPipelineInput, TContext, unknown, unknown>, index: number) => TStepOutput;
+}

package/dist/esm/types/platforms/nest/processors/initializer/index.d.ts

@@ -22,6 +22,7 @@ export declare class EntityManagerInitializer {
     private registerEventTrackingProviders;
     private registerEmailProviders;
     private registerEmailTemplates;
+    private registerPipelinesServices;
     private initializeProviders;
     private discoverRepositories;
     private discoverQueryBuilders;

package/dist/esm/types/platforms/nest/services/manager/index.d.ts

@@ -3,7 +3,7 @@ import { IEntityManager } from "../../../../abstractions";
 export declare class EntityManagerService {
     private readonly registry;
     constructor(registry: EntityManagerRegistry);
-    getManager<TEntity>(entityName: string): IEntityManager<TEntity, unknown, unknown, unknown, any, any, unknown, any>;
-    getActions<TEntity>(entityName: string): import("../../../../abstractions").IEntityActions<TEntity, unknown, unknown, unknown, unknown, unknown, any, any, unknown, any>;
+    getManager<TEntity>(entityName: string): IEntityManager<TEntity, unknown, unknown, unknown, any, any, any, unknown, any>;
+    getActions<TEntity>(entityName: string): import("../../../../abstractions").IEntityActions<TEntity, unknown, unknown, unknown, unknown, unknown, any, any, any, unknown, any>;
     getRepository<TEntity>(entityName: string): import("../../../../abstractions").IEntityRepository<TEntity, unknown, unknown, unknown, unknown, unknown>;
 }

package/dist/esm/types/platforms/nest/session/storage.d.ts

@@ -3,4 +3,4 @@
 import { AsyncLocalStorage } from "async_hooks";
 import { Request, Response } from "express";
 import { AppSession } from "./session";
-export declare const asyncLocalStorage: AsyncLocalStorage<AppSession<Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>, Response<any, Record<string, any>>>>;
+export declare const sessionStorage: AsyncLocalStorage<AppSession<Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>, Response<any, Record<string, any>>>>;

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

@@ -1,17 +1,18 @@
 import { IAuthenticationContext, IAuthenticationContextProvider, IEmailProvider, IEmailTemplatesCollection, IEventLog, IEventsTracker } from "../abstractions";
-import { IEntitiesSearchAction, IEntityActions, IEntityCreateAction, IEntityDeleteAction, IEntityGetAction, IEntityUpdateAction, IEntityUpsertAction } from "../abstractions/actions";
+import { IEntitiesCountAction, IEntitiesDeleteAction, IEntitiesSearchAction, IEntityActions, IEntityCreateAction, IEntityDeleteAction, IEntityExistsAction, IEntityGetAction, IEntityUpdateAction, IEntityUpsertAction } from "../abstractions/actions";
 import { IEntityAdapter } from "../abstractions/adapters";
 import { IEntityAuthorizationMiddleware } from "../abstractions/authorization";
-import { IEntityCreateCommand, IEntityDeleteCommand, IEntityUpdateCommand, IEntityUpsertCommand } from "../abstractions/commands";
+import { IEntitiesDeleteCommand, IEntitiesDeleteParameters, IEntityCreateCommand, IEntityDeleteCommand, IEntityUpdateCommand, IEntityUpsertCommand } from "../abstractions/commands";
 import { SortingType } from "../abstractions/common";
 import { IConnectorsConfiguration, IEntityConnectorDeleteManager, IEntityConnectorSyncManager } from "../abstractions/connectors";
 import { IEntityConverter } from "../abstractions/converters";
 import { IEntityEventsManager, IEventEmitter } from "../abstractions/events";
 import { IEntityManager } from "../abstractions/manager";
-import { IEntitiesQueryBuilder, IEntitiesSearchQuery, IEntityFacets, IEntityGetQuery } from "../abstractions/queries";
+import { IPipelinesController } from "../abstractions/pipelines";
+import { IEntitiesCountQuery, IEntitiesQueryBuilder, IEntitiesSearchQuery, IEntityExistsQuery, IEntityFacets, IEntityGetQuery } from "../abstractions/queries";
 import { IEntityReplicaDeleteManager, IEntityReplicaSyncManager, IReplicasConfiguration } from "../abstractions/replication";
 import { IEntityRepository } from "../abstractions/repository";
-import { IEntitySearchParameters } from "../abstractions/searchParameters";
+import { IEntitySearchParameters, ISearchFilters } from "../abstractions/searchParameters";
 import { ServiceLocator } from "../ioc";
 export declare class EntityServiceLocator<TEntity, TEntityId> {
     private readonly services;
@@ -19,8 +20,8 @@ export declare class EntityServiceLocator<TEntity, TEntityId> {
     constructor(services: EntitiesServiceLocator, entityName: string);
     getRootServices(): EntitiesServiceLocator;
     resolveAuthenticationContextProvider<TAuthenticationContextProvider extends IAuthenticationContextProvider<TUserContext>, TUserContext>(): TAuthenticationContextProvider;
-    resolveEntityManager(): IEntityManager<TEntity, unknown, unknown, unknown, any, any, unknown, any>;
-    resolveEntityActions(): IEntityActions<TEntity, TEntityId, unknown, unknown, unknown, unknown, any, any, unknown, any>;
+    resolveEntityManager(): IEntityManager<TEntity, unknown, unknown, unknown, any, any, any, unknown, any>;
+    resolveEntityActions(): IEntityActions<TEntity, TEntityId, unknown, unknown, unknown, unknown, any, any, any, unknown, any>;
     resolveRepository<TGetConditions, TFindCondition, TUpdateCondition, TDeleteCondition>(): IEntityRepository<TEntity, TEntityId, TGetConditions, TFindCondition, TUpdateCondition, TDeleteCondition>;
     resolveEventsManager(): IEntityEventsManager<TEntity, TEntityId>;
     resolveReplicaSyncManager(): IEntityReplicaSyncManager<TEntity>;
@@ -33,17 +34,23 @@ export declare class EntityServiceLocator<TEntity, TEntityId> {
     resolveAdapter<TEntityCreateData, TEntityUpdateData>(): IEntityAdapter<TEntity, TEntityCreateData, TEntityUpdateData> | undefined;
     resolveAuthorizationMiddleware<TAuthenticationContext extends IAuthenticationContext<TUserContext>, TUserContext>(): IEntityAuthorizationMiddleware<TEntity, TAuthenticationContext, TUserContext> | undefined;
     resolveGetQuery<TEntityId>(): IEntityGetQuery<TEntity, TEntityId>;
+    resolveExistsQuery<TEntityFilters extends ISearchFilters>(): IEntityExistsQuery<TEntity, TEntityFilters>;
+    resolveCountQuery<TEntityFilters extends ISearchFilters>(): IEntitiesCountQuery<TEntity, TEntityFilters>;
     resolveSearchQuery<TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets>(): IEntitiesSearchQuery<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets>;
     resolveCreateCommand<TEntityCreateData>(): IEntityCreateCommand<TEntity, TEntityCreateData>;
     resolveUpdateCommand<TEntityUpdateData>(): IEntityUpdateCommand<TEntity, TEntityId, TEntityUpdateData>;
     resolveUpsertCommand<TEntityUpdateData>(): IEntityUpsertCommand<TEntity, TEntityId, TEntityUpdateData>;
     resolveDeleteCommand<TEntityId>(): IEntityDeleteCommand<TEntity, TEntityId>;
+    resolveDeleteItemsCommand<TEntitiesDeleteParameters extends IEntitiesDeleteParameters<TSorting>, TSorting>(): IEntitiesDeleteCommand<TEntity, TEntitiesDeleteParameters, TSorting>;
     resolveGetAction<TEntityId, TEntityDto>(): IEntityGetAction<TEntity, TEntityId, TEntityDto>;
+    resolveExistsAction<TEntityFilters extends ISearchFilters>(): IEntityExistsAction<TEntity, TEntityFilters>;
+    resolveCountAction<TEntityFilters extends ISearchFilters>(): IEntitiesCountAction<TEntity, TEntityFilters>;
     resolveSearchAction<TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TEntityListItemDto, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets>(): IEntitiesSearchAction<TEntity, TEntitySearchParameters, TEntityListItemDto, TSorting, TCursor, TFacets>;
     resolveCreateAction<TEntityCreateData, TEntityDto>(): IEntityCreateAction<TEntity, TEntityCreateData, TEntityDto>;
     resolveUpdateAction<TEntityUpdateData, TEntityDto>(): IEntityUpdateAction<TEntity, TEntityId, TEntityUpdateData, TEntityDto>;
     resolveUpsertAction<TEntityUpdateData, TEntityDto>(): IEntityUpsertAction<TEntity, TEntityId, TEntityUpdateData, TEntityDto>;
     resolveDeleteAction(): IEntityDeleteAction<TEntity, TEntityId>;
+    resolveDeleteItemsAction<TEntitiesDeleteParameters extends IEntitiesDeleteParameters<TSorting>, TSorting>(): IEntitiesDeleteAction<TEntity, TEntitiesDeleteParameters, TSorting>;
     resolveQueryBuilder<TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets, TUserContext>(): IEntitiesQueryBuilder<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets, TUserContext>;
     getEntityName(): string;
 }
@@ -59,12 +66,14 @@ export declare class EntitiesServiceLocator {
     registerEventsTracker<TEventsTracker extends IEventsTracker<TEventLog>, TEventLog extends IEventLog<unknown>>(instance: TEventsTracker): void;
     resolveEmailTemplatesCollection(): IEmailTemplatesCollection;
     registerEmailTemplatesCollection(instance: IEmailTemplatesCollection): void;
+    resolvePipelinesController(): IPipelinesController;
+    registerPipelinesController(instance: IPipelinesController): void;
     resolveAuthenticationContextProvider<TAuthenticationContextProvider extends IAuthenticationContextProvider<TUserContext>, TUserContext>(): TAuthenticationContextProvider;
     registerAuthenticationContextProvider<TAuthenticationContextProvider extends IAuthenticationContextProvider<TUserContext>, TUserContext>(instance: TAuthenticationContextProvider): void;
-    resolveEntityManager<TEntity>(entityName: string): IEntityManager<TEntity, unknown, unknown, unknown, any, any, unknown, any>;
-    registerEntityManager<TEntity>(entityName: string, instance: IEntityManager<TEntity, unknown, unknown, unknown, any, any, unknown, any>): void;
-    resolveEntityActions<TEntity>(entityName: string): IEntityActions<TEntity, unknown, unknown, unknown, unknown, unknown, any, any, unknown, any>;
-    registerEntityActions<TEntity>(entityName: string, instance: IEntityActions<TEntity, unknown, unknown, unknown, unknown, unknown, any, any, unknown, any>): void;
+    resolveEntityManager<TEntity>(entityName: string): IEntityManager<TEntity, unknown, unknown, unknown, any, any, any, unknown, any>;
+    registerEntityManager<TEntity>(entityName: string, instance: IEntityManager<TEntity, unknown, unknown, unknown, any, any, any, unknown, any>): void;
+    resolveEntityActions<TEntity>(entityName: string): IEntityActions<TEntity, unknown, unknown, unknown, unknown, unknown, any, any, any, unknown, any>;
+    registerEntityActions<TEntity>(entityName: string, instance: IEntityActions<TEntity, unknown, unknown, unknown, unknown, unknown, any, any, any, unknown, any>): void;
     resolveRepository<TEntity, TEntityId, TGetConditions, TFindCondition, TUpdateCondition, TDeleteCondition>(entityName: string): IEntityRepository<TEntity, TEntityId, TGetConditions, TFindCondition, TUpdateCondition, TDeleteCondition>;
     registerRepository<TEntity, TEntityId, TGetConditions, TFindCondition, TUpdateCondition, TDeleteCondition>(entityName: string, instance: IEntityRepository<TEntity, TEntityId, TGetConditions, TFindCondition, TUpdateCondition, TDeleteCondition>): void;
     resolveEventsManager<TEntity, TEntityId>(entityName: string): IEntityEventsManager<TEntity, TEntityId>;
@@ -91,16 +100,26 @@ export declare class EntitiesServiceLocator {
     registerGetQuery<TEntity, TEntityId>(entityName: string, instance: IEntityGetQuery<TEntity, TEntityId>): void;
     resolveSearchQuery<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets>(entityName: string): IEntitiesSearchQuery<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets>;
     registerSearchQuery<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets>(entityName: string, instance: IEntitiesSearchQuery<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets>): void;
+    resolveExistsQuery<TEntity, TEntityFilters extends ISearchFilters>(entityName: string): IEntityExistsQuery<TEntity, TEntityFilters>;
+    registerExistsQuery<TEntity, TEntityFilters extends ISearchFilters>(entityName: string, instance: IEntityExistsQuery<TEntity, TEntityFilters>): void;
+    resolveCountQuery<TEntity, TEntityFilters extends ISearchFilters>(entityName: string): IEntitiesCountQuery<TEntity, TEntityFilters>;
+    registerCountQuery<TEntity, TEntityFilters extends ISearchFilters>(entityName: string, instance: IEntitiesCountQuery<TEntity, TEntityFilters>): void;
     resolveCreateCommand<TEntity, TEntityCreateData>(entityName: string): IEntityCreateCommand<TEntity, TEntityCreateData>;
     registerCreateCommand<TEntity, TEntityCreateData>(entityName: string, instance: IEntityCreateCommand<TEntity, TEntityCreateData>): void;
     resolveUpdateCommand<TEntity, TEntityId, TEntityUpdateData>(entityName: string): IEntityUpdateCommand<TEntity, TEntityId, TEntityUpdateData>;
     registerUpdateCommand<TEntity, TEntityId, TEntityUpdateData>(entityName: string, instance: IEntityUpdateCommand<TEntity, TEntityId, TEntityUpdateData>): void;
     resolveUpsertCommand<TEntity, TEntityId, TEntityUpdateData>(entityName: string): IEntityUpsertCommand<TEntity, TEntityId, TEntityUpdateData>;
     registerUpsertCommand<TEntity, TEntityId, TEntityUpdateData>(entityName: string, instance: IEntityUpsertCommand<TEntity, TEntityId, TEntityUpdateData>): void;
+    resolveDeleteItemsCommand<TEntity, TEntitiesDeleteParameters extends IEntitiesDeleteParameters<TSorting>, TSorting>(entityName: string): IEntitiesDeleteCommand<TEntity, TEntitiesDeleteParameters, TSorting>;
+    registerDeleteItemsCommand<TEntity, TEntitiesDeleteParameters extends IEntitiesDeleteParameters<TSorting>, TSorting>(entityName: string, instance: IEntitiesDeleteCommand<TEntity, TEntitiesDeleteParameters, TSorting>): void;
     resolveDeleteCommand<TEntity, TEntityId>(entityName: string): IEntityDeleteCommand<TEntity, TEntityId>;
     registerDeleteCommand<TEntity, TEntityId>(entityName: string, instance: IEntityDeleteCommand<TEntity, TEntityId>): void;
     resolveGetAction<TEntity, TEntityId, TEntityDto>(entityName: string): IEntityGetAction<TEntity, TEntityId, TEntityDto>;
     registerGetAction<TEntity, TEntityId, TEntityDto>(entityName: string, instance: IEntityGetAction<TEntity, TEntityId, TEntityDto>): void;
+    resolveExistsAction<TEntity, TEntityFilters extends ISearchFilters>(entityName: string): IEntityExistsAction<TEntity, TEntityFilters>;
+    registerExistsAction<TEntity, TEntityFilters extends ISearchFilters>(entityName: string, instance: IEntityExistsAction<TEntity, TEntityFilters>): void;
+    resolveCountAction<TEntity, TEntityFilters extends ISearchFilters>(entityName: string): IEntitiesCountAction<TEntity, TEntityFilters>;
+    registerCountAction<TEntity, TEntityFilters extends ISearchFilters>(entityName: string, instance: IEntitiesCountAction<TEntity, TEntityFilters>): void;
     resolveSearchAction<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TEntityListItemDto, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets>(entityName: string): IEntitiesSearchAction<TEntity, TEntitySearchParameters, TEntityListItemDto, TSorting, TCursor, TFacets>;
     registerSearchAction<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TEntityListItemDto, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets>(entityName: string, instance: IEntitiesSearchAction<TEntity, TEntitySearchParameters, TEntityListItemDto, TSorting, TCursor, TFacets>): void;
     resolveCreateAction<TEntity, TEntityCreateData, TEntityDto>(entityName: string): IEntityCreateAction<TEntity, TEntityCreateData, TEntityDto>;
@@ -111,6 +130,8 @@ export declare class EntitiesServiceLocator {
     registerUpsertAction<TEntity, TEntityId, TEntityUpdateData, TEntityDto>(entityName: string, instance: IEntityUpsertAction<TEntity, TEntityId, TEntityUpdateData, TEntityDto>): void;
     resolveDeleteAction<TEntity, TEntityId>(entityName: string): IEntityDeleteAction<TEntity, TEntityId>;
     registerDeleteAction<TEntity, TEntityId>(entityName: string, instance: IEntityDeleteAction<TEntity, TEntityId>): void;
+    resolveDeleteItemsAction<TEntity, TEntitiesDeleteParameters extends IEntitiesDeleteParameters<TSorting>, TSorting>(entityName: string): IEntitiesDeleteAction<TEntity, TEntitiesDeleteParameters, TSorting>;
+    registerDeleteItemsAction<TEntity, TEntitiesDeleteParameters extends IEntitiesDeleteParameters<TSorting>, TSorting>(entityName: string, instance: IEntitiesDeleteAction<TEntity, TEntitiesDeleteParameters, TSorting>): 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;
 }

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

@@ -0,0 +1,10 @@
+import { ISearchFilters } from "../abstractions";
+import { IEntitiesCountQuery } from "../abstractions/queries";
+import { EntityServiceLocator } from "../providers/services";
+export declare class EntitiesCountQuery<TEntity, TEntityFilters extends ISearchFilters, TUserContext> implements IEntitiesCountQuery<TEntity, TEntityFilters> {
+    private readonly services;
+    constructor(services: EntityServiceLocator<TEntity, unknown>);
+    execute(filters: TEntityFilters): Promise<number>;
+    private getContext;
+    private authorizeSearch;
+}

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

@@ -0,0 +1,10 @@
+import { ISearchFilters } from "../abstractions";
+import { IEntityExistsQuery } from "../abstractions/queries";
+import { EntityServiceLocator } from "../providers/services";
+export declare class EntityExistsQuery<TEntity, TEntityFilters extends ISearchFilters, TUserContext> implements IEntityExistsQuery<TEntity, TEntityFilters> {
+    private readonly services;
+    constructor(services: EntityServiceLocator<TEntity, unknown>);
+    execute(filters: TEntityFilters): Promise<boolean>;
+    private getContext;
+    private authorizeSearch;
+}

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

@@ -1,6 +1,9 @@
 export declare const EntityServices: {
     Actions: {
         IEntityGetAction: string;
+        IEntityExistsAction: string;
+        IEntitiesCountAction: string;
+        IEntitiesDeleteAction: string;
         IEntitiesSearchAction: string;
         IEntityCreateAction: string;
         IEntityUpdateAction: string;
@@ -17,6 +20,7 @@ export declare const EntityServices: {
         IEntityUpsertCommand: string;
         IEntityMergeCommand: string;
         IEntityDeleteCommand: string;
+        IEntitiesDeleteCommand: string;
     };
     Converters: {
         IEntityAdapter: string;
@@ -31,6 +35,8 @@ export declare const EntityServices: {
         IEntityEventsManager: string;
     };
     Queries: {
+        IEntityCountQuery: string;
+        IEntityExistsQuery: string;
         IEntityGetQuery: string;
         IEntitiesSearchQuery: string;
         IEntitiesQueryBuilder: string;
@@ -60,4 +66,7 @@ export declare const GlobalServices: {
         IEmailProvider: string;
         IEmailTemplatesCollection: string;
     };
+    Pipelines: {
+        IPipelineController: string;
+    };
 };

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

@@ -1 +1,2 @@
+export * from "./pipelines";
 export { QueryBuilderBase } from "./queryBuilder";

package/dist/esm/types/templates/pipelines/controller/index.d.ts

@@ -0,0 +1,5 @@
+import { IPipelineInstance, IPipelinesController } from "../../../abstractions/pipelines";
+import { PipelineDefinition } from "../../../types";
+export declare class PipelineController implements IPipelinesController {
+    createInstance<TInput, TOutput, TContext>(definition: PipelineDefinition<TInput, TOutput, TContext>, input: TInput, context: TContext): Promise<IPipelineInstance<TInput, TOutput, TContext>>;
+}

package/dist/esm/types/templates/pipelines/converters/index.d.ts

@@ -0,0 +1,5 @@
+import { PipelineErrorType, PipelineOperationError, PipelineOperationResult, PipelineStepErrorType, PipelineStepResult } from "../../../types";
+export declare const toPipelineOperationError: (error: Error) => PipelineOperationError;
+export declare const getStepOutput: <TStepInput, TStepOutput>(result: PipelineStepResult<TStepInput, TStepOutput>) => TStepOutput | undefined;
+export declare const getOperationOutput: <TStepInput, TStepOutput>(result: PipelineOperationResult<TStepInput, TStepOutput>) => TStepOutput | undefined;
+export declare const mapPipelineErrorType: (stepError: PipelineStepErrorType) => PipelineErrorType;

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

@@ -0,0 +1 @@
+export { PipelineController } from "./controller";

package/dist/esm/types/templates/pipelines/instance/index.d.ts

@@ -0,0 +1,19 @@
+import { IPipelineInstance } from "../../../abstractions/pipelines";
+import { PipelineDefinition, PipelineResult } from "../../../types";
+export declare class PipelineInstance<TPipelineInput, TPipelineOutput, TContext> implements IPipelineInstance<TPipelineInput, TPipelineOutput, TContext> {
+    private readonly definition;
+    private readonly input;
+    private readonly context;
+    private status;
+    constructor(definition: PipelineDefinition<TPipelineInput, TPipelineOutput, TContext>, input: TPipelineInput, context: TContext);
+    execute(): Promise<PipelineResult<TPipelineInput, TPipelineOutput>>;
+    private buildInitialStepState;
+    private buildNextStepState;
+    private rollbackSteps;
+    private rollbackStep;
+    private validateStepPrecondition;
+    private executeStep;
+    private executeOperation;
+    private rollbackOperations;
+    private rollbackOperation;
+}

package/dist/{cjs/types/templates/queryBuilder.d.ts → esm/types/templates/queryBuilder/index.d.ts}

@@ -1,7 +1,11 @@
-import { IAuthenticationContext, IEntitiesQueryBuilder, IEntityFacets, IEntitySearchParameters, ISearchRequestPaging } from "../abstractions";
-import { SortingType } from "../abstractions/common";
-import { IEntitiesSearchResults, IEntitiesSearchResultsPaging } from "../models";
+import { IAuthenticationContext, IEntitiesQueryBuilder, IEntityFacets, IEntitySearchParameters, ISearchRequestPaging } from "../../abstractions";
+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> {
+    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>;
     abstract search(request: TEntitySearchParameters, context?: IAuthenticationContext<TUserContext>): Promise<IEntitiesSearchResults<TEntitySearchParameters, TEntity, TSorting, TCursor, TFacets>>;
     protected getIndexBasedPagingResult({ paging, totResults, currentPageResults, }: {
         paging?: ISearchRequestPaging<number>;

package/dist/esm/types/testing/mocks/repository.d.ts

@@ -1,5 +1,5 @@
 import { FilterExpression } from "../../abstractions/filters";
-import { IEntityRepository } from "../../abstractions/repository";
+import { IEntitiesDeleteResult, IEntityRepository } from "../../abstractions/repository";
 export declare class InMemoryRepository<TEntity> implements IEntityRepository<TEntity, string, FilterExpression<TEntity>, FilterExpression<TEntity>, FilterExpression<TEntity>, FilterExpression<TEntity>> {
     private entities;
     exists(id: string): Promise<boolean>;
@@ -11,7 +11,7 @@ export declare class InMemoryRepository<TEntity> implements IEntityRepository<TE
     count(condition: FilterExpression<TEntity>): Promise<number>;
     findById(id: string[]): Promise<TEntity[]>;
     delete(id: string): Promise<void>;
-    deleteBy(condition: FilterExpression<TEntity>): Promise<void>;
+    deleteBy(condition: FilterExpression<TEntity>): Promise<IEntitiesDeleteResult>;
     create(entity: TEntity): Promise<TEntity>;
     update(id: string, entity: Partial<TEntity>): Promise<TEntity>;
     updateBy(entity: Partial<TEntity>, condition: FilterExpression<TEntity>): Promise<TEntity[]>;

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

@@ -0,0 +1,2 @@
+export * from "./objects";
+export * from "./pipelines";

package/dist/esm/types/types/objects.d.ts

@@ -0,0 +1,4 @@
+export type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+export type NonNullable<T> = T;

package/dist/esm/types/types/pipelines.d.ts

@@ -0,0 +1,109 @@
+export type PipelineStepState<TPipelineInput, TContext, TStepInput> = {
+    context: TContext;
+    stepInput: TStepInput;
+    pipelineInput: TPipelineInput;
+    previousStep?: PipelineCompletedStepState<TPipelineInput, TContext, any, TStepInput>;
+};
+export type PipelineCompletedStepState<TPipelineInput, TContext, TStepInput, TStepOutput> = PipelineStepState<TPipelineInput, TContext, TStepInput> & {
+    stepOutput?: TStepOutput;
+};
+export type PipelineCurrentStepState<TPipelineInput, TContext, TStepInput> = PipelineStepState<TPipelineInput, TContext, TStepInput> & {};
+export type OperationDefinition<TOperationInput, TOperationOutput, TCurrentStepInput, TPipelineInput, TContext> = {
+    name: string;
+    action: (input: TOperationInput, state: PipelineCurrentStepState<TPipelineInput, TContext, TCurrentStepInput>) => Promise<TOperationOutput> | TOperationOutput;
+    precondition?: (input: TOperationInput, state: PipelineCurrentStepState<TPipelineInput, TContext, TCurrentStepInput>) => Promise<boolean> | boolean;
+};
+export type RollbackOperationDefinition<TOperationInput, TOperationOutput, TCurrentStepInput, TPipelineInput, TContext> = {
+    name: string;
+    action: (input: TOperationInput, output: TOperationOutput, state: PipelineCurrentStepState<TPipelineInput, TContext, TCurrentStepInput>) => Promise<void> | void;
+};
+export type PipelineStepOperation<TOperationInput, TOperationOutput, TCurrentStepInput, TPipelineInput, TContext> = {
+    name: string;
+    operation: OperationDefinition<TOperationInput, TOperationOutput, TCurrentStepInput, TPipelineInput, TContext>;
+    rollbackOperations?: RollbackOperationDefinition<TOperationInput, TOperationOutput, TCurrentStepInput, TPipelineInput, TContext>[];
+};
+export type PipelineStep<TStepInput, TStepOutput, TPipelineInput, TContext> = {
+    name: string;
+    operations: PipelineStepOperation<TStepInput, TStepOutput, TStepInput, TPipelineInput, TContext>[];
+    outputsReducer?: (results: unknown[]) => TStepOutput;
+};
+export type PipelineDefinition<TPipelineInput, TPipelineOutput, TContext> = {
+    steps: PipelineStep<unknown, unknown, TPipelineInput, TContext>[];
+};
+export type PipelineOperationError = {
+    message: string;
+    exception?: Error;
+};
+export type PipelineOperationResult<TOperationInput, TOperationOutput> = {
+    input: TOperationInput;
+} & ({
+    type: "success";
+    output: TOperationOutput;
+} | {
+    type: "preconditionFailed";
+} | {
+    type: "error" | "rollbackCompleted";
+    error: PipelineOperationError;
+} | {
+    type: "rollbackFailed";
+    rollbackError: PipelineOperationError;
+    error: PipelineOperationError;
+});
+export type PipelineOperationResultType = PipelineOperationResult<unknown, unknown>["type"];
+export type PipelineOperationRollbackResult = {
+    type: "success" | "skipped";
+} | {
+    type: "error";
+    error: PipelineOperationError;
+};
+export type PipelineOperationRollbackResultType = PipelineOperationRollbackResult["type"];
+export declare enum PipelineStepErrorType {
+    FailedPrecondition = "failedPrecondition",
+    OperationError = "operationError",
+    RollbackError = "rollbackError",
+    GenericError = "genericError"
+}
+export type PipelineStepResult<TStepInput, TStepOutput> = {
+    input: TStepInput;
+    operationResults: PipelineOperationResult<unknown, unknown>[];
+} & ({
+    type: "success";
+    output: TStepOutput;
+} | {
+    type: "error";
+    errorType: PipelineStepErrorType;
+});
+export type PipelineStepResultType = PipelineStepResult<unknown, unknown>["type"];
+export type PipelineStepRollbackResult = {} & ({
+    type: "success";
+} | {
+    type: "error";
+});
+export type PipelineStepRollbackResultType = PipelineStepRollbackResult["type"];
+export declare enum PipelineErrorType {
+    FailedPrecondition = "failedPrecondition",
+    OperationError = "operationError",
+    RollbackError = "rollbackError",
+    Unauthorized = "unauthorized",
+    GenericError = "genericError"
+}
+export type PipelineResult<TPipelineInput, TPipelineOutput> = {
+    stepResults: PipelineStepResult<unknown, unknown>[];
+    input: TPipelineInput;
+} & ({
+    type: "success";
+    output: TPipelineOutput;
+} | {
+    type: "error";
+    errorType: PipelineErrorType;
+    exception?: Error;
+    output?: TPipelineOutput;
+});
+export type PipelineResultType = PipelineResult<unknown, unknown>["type"];
+export declare enum PipelineStatus {
+    Initializing = "initializing",
+    Running = "running",
+    RollbackInProgress = "rollbackInProgress",
+    Completed = "completed",
+    Failed = "failed"
+}