@punks/backend-entity-manager 0.0.70 → 0.0.72

package/dist/cjs/index.js

@@ -122,12 +122,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;
     }
 }
@@ -137,7 +136,7 @@ class NestEntityManager {
     constructor(entityName, registry) {
         this.services = registry.resolveEntityServicesCollection(entityName);
     }
-    get provider() {
+    get manager() {
         if (!this.managerInstance) {
             this.managerInstance =
                 this.services.resolveEntityManager();
@@ -161,6 +160,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 = {}) => common.applyDecorators(common.Injectable(), common.SetMetadata(EntityManagerSymbols.EntityAuthMiddleware, {
@@ -217,6 +217,11 @@ const WpEntityQueryBuilder = (entityName, props = {}) => common.applyDecorators(
     ...props,
 }));
 
+const WpPipeline = (name, props = {}) => common.applyDecorators(common.Injectable(), common.SetMetadata(EntityManagerSymbols.PipelineTemplate, {
+    name,
+    ...props,
+}));
+
 const WpEntitySeeder = (entityName, props = {}) => common.applyDecorators(common.Injectable(), common.SetMetadata(EntityManagerSymbols.EntitySeeder, {
     entityName,
     ...props,
@@ -467,6 +472,15 @@ exports.AppHashingService = __decorate([
     common.Injectable()
 ], exports.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;
@@ -494,6 +508,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;
@@ -611,6 +643,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(exports.EntityOperationType.Delete, this.services.getEntityName());
+    }
+}
+
 class EntityUpdateCommand {
     constructor(services) {
         this.services = services;
@@ -695,23 +761,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();
     }
 }
@@ -719,22 +793,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();
     }
 }
@@ -780,6 +863,9 @@ class ServiceLocator {
 const EntityServices = {
     Actions: {
         IEntityGetAction: "IEntityGetAction",
+        IEntityExistsAction: "IEntityExistsAction",
+        IEntitiesCountAction: "IEntitiesCountAction",
+        IEntitiesDeleteAction: "IEntitiesDeleteAction",
         IEntitiesSearchAction: "IEntitiesSearchAction",
         IEntityCreateAction: "IEntityCreateAction",
         IEntityUpdateAction: "IEntityUpdateAction",
@@ -796,6 +882,7 @@ const EntityServices = {
         IEntityUpsertCommand: "IEntityUpsertCommand",
         IEntityMergeCommand: "IEntityMergeCommand",
         IEntityDeleteCommand: "IEntityDeleteCommand",
+        IEntitiesDeleteCommand: "IEntitiesDeleteCommand",
     },
     Converters: {
         IEntityAdapter: "IEntityAdapter",
@@ -810,6 +897,8 @@ const EntityServices = {
         IEntityEventsManager: "IEntityEventsManager",
     },
     Queries: {
+        IEntityCountQuery: "IEntityCountQuery",
+        IEntityExistsQuery: "IEntityExistsQuery",
         IEntityGetQuery: "IEntityGetQuery",
         IEntitiesSearchQuery: "IEntitiesSearchQuery",
         IEntitiesQueryBuilder: "IEntitiesQueryBuilder",
@@ -839,6 +928,9 @@ const GlobalServices = {
         IEmailProvider: "IEmailProvider",
         IEmailTemplatesCollection: "IEmailTemplatesCollection",
     },
+    Pipelines: {
+        IPipelineController: "IPipelineController",
+    },
 };
 
 class EntityServiceLocator {
@@ -894,6 +986,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);
     }
@@ -912,9 +1010,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);
     }
@@ -930,6 +1037,9 @@ class EntityServiceLocator {
     resolveDeleteAction() {
         return this.services.resolveDeleteAction(this.entityName);
     }
+    resolveDeleteItemsAction() {
+        return this.services.resolveDeleteItemsAction(this.entityName);
+    }
     resolveQueryBuilder() {
         return this.services.resolveQueryBuilder(this.entityName);
     }
@@ -970,6 +1080,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);
     }
@@ -1072,6 +1188,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);
     }
@@ -1090,6 +1218,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> {
@@ -1130,6 +1264,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);
     }
@@ -1160,6 +1306,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);
     }
@@ -1168,12 +1320,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(exports.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(exports.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);
         }
@@ -1196,7 +1410,6 @@ class EntitiesSearchQuery {
     constructor(services) {
         this.services = services;
     }
-    // @ts-ignore
     async execute(request) {
         const context = await this.getContext();
         await this.authorizeSearch(context);
@@ -1491,6 +1704,8 @@ class EntityManagerServiceCollection {
     }
     mapCrudOperations({ queryBuilder, }) {
         this.mapGet();
+        this.mapCount();
+        this.mapExists();
         this.mapSearch({
             queryBuilder,
         });
@@ -1504,6 +1719,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));
@@ -1533,6 +1758,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) {
@@ -19779,6 +20006,209 @@ const orderByPriority = (items, priorityFieldSelector, nameFieldSelector) => {
     return backendCore.sort(items, backendCore.byField((x) => priorityFieldSelector(x) ?? Number.MAX_VALUE), backendCore.byField((x) => nameFieldSelector(x)));
 };
 
+exports.PipelineStatus = void 0;
+(function (PipelineStatus) {
+    PipelineStatus["Initializing"] = "initializing";
+    PipelineStatus["Running"] = "running";
+    PipelineStatus["RollbackInProgress"] = "rollbackInProgress";
+    PipelineStatus["Completed"] = "completed";
+    PipelineStatus["Failed"] = "failed";
+})(exports.PipelineStatus || (exports.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 = exports.PipelineStatus.Initializing;
+    }
+    async execute() {
+        this.status = exports.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 = exports.PipelineStatus.RollbackInProgress;
+                await this.rollbackSteps(executedSteps, stepResults, state);
+                return {
+                    type: "error",
+                    input: this.input,
+                    stepResults,
+                };
+            }
+        }
+        this.status = exports.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;
 exports.EntityManagerInitializer = EntityManagerInitializer_1 = class EntityManagerInitializer {
     constructor(discover, registry, eventEmitter) {
@@ -19800,6 +20230,7 @@ exports.EntityManagerInitializer = EntityManagerInitializer_1 = class EntityMana
             await this.registerAuthentication(staticProviders.authenticationProvider);
             this.logger.log("Entity manager authentication initialized 🔑");
         }
+        await this.registerPipelinesServices();
         await this.registerEmailTemplates();
         await this.registerEmailProviders();
         await this.registerEventTrackingProviders();
@@ -19904,6 +20335,12 @@ exports.EntityManagerInitializer = EntityManagerInitializer_1 = class EntityMana
             .getEntitiesServicesLocator()
             .registerEmailTemplatesCollection(collection);
     }
+    async registerPipelinesServices() {
+        this.registry
+            .getContainer()
+            .getEntitiesServicesLocator()
+            .registerPipelinesController(new PipelineController());
+    }
     async initializeProviders(app, staticProviders) {
         app
             .get(exports.ModulesContainerProvider)
@@ -19951,12 +20388,127 @@ const Processors = [exports.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);
+    }
+}
+
+exports.PipelinesBuilder = class PipelinesBuilder {
+    constructor(registry) {
+        this.registry = registry;
+    }
+    createTemplate() {
+        return new PipelineTemplateBuilder();
+    }
+};
+exports.PipelinesBuilder = __decorate([
+    common.Injectable(),
+    __metadata("design:paramtypes", [exports.EntityManagerRegistry])
+], exports.PipelinesBuilder);
+
+exports.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();
+    }
+};
+exports.PipelinesRunner = __decorate([
+    common.Injectable(),
+    __metadata("design:paramtypes", [exports.EntityManagerRegistry])
+], exports.PipelinesRunner);
+
+const PipelineProviders = [exports.PipelinesBuilder, exports.PipelinesRunner];
+
 exports.EntityManagerModule = class EntityManagerModule {
 };
 exports.EntityManagerModule = __decorate([
     common.Module({
         imports: [CustomDiscoveryModule, eventEmitter.EventEmitterModule],
-        providers: [...IoC, ...Providers, ...Processors, ...Services$1],
+        providers: [
+            ...IoC,
+            ...Providers,
+            ...Processors,
+            ...Services$1,
+            ...PipelineProviders,
+        ],
         exports: [exports.EntityManagerRegistry, ...Services$1],
     })
 ], exports.EntityManagerModule);
@@ -20203,6 +20755,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);
@@ -20320,7 +20890,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);
@@ -20403,19 +20976,18 @@ class NestTypeOrmEntitySeeder extends TypeOrmEntitySeeder {
 
 class AppExceptionsFilterBase {
     catch(exception, host) {
-        if (exception instanceof common.HttpException) {
-            return;
-        }
         const ctx = host.switchToHttp();
         const response = ctx.getResponse();
         const request = ctx.getRequest();
-        this.logError({
-            exception,
-            request,
-            response,
-        }).catch((error) => {
-            backendCore.Log.getLogger("AllExceptionsFilter").error("Error logging failed", error);
-        });
+        if (!(exception instanceof common.HttpException)) {
+            this.logError({
+                exception,
+                request,
+                response,
+            }).catch((error) => {
+                backendCore.Log.getLogger("AllExceptionsFilter").error("Error logging failed", error);
+            });
+        }
         const status = this.getErrorStatusCode(exception);
         response.status(status).json({
             statusCode: status,
@@ -25686,6 +26258,7 @@ exports.NumericFacet = NumericFacet;
 exports.NumericFacetItem = NumericFacetItem;
 exports.OperationTokenMismatchError = OperationTokenMismatchError;
 exports.PLATFORM_EVENT_NAMESPACE = PLATFORM_EVENT_NAMESPACE;
+exports.PipelineController = PipelineController;
 exports.PlatformEvents = PlatformEvents;
 exports.Public = Public;
 exports.QueryBuilderBase = QueryBuilderBase;
@@ -25707,6 +26280,7 @@ exports.WpEntityQueryBuilder = WpEntityQueryBuilder;
 exports.WpEntityRepository = WpEntityRepository;
 exports.WpEntitySeeder = WpEntitySeeder;
 exports.WpEventsTracker = WpEventsTracker;
+exports.WpPipeline = WpPipeline;
 exports.WpRolesService = WpRolesService;
 exports.WpSendgridEmailTemplate = WpSendgridEmailTemplate;
 exports.WpUserRolesService = WpUserRolesService;