@punks/backend-entity-manager 0.0.71 → 0.0.73

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,
@@ -428,7 +433,12 @@ exports.AuthGuard = __decorate([
     __metadata("design:paramtypes", [core.Reflector])
 ], exports.AuthGuard);
 
-const asyncLocalStorage = new async_hooks.AsyncLocalStorage();
+exports.UserCreationError = void 0;
+(function (UserCreationError) {
+    UserCreationError["UserAlreadyExists"] = "userAlreadyExists";
+})(exports.UserCreationError || (exports.UserCreationError = {}));
+
+const sessionStorage = new async_hooks.AsyncLocalStorage();
 
 exports.AppSessionService = class AppSessionService {
     getValue(key) {
@@ -444,7 +454,7 @@ exports.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");
         }
@@ -467,6 +477,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 +513,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;
@@ -578,7 +615,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(exports.EntityOperationType.Create, this.services.getEntityName(), entity);
@@ -604,13 +644,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(exports.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(exports.EntityOperationType.Delete, this.services.getEntityName());
+    }
+}
+
 class EntityUpdateCommand {
     constructor(services) {
         this.services = services;
@@ -642,7 +722,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(exports.EntityOperationType.Create, this.services.getEntityName(), currentEntity);
@@ -678,7 +761,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)
@@ -695,23 +781,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 +813,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 +883,9 @@ class ServiceLocator {
 const EntityServices = {
     Actions: {
         IEntityGetAction: "IEntityGetAction",
+        IEntityExistsAction: "IEntityExistsAction",
+        IEntitiesCountAction: "IEntitiesCountAction",
+        IEntitiesDeleteAction: "IEntitiesDeleteAction",
         IEntitiesSearchAction: "IEntitiesSearchAction",
         IEntityCreateAction: "IEntityCreateAction",
         IEntityUpdateAction: "IEntityUpdateAction",
@@ -796,6 +902,7 @@ const EntityServices = {
         IEntityUpsertCommand: "IEntityUpsertCommand",
         IEntityMergeCommand: "IEntityMergeCommand",
         IEntityDeleteCommand: "IEntityDeleteCommand",
+        IEntitiesDeleteCommand: "IEntitiesDeleteCommand",
     },
     Converters: {
         IEntityAdapter: "IEntityAdapter",
@@ -810,6 +917,8 @@ const EntityServices = {
         IEntityEventsManager: "IEntityEventsManager",
     },
     Queries: {
+        IEntityCountQuery: "IEntityCountQuery",
+        IEntityExistsQuery: "IEntityExistsQuery",
         IEntityGetQuery: "IEntityGetQuery",
         IEntitiesSearchQuery: "IEntitiesSearchQuery",
         IEntitiesQueryBuilder: "IEntitiesQueryBuilder",
@@ -839,6 +948,9 @@ const GlobalServices = {
         IEmailProvider: "IEmailProvider",
         IEmailTemplatesCollection: "IEmailTemplatesCollection",
     },
+    Pipelines: {
+        IPipelineController: "IPipelineController",
+    },
 };
 
 class EntityServiceLocator {
@@ -894,6 +1006,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 +1030,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 +1057,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,8 +1100,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);
@@ -1072,6 +1210,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 +1240,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 +1286,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 +1328,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 +1342,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);
         }
@@ -1185,7 +1421,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(exports.EntityOperationType.Read, this.services.getEntityName(), entity);
@@ -1196,7 +1435,6 @@ class EntitiesSearchQuery {
     constructor(services) {
         this.services = services;
     }
-    // @ts-ignore
     async execute(request) {
         const context = await this.getContext();
         await this.authorizeSearch(context);
@@ -1221,7 +1459,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();
@@ -1491,6 +1729,8 @@ class EntityManagerServiceCollection {
     }
     mapCrudOperations({ queryBuilder, }) {
         this.mapGet();
+        this.mapCount();
+        this.mapExists();
         this.mapSearch({
             queryBuilder,
         });
@@ -1504,6 +1744,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 +1783,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) {
@@ -19286,7 +19538,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,
@@ -19327,8 +19579,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
@@ -19662,9 +19916,92 @@ UserVerifyRequestHandler = __decorate([
         JwtProvider])
 ], UserVerifyRequestHandler);
 
+let UserCreationHandler = class UserCreationHandler {
+    constructor(services, passwordHashingProvider) {
+        this.services = services;
+        this.passwordHashingProvider = passwordHashingProvider;
+        this.logger = backendCore.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: exports.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([
+    common.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([
+    common.Injectable(),
+    __metadata("design:paramtypes", [AuthenticationServicesResolver])
+], UserDeleteHandler);
+
 exports.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;
@@ -19676,9 +20013,15 @@ exports.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);
     }
@@ -19718,7 +20061,9 @@ exports.AuthenticationService = class AuthenticationService {
 };
 exports.AuthenticationService = __decorate([
     common.Injectable(),
-    __metadata("design:paramtypes", [UserDisableHandler,
+    __metadata("design:paramtypes", [UserCreationHandler,
+        UserDisableHandler,
+        UserDeleteHandler,
         UserEnableHandler,
         UserLoginHandler,
         UserPasswordChangeHandler,
@@ -19779,6 +20124,239 @@ const orderByPriority = (items, priorityFieldSelector, nameFieldSelector) => {
     return backendCore.sort(items, backendCore.byField((x) => priorityFieldSelector(x) ?? Number.MAX_VALUE), backendCore.byField((x) => nameFieldSelector(x)));
 };
 
+exports.PipelineStepErrorType = void 0;
+(function (PipelineStepErrorType) {
+    PipelineStepErrorType["FailedPrecondition"] = "failedPrecondition";
+    PipelineStepErrorType["OperationError"] = "operationError";
+    PipelineStepErrorType["RollbackError"] = "rollbackError";
+    PipelineStepErrorType["GenericError"] = "genericError";
+})(exports.PipelineStepErrorType || (exports.PipelineStepErrorType = {}));
+exports.PipelineErrorType = void 0;
+(function (PipelineErrorType) {
+    PipelineErrorType["FailedPrecondition"] = "failedPrecondition";
+    PipelineErrorType["OperationError"] = "operationError";
+    PipelineErrorType["RollbackError"] = "rollbackError";
+    PipelineErrorType["Unauthorized"] = "unauthorized";
+    PipelineErrorType["GenericError"] = "genericError";
+})(exports.PipelineErrorType || (exports.PipelineErrorType = {}));
+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;
+};
+const mapPipelineErrorType = (stepError) => {
+    switch (stepError) {
+        case exports.PipelineStepErrorType.FailedPrecondition:
+            return exports.PipelineErrorType.FailedPrecondition;
+        case exports.PipelineStepErrorType.OperationError:
+            return exports.PipelineErrorType.OperationError;
+        case exports.PipelineStepErrorType.RollbackError:
+            return exports.PipelineErrorType.RollbackError;
+        case exports.PipelineStepErrorType.GenericError:
+            return exports.PipelineErrorType.GenericError;
+    }
+};
+
+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",
+                    errorType: mapPipelineErrorType(stepResult.errorType),
+                    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: "error",
+                errorType: exports.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: exports.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;
 exports.EntityManagerInitializer = EntityManagerInitializer_1 = class EntityManagerInitializer {
     constructor(discover, registry, eventEmitter) {
@@ -19800,6 +20378,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 +20483,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,18 +20536,148 @@ 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];
+            },
+        };
+    }
+    complete() {
+        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];
+
+// export const iocStorage = new AsyncLocalStorage<IocContext>()
+const initializeIoCContext = (context) => {
+};
+
 exports.EntityManagerModule = class EntityManagerModule {
+    constructor(registry) {
+        this.registry = registry;
+    }
+    onModuleInit() {
+        initializeIoCContext({
+            registry: this.registry,
+        });
+    }
 };
 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],
-    })
+    }),
+    __metadata("design:paramtypes", [exports.EntityManagerRegistry])
 ], exports.EntityManagerModule);
 
 const UserHandlers = [
+    UserCreationHandler,
     UserDisableHandler,
+    UserDeleteHandler,
     UserEnableHandler,
     UserLoginHandler,
     UserPasswordChangeHandler,
@@ -20057,7 +20772,7 @@ class AppSession {
 
 exports.AppSessionMiddleware = class AppSessionMiddleware {
     use(req, res, next) {
-        asyncLocalStorage.run(new AppSession(req, res), () => {
+        sessionStorage.run(new AppSession(req, res), () => {
             next();
         });
     }
@@ -20066,7 +20781,7 @@ exports.AppSessionMiddleware = __decorate([
     common.Injectable()
 ], exports.AppSessionMiddleware);
 function appSessionMiddleware(req, res, next) {
-    asyncLocalStorage.run(new AppSession(req, res), () => {
+    sessionStorage.run(new AppSession(req, res), () => {
         next();
     });
 }
@@ -20203,6 +20918,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 +21053,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);
@@ -20401,6 +21137,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();
@@ -20436,6 +21180,16 @@ class AppExceptionsFilterBase {
         if (exception instanceof common.HttpException) {
             return exception.getStatus();
         }
+        if (exception instanceof PipelineInvocationError) {
+            switch (exception.errorType) {
+                case exports.PipelineErrorType.Unauthorized:
+                    return common.HttpStatus.UNAUTHORIZED;
+                case exports.PipelineErrorType.FailedPrecondition:
+                    return common.HttpStatus.PRECONDITION_FAILED;
+                default:
+                    return common.HttpStatus.INTERNAL_SERVER_ERROR;
+            }
+        }
         return common.HttpStatus.INTERNAL_SERVER_ERROR;
     }
 }
@@ -25685,6 +26439,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;
@@ -25706,6 +26461,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;