@punks/backend-entity-manager 0.0.71 → 0.0.73

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,
@@ -420,7 +425,12 @@ AuthGuard = __decorate([
     __metadata("design:paramtypes", [Reflector])
 ], AuthGuard);
 
-const asyncLocalStorage = new AsyncLocalStorage();
+var UserCreationError;
+(function (UserCreationError) {
+    UserCreationError["UserAlreadyExists"] = "userAlreadyExists";
+})(UserCreationError || (UserCreationError = {}));
+
+const sessionStorage = new AsyncLocalStorage();
 
 let AppSessionService = class AppSessionService {
     getValue(key) {
@@ -436,7 +446,7 @@ let AppSessionService = class AppSessionService {
         return this.getSession().request;
     }
     getSession() {
-        const store = asyncLocalStorage.getStore();
+        const store = sessionStorage.getStore();
         if (!store) {
             throw new Error("No active context found");
         }
@@ -459,6 +469,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 +505,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;
@@ -570,7 +607,10 @@ class EntityCreateCommand {
             return;
         }
         const contextService = this.services.resolveAuthenticationContextProvider();
-        const context = await contextService.getContext();
+        const context = await contextService?.getContext();
+        if (!context) {
+            return;
+        }
         const authorizationResult = await authorization.canCreate(entity, context);
         if (!authorizationResult.isAuthorized)
             throw new EntityOperationUnauthorizedException(EntityOperationType.Create, this.services.getEntityName(), entity);
@@ -596,13 +636,53 @@ class EntityDeleteCommand {
             throw new EntityNotFoundException(id);
         }
         const contextService = this.services.resolveAuthenticationContextProvider();
-        const context = await contextService.getContext();
+        const context = await contextService?.getContext();
+        if (!context) {
+            return;
+        }
         const authorizationResult = await authorization.canDelete(entity, context);
         if (!authorizationResult.isAuthorized)
             throw new EntityOperationUnauthorizedException(EntityOperationType.Delete, this.services.getEntityName(), entity);
     }
 }
 
+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();
+        if (!context) {
+            return;
+        }
+        const authorizationResult = await authorization.canDeleteItems(context);
+        if (!authorizationResult.isAuthorized)
+            throw new EntityOperationUnauthorizedException(EntityOperationType.Delete, this.services.getEntityName());
+    }
+}
+
 class EntityUpdateCommand {
     constructor(services) {
         this.services = services;
@@ -634,7 +714,10 @@ class EntityUpdateCommand {
             throw new EntityNotFoundException();
         }
         const contextService = this.services.resolveAuthenticationContextProvider();
-        const context = await contextService.getContext();
+        const context = await contextService?.getContext();
+        if (!context) {
+            return;
+        }
         const authorizationResult = await authorization.canUpdate(currentEntity, context);
         if (!authorizationResult.isAuthorized)
             throw new EntityOperationUnauthorizedException(EntityOperationType.Create, this.services.getEntityName(), currentEntity);
@@ -670,7 +753,10 @@ class EntityUpsertCommand {
         }
         const currentEntity = await this.services.resolveRepository().get(id);
         const contextService = this.services.resolveAuthenticationContextProvider();
-        const context = await contextService.getContext();
+        const context = await contextService?.getContext();
+        if (!context) {
+            return;
+        }
         if (currentEntity) {
             const updateResult = await authorization.canUpdate(currentEntity, context);
             if (!updateResult.isAuthorized)
@@ -687,23 +773,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 +805,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 +875,9 @@ class ServiceLocator {
 const EntityServices = {
     Actions: {
         IEntityGetAction: "IEntityGetAction",
+        IEntityExistsAction: "IEntityExistsAction",
+        IEntitiesCountAction: "IEntitiesCountAction",
+        IEntitiesDeleteAction: "IEntitiesDeleteAction",
         IEntitiesSearchAction: "IEntitiesSearchAction",
         IEntityCreateAction: "IEntityCreateAction",
         IEntityUpdateAction: "IEntityUpdateAction",
@@ -788,6 +894,7 @@ const EntityServices = {
         IEntityUpsertCommand: "IEntityUpsertCommand",
         IEntityMergeCommand: "IEntityMergeCommand",
         IEntityDeleteCommand: "IEntityDeleteCommand",
+        IEntitiesDeleteCommand: "IEntitiesDeleteCommand",
     },
     Converters: {
         IEntityAdapter: "IEntityAdapter",
@@ -802,6 +909,8 @@ const EntityServices = {
         IEntityEventsManager: "IEntityEventsManager",
     },
     Queries: {
+        IEntityCountQuery: "IEntityCountQuery",
+        IEntityExistsQuery: "IEntityExistsQuery",
         IEntityGetQuery: "IEntityGetQuery",
         IEntitiesSearchQuery: "IEntitiesSearchQuery",
         IEntitiesQueryBuilder: "IEntitiesQueryBuilder",
@@ -831,6 +940,9 @@ const GlobalServices = {
         IEmailProvider: "IEmailProvider",
         IEmailTemplatesCollection: "IEmailTemplatesCollection",
     },
+    Pipelines: {
+        IPipelineController: "IPipelineController",
+    },
 };
 
 class EntityServiceLocator {
@@ -886,6 +998,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 +1022,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 +1049,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,8 +1092,16 @@ 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);
+        return this.provider.resolve(GlobalServices.Authentication.IAuthenticationContextProvider, {
+            optional: true,
+        });
     }
     registerAuthenticationContextProvider(instance) {
         this.provider.register(GlobalServices.Authentication.IAuthenticationContextProvider, instance);
@@ -1064,6 +1202,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 +1232,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 +1278,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 +1320,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 +1334,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);
         }
@@ -1177,7 +1413,10 @@ class EntityGetQuery {
             return;
         }
         const contextService = this.services.resolveAuthenticationContextProvider();
-        const context = await contextService.getContext();
+        const context = await contextService?.getContext();
+        if (!context) {
+            return;
+        }
         const authorizationResult = await authorization.canRead(entity, context);
         if (!authorizationResult.isAuthorized)
             throw new EntityOperationUnauthorizedException(EntityOperationType.Read, this.services.getEntityName(), entity);
@@ -1188,7 +1427,6 @@ class EntitiesSearchQuery {
     constructor(services) {
         this.services = services;
     }
-    // @ts-ignore
     async execute(request) {
         const context = await this.getContext();
         await this.authorizeSearch(context);
@@ -1213,7 +1451,7 @@ class EntitiesSearchQuery {
             return undefined;
         }
         const contextService = this.services.resolveAuthenticationContextProvider();
-        return await contextService.getContext();
+        return await contextService?.getContext();
     }
     async filterAllowedEntities(entities, context) {
         const authorization = this.services.resolveAuthorizationMiddleware();
@@ -1483,6 +1721,8 @@ class EntityManagerServiceCollection {
     }
     mapCrudOperations({ queryBuilder, }) {
         this.mapGet();
+        this.mapCount();
+        this.mapExists();
         this.mapSearch({
             queryBuilder,
         });
@@ -1496,6 +1736,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 +1775,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) {
@@ -19278,7 +19530,7 @@ let UserRegistrationHandler = class UserRegistrationHandler {
                 userId: user.id,
             };
         }
-        const newUser = await this.createUser(input.email, input.registrationInfo, input.context);
+        const newUser = await this.createUser(input.email, input.userName, input.registrationInfo, input.context);
         const passwordHash = await this.createPasswordHash(input.password, newUser.id);
         await this.services.getUsersService().update(newUser.id, {
             passwordHash,
@@ -19319,8 +19571,10 @@ let UserRegistrationHandler = class UserRegistrationHandler {
             timestamp: Date.now(),
         });
     }
-    async createUser(email, info, context) {
-        return await this.services.getUsersService().create(email, info, context);
+    async createUser(email, userName, info, context) {
+        return await this.services
+            .getUsersService()
+            .create(email, userName, info, context);
     }
     async resolveUser(userName, context) {
         return ((await this.services
@@ -19654,9 +19908,92 @@ UserVerifyRequestHandler = __decorate([
         JwtProvider])
 ], UserVerifyRequestHandler);
 
+let UserCreationHandler = class UserCreationHandler {
+    constructor(services, passwordHashingProvider) {
+        this.services = services;
+        this.passwordHashingProvider = passwordHashingProvider;
+        this.logger = Log.getLogger("UserCreation");
+    }
+    async execute(input) {
+        const user = (await this.resolveUser(input.email, input.context)) ??
+            (await this.resolveUser(input.userName, input.context));
+        if (user && user.verified) {
+            this.logger.debug(`User already exists: ${input.email} - ${input.userName}`, { user });
+            return {
+                success: false,
+                error: UserCreationError.UserAlreadyExists,
+            };
+        }
+        if (user && !user.verified) {
+            const passwordHash = await this.createPasswordHash(input.password, user.id);
+            await this.services.getUsersService().update(user.id, {
+                passwordHash,
+                passwordUpdateTimestamp: new Date(),
+                verified: true,
+            });
+            this.logger.debug(`User already exists but not verified. Updating password and marking as verified: ${input.email} - ${input.userName}`, { user });
+            return {
+                success: true,
+                userId: user.id,
+            };
+        }
+        const newUser = await this.createUser(input.email, input.userName, input.registrationInfo, input.context);
+        const passwordHash = await this.createPasswordHash(input.password, newUser.id);
+        await this.services.getUsersService().update(newUser.id, {
+            passwordHash,
+            passwordUpdateTimestamp: new Date(),
+            verified: true,
+        });
+        this.logger.debug(`New user created: ${input.email} - ${input.userName}`, {
+            user: newUser,
+        });
+        return {
+            success: true,
+            userId: newUser.id,
+        };
+    }
+    async createPasswordHash(password, userId) {
+        return await this.passwordHashingProvider.hashPassword({
+            password,
+            userId,
+        });
+    }
+    async createUser(email, userName, info, context) {
+        return await this.services
+            .getUsersService()
+            .create(email, userName, info, context);
+    }
+    async resolveUser(userName, context) {
+        return ((await this.services
+            .getUsersService()
+            .getByUserName(userName, context)) ??
+            (await this.services.getUsersService().getByEmail(userName, context)));
+    }
+};
+UserCreationHandler = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [AuthenticationServicesResolver,
+        PasswordHashingProvider])
+], UserCreationHandler);
+
+let UserDeleteHandler = class UserDeleteHandler {
+    constructor(services) {
+        this.services = services;
+    }
+    async execute(input) {
+        await this.services.getUsersService().delete(input.userId);
+    }
+};
+UserDeleteHandler = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [AuthenticationServicesResolver])
+], UserDeleteHandler);
+
 let AuthenticationService = class AuthenticationService {
-    constructor(userDisableHandler, userEnableHandler, userLoginHandler, userPasswordChangeHandler, userPasswordResetFinalizeHandler, userPasswordResetRequestHandler, userRegistrationHandler, userTokenVerifyHandler, userVerifyRequestHandler, userVerifyCompleteHandler, resolver) {
+    constructor(userCreationHandler, userDisableHandler, userDeleteHandler, userEnableHandler, userLoginHandler, userPasswordChangeHandler, userPasswordResetFinalizeHandler, userPasswordResetRequestHandler, userRegistrationHandler, userTokenVerifyHandler, userVerifyRequestHandler, userVerifyCompleteHandler, resolver) {
+        this.userCreationHandler = userCreationHandler;
         this.userDisableHandler = userDisableHandler;
+        this.userDeleteHandler = userDeleteHandler;
         this.userEnableHandler = userEnableHandler;
         this.userLoginHandler = userLoginHandler;
         this.userPasswordChangeHandler = userPasswordChangeHandler;
@@ -19668,9 +20005,15 @@ let AuthenticationService = class AuthenticationService {
         this.userVerifyCompleteHandler = userVerifyCompleteHandler;
         this.resolver = resolver;
     }
+    async userCreate(input) {
+        return await this.userCreationHandler.execute(input);
+    }
     async userDisable(input) {
         await this.userDisableHandler.execute(input);
     }
+    async userDelete(input) {
+        await this.userDeleteHandler.execute(input);
+    }
     async userEnable(input) {
         await this.userEnableHandler.execute(input);
     }
@@ -19710,7 +20053,9 @@ let AuthenticationService = class AuthenticationService {
 };
 AuthenticationService = __decorate([
     Injectable(),
-    __metadata("design:paramtypes", [UserDisableHandler,
+    __metadata("design:paramtypes", [UserCreationHandler,
+        UserDisableHandler,
+        UserDeleteHandler,
         UserEnableHandler,
         UserLoginHandler,
         UserPasswordChangeHandler,
@@ -19771,6 +20116,239 @@ const orderByPriority = (items, priorityFieldSelector, nameFieldSelector) => {
     return sort(items, byField((x) => priorityFieldSelector(x) ?? Number.MAX_VALUE), byField((x) => nameFieldSelector(x)));
 };
 
+var PipelineStepErrorType;
+(function (PipelineStepErrorType) {
+    PipelineStepErrorType["FailedPrecondition"] = "failedPrecondition";
+    PipelineStepErrorType["OperationError"] = "operationError";
+    PipelineStepErrorType["RollbackError"] = "rollbackError";
+    PipelineStepErrorType["GenericError"] = "genericError";
+})(PipelineStepErrorType || (PipelineStepErrorType = {}));
+var PipelineErrorType;
+(function (PipelineErrorType) {
+    PipelineErrorType["FailedPrecondition"] = "failedPrecondition";
+    PipelineErrorType["OperationError"] = "operationError";
+    PipelineErrorType["RollbackError"] = "rollbackError";
+    PipelineErrorType["Unauthorized"] = "unauthorized";
+    PipelineErrorType["GenericError"] = "genericError";
+})(PipelineErrorType || (PipelineErrorType = {}));
+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;
+};
+const mapPipelineErrorType = (stepError) => {
+    switch (stepError) {
+        case PipelineStepErrorType.FailedPrecondition:
+            return PipelineErrorType.FailedPrecondition;
+        case PipelineStepErrorType.OperationError:
+            return PipelineErrorType.OperationError;
+        case PipelineStepErrorType.RollbackError:
+            return PipelineErrorType.RollbackError;
+        case PipelineStepErrorType.GenericError:
+            return PipelineErrorType.GenericError;
+    }
+};
+
+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",
+                    errorType: mapPipelineErrorType(stepResult.errorType),
+                    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: "error",
+                errorType: PipelineStepErrorType.FailedPrecondition,
+                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",
+            errorType: PipelineStepErrorType.OperationError,
+            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 +20370,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 +20475,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,18 +20528,148 @@ 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];
+            },
+        };
+    }
+    complete() {
+        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];
+
+// export const iocStorage = new AsyncLocalStorage<IocContext>()
+const initializeIoCContext = (context) => {
+};
+
 let EntityManagerModule = class EntityManagerModule {
+    constructor(registry) {
+        this.registry = registry;
+    }
+    onModuleInit() {
+        initializeIoCContext({
+            registry: this.registry,
+        });
+    }
 };
 EntityManagerModule = __decorate([
     Module({
         imports: [CustomDiscoveryModule, EventEmitterModule],
-        providers: [...IoC, ...Providers, ...Processors, ...Services$1],
+        providers: [
+            ...IoC,
+            ...Providers,
+            ...Processors,
+            ...Services$1,
+            ...PipelineProviders,
+        ],
         exports: [EntityManagerRegistry, ...Services$1],
-    })
+    }),
+    __metadata("design:paramtypes", [EntityManagerRegistry])
 ], EntityManagerModule);
 
 const UserHandlers = [
+    UserCreationHandler,
     UserDisableHandler,
+    UserDeleteHandler,
     UserEnableHandler,
     UserLoginHandler,
     UserPasswordChangeHandler,
@@ -20049,7 +20764,7 @@ class AppSession {
 
 let AppSessionMiddleware = class AppSessionMiddleware {
     use(req, res, next) {
-        asyncLocalStorage.run(new AppSession(req, res), () => {
+        sessionStorage.run(new AppSession(req, res), () => {
             next();
         });
     }
@@ -20058,7 +20773,7 @@ AppSessionMiddleware = __decorate([
     Injectable()
 ], AppSessionMiddleware);
 function appSessionMiddleware(req, res, next) {
-    asyncLocalStorage.run(new AppSession(req, res), () => {
+    sessionStorage.run(new AppSession(req, res), () => {
         next();
     });
 }
@@ -20195,6 +20910,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 +21045,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);
@@ -20393,6 +21129,14 @@ class NestTypeOrmEntitySeeder extends TypeOrmEntitySeeder {
     }
 }
 
+class PipelineInvocationError extends Error {
+    constructor(errorType, innerError, message) {
+        super(message ?? innerError?.message);
+        this.errorType = errorType;
+        this.innerError = innerError;
+    }
+}
+
 class AppExceptionsFilterBase {
     catch(exception, host) {
         const ctx = host.switchToHttp();
@@ -20428,6 +21172,16 @@ class AppExceptionsFilterBase {
         if (exception instanceof HttpException) {
             return exception.getStatus();
         }
+        if (exception instanceof PipelineInvocationError) {
+            switch (exception.errorType) {
+                case PipelineErrorType.Unauthorized:
+                    return HttpStatus.UNAUTHORIZED;
+                case PipelineErrorType.FailedPrecondition:
+                    return HttpStatus.PRECONDITION_FAILED;
+                default:
+                    return HttpStatus.INTERNAL_SERVER_ERROR;
+            }
+        }
         return HttpStatus.INTERNAL_SERVER_ERROR;
     }
 }
@@ -25646,5 +26400,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, PipelineErrorType, PipelineStatus, PipelineStepErrorType, PipelinesBuilder, PipelinesRunner, PlatformEvents, Public, QueryBuilderBase, ReplicationMode, Roles, SendgridEmailModule, SendgridEmailTemplate, SortDirection, StringFacet, StringFacetItem, TrackingService, UserCreationError, 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