@punks/backend-entity-manager 0.0.70 → 0.0.72

package/dist/esm/index.js

@@ -114,12 +114,11 @@ class NestEntityActions {
     constructor(entityName, registry) {
         this.services = registry.resolveEntityServicesCollection(entityName);
     }
-    get provider() {
+    get manager() {
         if (!this.actionsInstance) {
             this.actionsInstance =
                 this.services.resolveEntityActions();
         }
-        this.services.resolveEntityActions;
         return this.actionsInstance;
     }
 }
@@ -129,7 +128,7 @@ class NestEntityManager {
     constructor(entityName, registry) {
         this.services = registry.resolveEntityServicesCollection(entityName);
     }
-    get provider() {
+    get manager() {
         if (!this.managerInstance) {
             this.managerInstance =
                 this.services.resolveEntityManager();
@@ -153,6 +152,7 @@ const EntityManagerSymbols = {
     EntitySeeder: Symbol.for("WP:ENTITY_SEEDER"),
     EmailProvider: Symbol.for("WP:EMAIL_PROVIDER"),
     EmailTemplate: Symbol.for("WP:EMAIL_TEMPLATE"),
+    PipelineTemplate: Symbol.for("WP:PIPELINE_TEMPLATE"),
 };
 
 const WpEntityAuthMiddleware = (entityName, props = {}) => applyDecorators(Injectable(), SetMetadata(EntityManagerSymbols.EntityAuthMiddleware, {
@@ -209,6 +209,11 @@ const WpEntityQueryBuilder = (entityName, props = {}) => applyDecorators(Injecta
     ...props,
 }));
 
+const WpPipeline = (name, props = {}) => applyDecorators(Injectable(), SetMetadata(EntityManagerSymbols.PipelineTemplate, {
+    name,
+    ...props,
+}));
+
 const WpEntitySeeder = (entityName, props = {}) => applyDecorators(Injectable(), SetMetadata(EntityManagerSymbols.EntitySeeder, {
     entityName,
     ...props,
@@ -459,6 +464,15 @@ AppHashingService = __decorate([
     Injectable()
 ], AppHashingService);
 
+class EntitiesCountAction {
+    constructor(services) {
+        this.services = services;
+    }
+    async execute(filters) {
+        return await this.services.resolveCountQuery().execute(filters);
+    }
+}
+
 class EntityCreateAction {
     constructor(services) {
         this.services = services;
@@ -486,6 +500,24 @@ class EntityDeleteAction {
     }
 }
 
+class EntitiesDeleteAction {
+    constructor(services) {
+        this.services = services;
+    }
+    async execute(params) {
+        await this.services.resolveDeleteItemsCommand().execute(params);
+    }
+}
+
+class EntityExistsAction {
+    constructor(services) {
+        this.services = services;
+    }
+    async execute(filters) {
+        return await this.services.resolveExistsQuery().execute(filters);
+    }
+}
+
 class EntityGetAction {
     constructor(services) {
         this.services = services;
@@ -603,6 +635,40 @@ class EntityDeleteCommand {
     }
 }
 
+class EntitiesDeleteCommand {
+    constructor(services) {
+        this.services = services;
+    }
+    async execute(params) {
+        await this.authorize();
+        const context = await this.getContext();
+        const deleteResult = await this.services
+            .resolveQueryBuilder()
+            .delete(params.filters, context);
+        // todo: add entities deleted event
+        return deleteResult;
+    }
+    async getContext() {
+        const authorization = this.services.resolveAuthorizationMiddleware();
+        if (!authorization) {
+            return undefined;
+        }
+        const contextService = this.services.resolveAuthenticationContextProvider();
+        return await contextService.getContext();
+    }
+    async authorize() {
+        const authorization = this.services.resolveAuthorizationMiddleware();
+        if (!authorization) {
+            return;
+        }
+        const contextService = this.services.resolveAuthenticationContextProvider();
+        const context = await contextService.getContext();
+        const authorizationResult = await authorization.canDeleteItems(context);
+        if (!authorizationResult.isAuthorized)
+            throw new EntityOperationUnauthorizedException(EntityOperationType.Delete, this.services.getEntityName());
+    }
+}
+
 class EntityUpdateCommand {
     constructor(services) {
         this.services = services;
@@ -687,23 +753,31 @@ class EntityManager {
     constructor(services) {
         this.services = services;
     }
-    get() {
+    get exists() {
+        return this.services.resolveExistsQuery();
+    }
+    get count() {
+        return this.services.resolveCountQuery();
+    }
+    get deleteItems() {
+        return this.services.resolveDeleteItemsCommand();
+    }
+    get get() {
         return this.services.resolveGetQuery();
     }
-    // @ts-ignore
-    search() {
+    get search() {
         return this.services.resolveSearchQuery();
     }
-    create() {
+    get create() {
         return this.services.resolveCreateCommand();
     }
-    update() {
+    get update() {
         return this.services.resolveUpdateCommand();
     }
-    upsert() {
+    get upsert() {
         return this.services.resolveUpsertCommand();
     }
-    delete() {
+    get delete() {
         return this.services.resolveDeleteCommand();
     }
 }
@@ -711,22 +785,31 @@ class EntityActions {
     constructor(services) {
         this.services = services;
     }
-    get() {
+    get exists() {
+        return this.services.resolveExistsAction();
+    }
+    get count() {
+        return this.services.resolveCountAction();
+    }
+    get deleteItems() {
+        return this.services.resolveDeleteItemsAction();
+    }
+    get get() {
         return this.services.resolveGetAction();
     }
-    search() {
+    get search() {
         return this.services.resolveSearchAction();
     }
-    create() {
+    get create() {
         return this.services.resolveCreateAction();
     }
-    update() {
+    get update() {
         return this.services.resolveUpdateAction();
     }
-    upsert() {
+    get upsert() {
         return this.services.resolveUpsertAction();
     }
-    delete() {
+    get delete() {
         return this.services.resolveDeleteAction();
     }
 }
@@ -772,6 +855,9 @@ class ServiceLocator {
 const EntityServices = {
     Actions: {
         IEntityGetAction: "IEntityGetAction",
+        IEntityExistsAction: "IEntityExistsAction",
+        IEntitiesCountAction: "IEntitiesCountAction",
+        IEntitiesDeleteAction: "IEntitiesDeleteAction",
         IEntitiesSearchAction: "IEntitiesSearchAction",
         IEntityCreateAction: "IEntityCreateAction",
         IEntityUpdateAction: "IEntityUpdateAction",
@@ -788,6 +874,7 @@ const EntityServices = {
         IEntityUpsertCommand: "IEntityUpsertCommand",
         IEntityMergeCommand: "IEntityMergeCommand",
         IEntityDeleteCommand: "IEntityDeleteCommand",
+        IEntitiesDeleteCommand: "IEntitiesDeleteCommand",
     },
     Converters: {
         IEntityAdapter: "IEntityAdapter",
@@ -802,6 +889,8 @@ const EntityServices = {
         IEntityEventsManager: "IEntityEventsManager",
     },
     Queries: {
+        IEntityCountQuery: "IEntityCountQuery",
+        IEntityExistsQuery: "IEntityExistsQuery",
         IEntityGetQuery: "IEntityGetQuery",
         IEntitiesSearchQuery: "IEntitiesSearchQuery",
         IEntitiesQueryBuilder: "IEntitiesQueryBuilder",
@@ -831,6 +920,9 @@ const GlobalServices = {
         IEmailProvider: "IEmailProvider",
         IEmailTemplatesCollection: "IEmailTemplatesCollection",
     },
+    Pipelines: {
+        IPipelineController: "IPipelineController",
+    },
 };
 
 class EntityServiceLocator {
@@ -886,6 +978,12 @@ class EntityServiceLocator {
     resolveGetQuery() {
         return this.services.resolveGetQuery(this.entityName);
     }
+    resolveExistsQuery() {
+        return this.services.resolveExistsQuery(this.entityName);
+    }
+    resolveCountQuery() {
+        return this.services.resolveCountQuery(this.entityName);
+    }
     resolveSearchQuery() {
         return this.services.resolveSearchQuery(this.entityName);
     }
@@ -904,9 +1002,18 @@ class EntityServiceLocator {
     resolveDeleteCommand() {
         return this.services.resolveDeleteCommand(this.entityName);
     }
+    resolveDeleteItemsCommand() {
+        return this.services.resolveDeleteItemsCommand(this.entityName);
+    }
     resolveGetAction() {
         return this.services.resolveGetAction(this.entityName);
     }
+    resolveExistsAction() {
+        return this.services.resolveExistsAction(this.entityName);
+    }
+    resolveCountAction() {
+        return this.services.resolveCountAction(this.entityName);
+    }
     resolveSearchAction() {
         return this.services.resolveSearchAction(this.entityName);
     }
@@ -922,6 +1029,9 @@ class EntityServiceLocator {
     resolveDeleteAction() {
         return this.services.resolveDeleteAction(this.entityName);
     }
+    resolveDeleteItemsAction() {
+        return this.services.resolveDeleteItemsAction(this.entityName);
+    }
     resolveQueryBuilder() {
         return this.services.resolveQueryBuilder(this.entityName);
     }
@@ -962,6 +1072,12 @@ class EntitiesServiceLocator {
     registerEmailTemplatesCollection(instance) {
         this.provider.register(GlobalServices.Messaging.IEmailTemplatesCollection, instance);
     }
+    resolvePipelinesController() {
+        return this.provider.resolve(GlobalServices.Pipelines.IPipelineController);
+    }
+    registerPipelinesController(instance) {
+        this.provider.register(GlobalServices.Pipelines.IPipelineController, instance);
+    }
     resolveAuthenticationContextProvider() {
         return this.provider.resolve(GlobalServices.Authentication.IAuthenticationContextProvider);
     }
@@ -1064,6 +1180,18 @@ class EntitiesServiceLocator {
     registerSearchQuery(entityName, instance) {
         this.provider.registerEntityService(EntityServices.Queries.IEntitiesSearchQuery, entityName, instance);
     }
+    resolveExistsQuery(entityName) {
+        return this.provider.resolveEntityService(EntityServices.Queries.IEntityExistsQuery, entityName);
+    }
+    registerExistsQuery(entityName, instance) {
+        this.provider.registerEntityService(EntityServices.Queries.IEntityExistsQuery, entityName, instance);
+    }
+    resolveCountQuery(entityName) {
+        return this.provider.resolveEntityService(EntityServices.Queries.IEntityCountQuery, entityName);
+    }
+    registerCountQuery(entityName, instance) {
+        this.provider.registerEntityService(EntityServices.Queries.IEntityCountQuery, entityName, instance);
+    }
     resolveCreateCommand(entityName) {
         return this.provider.resolveEntityService(EntityServices.Commands.IEntityCreateCommand, entityName);
     }
@@ -1082,6 +1210,12 @@ class EntitiesServiceLocator {
     registerUpsertCommand(entityName, instance) {
         this.provider.registerEntityService(EntityServices.Commands.IEntityUpsertCommand, entityName, instance);
     }
+    resolveDeleteItemsCommand(entityName) {
+        return this.provider.resolveEntityService(EntityServices.Commands.IEntitiesDeleteCommand, entityName);
+    }
+    registerDeleteItemsCommand(entityName, instance) {
+        this.provider.registerEntityService(EntityServices.Commands.IEntitiesDeleteCommand, entityName, instance);
+    }
     // resolveMergeCommand<TEntity>(
     //   entityName: string
     // ): IEntityMergeCommand<TEntity> {
@@ -1122,6 +1256,18 @@ class EntitiesServiceLocator {
     registerGetAction(entityName, instance) {
         this.provider.registerEntityService(EntityServices.Actions.IEntityGetAction, entityName, instance);
     }
+    resolveExistsAction(entityName) {
+        return this.provider.resolveEntityService(EntityServices.Actions.IEntityExistsAction, entityName);
+    }
+    registerExistsAction(entityName, instance) {
+        this.provider.registerEntityService(EntityServices.Actions.IEntityExistsAction, entityName, instance);
+    }
+    resolveCountAction(entityName) {
+        return this.provider.resolveEntityService(EntityServices.Actions.IEntitiesCountAction, entityName);
+    }
+    registerCountAction(entityName, instance) {
+        this.provider.registerEntityService(EntityServices.Actions.IEntitiesCountAction, entityName, instance);
+    }
     resolveSearchAction(entityName) {
         return this.provider.resolveEntityService(EntityServices.Actions.IEntitiesSearchAction, entityName);
     }
@@ -1152,6 +1298,12 @@ class EntitiesServiceLocator {
     registerDeleteAction(entityName, instance) {
         this.provider.registerEntityService(EntityServices.Actions.IEntityDeleteAction, entityName, instance);
     }
+    resolveDeleteItemsAction(entityName) {
+        return this.provider.resolveEntityService(EntityServices.Actions.IEntitiesDeleteAction, entityName);
+    }
+    registerDeleteItemsAction(entityName, instance) {
+        this.provider.registerEntityService(EntityServices.Actions.IEntitiesDeleteAction, entityName, instance);
+    }
     resolveQueryBuilder(entityName) {
         return this.provider.resolveEntityService(EntityServices.Queries.IEntitiesQueryBuilder, entityName);
     }
@@ -1160,12 +1312,74 @@ class EntitiesServiceLocator {
     }
 }
 
+class EntitiesCountQuery {
+    constructor(services) {
+        this.services = services;
+    }
+    async execute(filters) {
+        const context = await this.getContext();
+        await this.authorizeSearch(context);
+        return await this.services
+            .resolveQueryBuilder()
+            .count(filters, context);
+    }
+    async getContext() {
+        const authorization = this.services.resolveAuthorizationMiddleware();
+        if (!authorization) {
+            return undefined;
+        }
+        const contextService = this.services.resolveAuthenticationContextProvider();
+        return await contextService.getContext();
+    }
+    async authorizeSearch(context) {
+        const authorization = this.services.resolveAuthorizationMiddleware();
+        if (!authorization) {
+            return;
+        }
+        const { isAuthorized } = await authorization.canSearch(context);
+        if (!isAuthorized) {
+            throw new EntityOperationUnauthorizedException(EntityOperationType.Search, this.services.getEntityName());
+        }
+    }
+}
+
+class EntityExistsQuery {
+    constructor(services) {
+        this.services = services;
+    }
+    async execute(filters) {
+        const context = await this.getContext();
+        await this.authorizeSearch(context);
+        return await this.services
+            .resolveQueryBuilder()
+            .exists(filters, context);
+    }
+    async getContext() {
+        const authorization = this.services.resolveAuthorizationMiddleware();
+        if (!authorization) {
+            return undefined;
+        }
+        const contextService = this.services.resolveAuthenticationContextProvider();
+        return await contextService.getContext();
+    }
+    async authorizeSearch(context) {
+        const authorization = this.services.resolveAuthorizationMiddleware();
+        if (!authorization) {
+            return;
+        }
+        const { isAuthorized } = await authorization.canSearch(context);
+        if (!isAuthorized) {
+            throw new EntityOperationUnauthorizedException(EntityOperationType.Search, this.services.getEntityName());
+        }
+    }
+}
+
 class EntityGetQuery {
     constructor(services) {
         this.services = services;
     }
     async execute(id) {
-        var entity = await this.services.resolveRepository().get(id);
+        const entity = await this.services.resolveRepository().get(id);
         if (entity) {
             await this.authorize(entity);
         }
@@ -1188,7 +1402,6 @@ class EntitiesSearchQuery {
     constructor(services) {
         this.services = services;
     }
-    // @ts-ignore
     async execute(request) {
         const context = await this.getContext();
         await this.authorizeSearch(context);
@@ -1483,6 +1696,8 @@ class EntityManagerServiceCollection {
     }
     mapCrudOperations({ queryBuilder, }) {
         this.mapGet();
+        this.mapCount();
+        this.mapExists();
         this.mapSearch({
             queryBuilder,
         });
@@ -1496,6 +1711,16 @@ class EntityManagerServiceCollection {
         this.locator.registerGetAction(this.entityName, new EntityGetAction(this.resolver));
         return this;
     }
+    mapCount() {
+        this.locator.registerCountQuery(this.entityName, new EntitiesCountQuery(this.resolver));
+        this.locator.registerCountAction(this.entityName, new EntitiesCountAction(this.resolver));
+        return this;
+    }
+    mapExists() {
+        this.locator.registerExistsQuery(this.entityName, new EntityExistsQuery(this.resolver));
+        this.locator.registerExistsAction(this.entityName, new EntityExistsAction(this.resolver));
+        return this;
+    }
     mapSearch({ queryBuilder, }) {
         this.locator.registerSearchQuery(this.entityName, new EntitiesSearchQuery(this.resolver));
         this.locator.registerSearchAction(this.entityName, new EntitiesSearchAction(this.resolver));
@@ -1525,6 +1750,8 @@ class EntityManagerServiceCollection {
     mapDelete() {
         this.locator.registerDeleteCommand(this.entityName, new EntityDeleteCommand(this.resolver));
         this.locator.registerDeleteAction(this.entityName, new EntityDeleteAction(this.resolver));
+        this.locator.registerDeleteItemsCommand(this.entityName, new EntitiesDeleteCommand(this.resolver));
+        this.locator.registerDeleteAction(this.entityName, new EntitiesDeleteAction(this.resolver));
         return this;
     }
     addAdapter(adapter) {
@@ -19771,6 +19998,209 @@ const orderByPriority = (items, priorityFieldSelector, nameFieldSelector) => {
     return sort(items, byField((x) => priorityFieldSelector(x) ?? Number.MAX_VALUE), byField((x) => nameFieldSelector(x)));
 };
 
+var PipelineStatus;
+(function (PipelineStatus) {
+    PipelineStatus["Initializing"] = "initializing";
+    PipelineStatus["Running"] = "running";
+    PipelineStatus["RollbackInProgress"] = "rollbackInProgress";
+    PipelineStatus["Completed"] = "completed";
+    PipelineStatus["Failed"] = "failed";
+})(PipelineStatus || (PipelineStatus = {}));
+
+const toPipelineOperationError = (error) => ({
+    message: error.message,
+    exception: error,
+});
+const getStepOutput = (result) => {
+    return result.type === "success" ? result.output : undefined;
+};
+const getOperationOutput = (result) => {
+    return result.type === "success" ? result.output : undefined;
+};
+
+class PipelineInstance {
+    constructor(definition, input, context) {
+        this.definition = definition;
+        this.input = input;
+        this.context = context;
+        this.status = PipelineStatus.Initializing;
+    }
+    async execute() {
+        this.status = PipelineStatus.Running;
+        const executedSteps = [];
+        const stepResults = [];
+        let state = this.buildInitialStepState();
+        for (const [i, step] of this.definition.steps.entries()) {
+            executedSteps.push(step);
+            const stepResult = await this.executeStep(step, i > 0 ? getStepOutput(stepResults[i - 1]) : this.input, state);
+            stepResults.push(stepResult);
+            state = this.buildNextStepState(state, stepResult);
+            if (stepResult.type !== "success") {
+                this.status = PipelineStatus.RollbackInProgress;
+                await this.rollbackSteps(executedSteps, stepResults, state);
+                return {
+                    type: "error",
+                    input: this.input,
+                    stepResults,
+                };
+            }
+        }
+        this.status = PipelineStatus.Completed;
+        return {
+            type: "success",
+            input: this.input,
+            output: getStepOutput(stepResults[stepResults.length - 1]),
+            stepResults,
+        };
+    }
+    buildInitialStepState() {
+        return {
+            stepInput: this.input,
+            context: this.context,
+            pipelineInput: this.input,
+        };
+    }
+    buildNextStepState(state, stepResult) {
+        return {
+            stepInput: getStepOutput(stepResult),
+            context: this.context,
+            pipelineInput: this.input,
+            previousStep: {
+                stepInput: state.stepInput,
+                stepOutput: getStepOutput(stepResult),
+                context: this.context,
+                pipelineInput: this.input,
+                previousStep: state.previousStep,
+            },
+        };
+    }
+    async rollbackSteps(executedSteps, stepsResults, state) {
+        const rollbackSteps = executedSteps
+            .map((x, i) => ({
+            step: x,
+            result: stepsResults[i],
+        }))
+            .reverse();
+        let rollbackState = state;
+        for (const step of rollbackSteps) {
+            await this.rollbackStep(step.step, step.result, rollbackState);
+            rollbackState = state.previousStep;
+        }
+    }
+    async rollbackStep(step, stepResults, state) {
+        const completedOperations = stepResults.operationResults.map((x, i) => ({
+            result: x,
+            operation: step.operations[i],
+        }));
+        // .filter((x) => x.result.type === "success")
+        const rollbackOperations = completedOperations.map((x) => this.rollbackOperations(x.operation, x.result.input, getOperationOutput(x.result), state));
+        const rollbackResults = await Promise.all(rollbackOperations);
+        const isRollbackError = rollbackResults.some((x) => x.type === "error");
+        if (isRollbackError) {
+            return {
+                type: "error",
+            };
+        }
+        return {
+            type: "success",
+        };
+    }
+    async validateStepPrecondition(step, input, state) {
+        const preconditionOperations = step.operations
+            .filter((x) => x.operation.precondition)
+            .map((x) => x.operation.precondition(input, state));
+        const preconditionResults = await Promise.all(preconditionOperations);
+        return {
+            hasValidPrecondition: preconditionResults.every((x) => x),
+        };
+    }
+    async executeStep(step, input, state) {
+        const preconditionResult = await this.validateStepPrecondition(step, input, state);
+        if (!preconditionResult.hasValidPrecondition) {
+            return {
+                operationResults: [],
+                type: "preconditionFailed",
+                input,
+            };
+        }
+        const stepOperations = step.operations.map((x) => this.executeOperation(x, input, state));
+        const operationResults = await Promise.all(stepOperations);
+        const isSuccess = operationResults.every((x) => x.type === "success");
+        if (isSuccess) {
+            const output = step.outputsReducer
+                ? step.outputsReducer(operationResults.map((x) => getOperationOutput(x)))
+                : operationResults.map((x) => getOperationOutput(x));
+            return {
+                type: "success",
+                operationResults,
+                input,
+                output: output,
+            };
+        }
+        return {
+            type: "error",
+            operationResults,
+            input,
+        };
+    }
+    async executeOperation(operation, input, state) {
+        try {
+            const operationResult = await operation.operation.action(input, state);
+            return {
+                type: "success",
+                input,
+                output: operationResult,
+            };
+        }
+        catch (error) {
+            return {
+                type: "error",
+                input,
+                error: toPipelineOperationError(error),
+            };
+        }
+    }
+    async rollbackOperations(operation, operationInput, operationOutput, state) {
+        if (!operation.rollbackOperations?.length) {
+            return {
+                type: "skipped",
+            };
+        }
+        for (const rollbackOperation of operation.rollbackOperations) {
+            const rollbackResult = await this.rollbackOperation(rollbackOperation, operationInput, operationOutput, state);
+            if (rollbackResult.type === "error") {
+                return {
+                    type: "error",
+                    error: rollbackResult.error,
+                };
+            }
+        }
+        return {
+            type: "success",
+        };
+    }
+    async rollbackOperation(rollbackOperation, operationInput, operationOutput, state) {
+        try {
+            await rollbackOperation.action(operationInput, operationOutput, state);
+            return {
+                type: "success",
+            };
+        }
+        catch (error) {
+            return {
+                type: "error",
+                error: toPipelineOperationError(error),
+            };
+        }
+    }
+}
+
+class PipelineController {
+    async createInstance(definition, input, context) {
+        return new PipelineInstance(definition, input, context);
+    }
+}
+
 var EntityManagerInitializer_1;
 let EntityManagerInitializer = EntityManagerInitializer_1 = class EntityManagerInitializer {
     constructor(discover, registry, eventEmitter) {
@@ -19792,6 +20222,7 @@ let EntityManagerInitializer = EntityManagerInitializer_1 = class EntityManagerI
             await this.registerAuthentication(staticProviders.authenticationProvider);
             this.logger.log("Entity manager authentication initialized 🔑");
         }
+        await this.registerPipelinesServices();
         await this.registerEmailTemplates();
         await this.registerEmailProviders();
         await this.registerEventTrackingProviders();
@@ -19896,6 +20327,12 @@ let EntityManagerInitializer = EntityManagerInitializer_1 = class EntityManagerI
             .getEntitiesServicesLocator()
             .registerEmailTemplatesCollection(collection);
     }
+    async registerPipelinesServices() {
+        this.registry
+            .getContainer()
+            .getEntitiesServicesLocator()
+            .registerPipelinesController(new PipelineController());
+    }
     async initializeProviders(app, staticProviders) {
         app
             .get(ModulesContainerProvider)
@@ -19943,12 +20380,127 @@ const Processors = [EntityManagerInitializer];
 
 const Providers = [NestEventEmitter];
 
+class PipelineStepOperationOptionsBuilder {
+    constructor(operation) {
+        this.operation = operation;
+        this.rollbackOperations = [];
+    }
+    withRollback(definition) {
+        this.rollbackOperations.push(definition);
+        return this;
+    }
+    build() {
+        return {
+            name: this.operation.name,
+            operation: this.operation,
+            rollbackOperations: this.rollbackOperations,
+        };
+    }
+}
+class PipelineStepOperationsBuilder {
+    constructor() {
+        this.operationBuilders = [];
+    }
+    addOperation(operation) {
+        const operationBuilder = new PipelineStepOperationOptionsBuilder(operation);
+        this.operationBuilders.push(operationBuilder);
+        return operationBuilder;
+    }
+    buildOperations() {
+        return this.operationBuilders.map((builder) => builder.build());
+    }
+}
+class PipelineStepBuilder {
+    constructor(previousSteps, currentStepOperationsBuilder) {
+        this.previousSteps = previousSteps;
+        this.currentStep = this.buildCurrentStep(currentStepOperationsBuilder);
+    }
+    addStep(builder) {
+        return new PipelineStepBuilder(this.currentSteps, builder);
+    }
+    buildCurrentStep(currentStepOperationsBuilder) {
+        const operationsBuilder = new PipelineStepOperationsBuilder();
+        currentStepOperationsBuilder(operationsBuilder);
+        return {
+            name: `Step ${this.previousSteps.length + 1}`,
+            operations: operationsBuilder.buildOperations(),
+            // TODO: add support for multiple operation outputs
+            outputsReducer: (outputs) => {
+                if (outputs.length === 0) {
+                    throw new Error("Empty pipeline step found");
+                }
+                if (outputs.length !== 1) {
+                    throw new Error("Multiple outputs are not supported yet");
+                }
+                return outputs[0];
+            },
+        };
+    }
+    build() {
+        return {
+            steps: this.currentSteps,
+        };
+    }
+    get currentSteps() {
+        return [
+            ...this.previousSteps,
+            this.currentStep,
+        ];
+    }
+}
+class PipelineTemplateBuilder {
+    addStep(builder) {
+        return new PipelineStepBuilder([], builder);
+    }
+}
+
+let PipelinesBuilder = class PipelinesBuilder {
+    constructor(registry) {
+        this.registry = registry;
+    }
+    createTemplate() {
+        return new PipelineTemplateBuilder();
+    }
+};
+PipelinesBuilder = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [EntityManagerRegistry])
+], PipelinesBuilder);
+
+let PipelinesRunner = class PipelinesRunner {
+    constructor(registry) {
+        this.registry = registry;
+    }
+    async invokePipeline(definition, data) {
+        const instance = await this.controller.createInstance(definition, data.input, data.context);
+        return await instance.execute();
+    }
+    get controller() {
+        return this.registry
+            .getContainer()
+            .getEntitiesServicesLocator()
+            .resolvePipelinesController();
+    }
+};
+PipelinesRunner = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [EntityManagerRegistry])
+], PipelinesRunner);
+
+const PipelineProviders = [PipelinesBuilder, PipelinesRunner];
+
 let EntityManagerModule = class EntityManagerModule {
 };
 EntityManagerModule = __decorate([
     Module({
         imports: [CustomDiscoveryModule, EventEmitterModule],
-        providers: [...IoC, ...Providers, ...Processors, ...Services$1],
+        providers: [
+            ...IoC,
+            ...Providers,
+            ...Processors,
+            ...Services$1,
+            ...PipelineProviders,
+        ],
         exports: [EntityManagerRegistry, ...Services$1],
     })
 ], EntityManagerModule);
@@ -20195,6 +20747,24 @@ class TypeOrmQueryBuilder extends QueryBuilderBase {
         super();
         this.services = services;
     }
+    async exists(filters, context) {
+        return (await this.count(filters, context)) > 0;
+    }
+    async count(filters, context) {
+        const request = {
+            filters,
+        };
+        return await this.countQueryResults(request, context);
+    }
+    async delete(filters, context) {
+        const request = {
+            filters,
+        };
+        return await this.getRepository().deleteBy({
+            ...(context ? this.buildContextFilter(context) : {}),
+            ...this.buildWhereClause(request),
+        });
+    }
     async search(request, context) {
         // todo: execute inside read transaction in order to perform the three queries on the same dataset
         const queryResults = await this.countQueryResults(request, context);
@@ -20312,7 +20882,10 @@ class TypeOrmRepository {
         });
     }
     async deleteBy(condition) {
-        await this.innerRepository.delete(condition);
+        const result = await this.innerRepository.delete(condition);
+        return {
+            deletedCount: result.affected,
+        };
     }
     async create(entity) {
         const createResult = await this.innerRepository.insert(entity);
@@ -20395,19 +20968,18 @@ class NestTypeOrmEntitySeeder extends TypeOrmEntitySeeder {
 
 class AppExceptionsFilterBase {
     catch(exception, host) {
-        if (exception instanceof HttpException) {
-            return;
-        }
         const ctx = host.switchToHttp();
         const response = ctx.getResponse();
         const request = ctx.getRequest();
-        this.logError({
-            exception,
-            request,
-            response,
-        }).catch((error) => {
-            Log.getLogger("AllExceptionsFilter").error("Error logging failed", error);
-        });
+        if (!(exception instanceof HttpException)) {
+            this.logError({
+                exception,
+                request,
+                response,
+            }).catch((error) => {
+                Log.getLogger("AllExceptionsFilter").error("Error logging failed", error);
+            });
+        }
         const status = this.getErrorStatusCode(exception);
         response.status(status).json({
             statusCode: status,
@@ -25647,5 +26219,5 @@ SendgridEmailModule = SendgridEmailModule_1 = __decorate([
     })
 ], SendgridEmailModule);
 
-export { AUTHENTICATION_EVENTS_NAMESPACE, AppExceptionsFilterBase, AppHashingService, AppInMemorySettings, AppSessionMiddleware, AppSessionService, AuthGuard, Authenticated, AuthenticationEmailTemplates, AuthenticationError, AuthenticationEvents, AuthenticationExtensionSymbols, AuthenticationModule, AuthenticationService, AwsEmailModule, AwsSesEmailTemplate, BooleanFacet, BooleanFacetItem, EmailService, EntityManagerConfigurationError, EntityManagerException, EntityManagerInitializer, EntityManagerModule, EntityManagerRegistry, EntityManagerService, EntityManagerSymbols, EntityManagerUnauthorizedException, EntityNotFoundException, EntityOperationType, EntityOperationUnauthorizedException, EntitySeeder, EventsService, InvalidCredentialsError, MemberOf, ModulesContainerProvider, MultiTenancyModule, MultipleEntitiesFoundException, NestEntityActions, NestEntityAuthorizationMiddleware, NestEntityManager, NestTypeOrmEntitySeeder, NestTypeOrmQueryBuilder, NestTypeOrmRepository, NumericFacet, NumericFacetItem, OperationTokenMismatchError, PLATFORM_EVENT_NAMESPACE, PlatformEvents, Public, QueryBuilderBase, ReplicationMode, Roles, SendgridEmailModule, SendgridEmailTemplate, SortDirection, StringFacet, StringFacetItem, TrackingService, UserRegistrationError, WpAppInitializer, WpAwsSesEmailTemplate, WpEmailTemplate, WpEntity, WpEntityActions, WpEntityAdapter, WpEntityAuthMiddleware, WpEntityConnector, WpEntityConverter, WpEntityManager, WpEntityQueryBuilder, WpEntityRepository, WpEntitySeeder, WpEventsTracker, WpRolesService, WpSendgridEmailTemplate, WpUserRolesService, WpUserService, getLocalizedText, newUuid, renderHandlebarsTemplate };
+export { AUTHENTICATION_EVENTS_NAMESPACE, AppExceptionsFilterBase, AppHashingService, AppInMemorySettings, AppSessionMiddleware, AppSessionService, AuthGuard, Authenticated, AuthenticationEmailTemplates, AuthenticationError, AuthenticationEvents, AuthenticationExtensionSymbols, AuthenticationModule, AuthenticationService, AwsEmailModule, AwsSesEmailTemplate, BooleanFacet, BooleanFacetItem, EmailService, EntityManagerConfigurationError, EntityManagerException, EntityManagerInitializer, EntityManagerModule, EntityManagerRegistry, EntityManagerService, EntityManagerSymbols, EntityManagerUnauthorizedException, EntityNotFoundException, EntityOperationType, EntityOperationUnauthorizedException, EntitySeeder, EventsService, InvalidCredentialsError, MemberOf, ModulesContainerProvider, MultiTenancyModule, MultipleEntitiesFoundException, NestEntityActions, NestEntityAuthorizationMiddleware, NestEntityManager, NestTypeOrmEntitySeeder, NestTypeOrmQueryBuilder, NestTypeOrmRepository, NumericFacet, NumericFacetItem, OperationTokenMismatchError, PLATFORM_EVENT_NAMESPACE, PipelineController, PipelineStatus, PipelinesBuilder, PipelinesRunner, PlatformEvents, Public, QueryBuilderBase, ReplicationMode, Roles, SendgridEmailModule, SendgridEmailTemplate, SortDirection, StringFacet, StringFacetItem, TrackingService, UserRegistrationError, WpAppInitializer, WpAwsSesEmailTemplate, WpEmailTemplate, WpEntity, WpEntityActions, WpEntityAdapter, WpEntityAuthMiddleware, WpEntityConnector, WpEntityConverter, WpEntityManager, WpEntityQueryBuilder, WpEntityRepository, WpEntitySeeder, WpEventsTracker, WpPipeline, WpRolesService, WpSendgridEmailTemplate, WpUserRolesService, WpUserService, getLocalizedText, newUuid, renderHandlebarsTemplate };
 //# sourceMappingURL=index.js.map