@punks/backend-entity-manager 0.0.28 → 0.0.30

package/dist/cjs/index.js

@@ -3,13 +3,15 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var common = require('@nestjs/common');
-var typeorm = require('typeorm');
+var async_hooks = require('async_hooks');
+var bcrypt = require('bcrypt');
 var backendCore = require('@punks/backend-core');
 var constants = require('@nestjs/common/constants');
 var constants$1 = require('@nestjs/core/injector/constants');
 var metadataScanner = require('@nestjs/core/metadata-scanner');
-var async_hooks = require('async_hooks');
+var jwt = require('@nestjs/jwt');
 var eventEmitter = require('@nestjs/event-emitter');
+var typeorm = require('typeorm');
 
 class EntityManagerException extends Error {
     constructor(message) {
@@ -58,6 +60,12 @@ class MultipleEntitiesFoundException extends EntityManagerException {
         super("Multiple entities found");
     }
 }
+class EntityManagerConfigurationError extends EntityManagerException {
+    constructor(message) {
+        super(message);
+        this.name = "EntityManagerConfigurationError";
+    }
+}
 
 exports.ReplicationMode = void 0;
 (function (ReplicationMode) {
@@ -104,15 +112,18 @@ class NestEntityManager {
 }
 
 const EntityManagerSymbols = {
-    Entity: Symbol.for("WP.ENTITY"),
-    EntityActions: Symbol.for("WP.ENTITY_ACTIONS"),
-    EntityAdapter: Symbol.for("WP.ENTITY_ADAPTER"),
-    EntityAuthMiddleware: Symbol.for("WP.ENTITY_AUTH_MIDDLEWARE"),
-    EntityRepository: Symbol.for("WP.ENTITY_REPOSITORY"),
-    EntityConnector: Symbol.for("WP.ENTITY_CONNECTOR"),
-    EntityConverter: Symbol.for("WP.ENTITY_CONVERTER"),
-    EntityManager: Symbol.for("WP.ENTITY_MANAGER"),
-    EntityQueryBuilder: Symbol.for("WP.ENTITY_QUERY_BUILDER"),
+    AppInitializer: Symbol.for("WP:APP_INITIALIZER"),
+    Entity: Symbol.for("WP:ENTITY"),
+    EntityActions: Symbol.for("WP:ENTITY_ACTIONS"),
+    EntityAdapter: Symbol.for("WP:ENTITY_ADAPTER"),
+    EntityAuthMiddleware: Symbol.for("WP:ENTITY_AUTH_MIDDLEWARE"),
+    EntityRepository: Symbol.for("WP:ENTITY_REPOSITORY"),
+    EntityConnector: Symbol.for("WP:ENTITY_CONNECTOR"),
+    EntityConverter: Symbol.for("WP:ENTITY_CONVERTER"),
+    EntityManager: Symbol.for("WP:ENTITY_MANAGER"),
+    EntityQueryBuilder: Symbol.for("WP:ENTITY_QUERY_BUILDER"),
+    EmailProvider: Symbol.for("WP:EMAIL_PROVIDER"),
+    EmailTemplate: Symbol.for("WP:EMAIL_TEMPLATE"),
 };
 
 const WpEntityAuthMiddleware = (entityName, props = {}) => common.applyDecorators(common.Injectable(), common.SetMetadata(EntityManagerSymbols.EntityAuthMiddleware, {
@@ -140,11 +151,17 @@ const WpEntityConverter = (entityName, props = {}) => common.applyDecorators(com
     ...props,
 }));
 
+const WpEmailTemplate = (templateId) => common.applyDecorators(common.Injectable(), common.SetMetadata(EntityManagerSymbols.EmailTemplate, {
+    templateId,
+}));
+
 const WpEntity = (name, props = {}) => common.applyDecorators(common.SetMetadata(EntityManagerSymbols.Entity, {
     name,
     ...props,
 }));
 
+const WpAppInitializer = () => common.applyDecorators(common.Injectable(), common.SetMetadata(EntityManagerSymbols.AppInitializer, true));
+
 const WpEntityRepository = (entityName, props = {}) => common.applyDecorators(common.Injectable(), common.SetMetadata(EntityManagerSymbols.EntityRepository, {
     entityName,
     ...props,
@@ -160,6 +177,37 @@ const WpEntityQueryBuilder = (entityName, props = {}) => common.applyDecorators(
     ...props,
 }));
 
+const AuthenticationExtensionSymbols = {
+    UserService: Symbol.for("WP.EXT:AUTHENTICATION.USER_SERVICE"),
+};
+
+const WpUserService = () => common.applyDecorators(common.Injectable(), common.SetMetadata(AuthenticationExtensionSymbols.UserService, true));
+
+const AuthenticationEmailTemplates = {
+    Registration: "registration",
+    PasswordReset: "passwordReset",
+    EmailVerify: "emailVerify",
+};
+
+class AuthenticationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "AuthenticationError";
+    }
+}
+class InvalidCredentialsError extends AuthenticationError {
+    constructor(message) {
+        super(message);
+        this.name = "InvalidCredentialsError";
+    }
+}
+class OperationTokenMismatchError extends AuthenticationError {
+    constructor(message) {
+        super(message);
+        this.name = "OperationTokenMismatchError";
+    }
+}
+
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
 
@@ -191,204 +239,44 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
   return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
-let AuthenticationService = class AuthenticationService {
-};
-AuthenticationService = __decorate([
-    common.Injectable()
-], AuthenticationService);
-
-const Services$1 = [AuthenticationService];
-
-exports.AuthenticationModule = class AuthenticationModule {
-};
-exports.AuthenticationModule = __decorate([
-    common.Module({
-        providers: [...Services$1],
-        exports: [...Services$1],
-    })
-], exports.AuthenticationModule);
-
-exports.MultiTenancyModule = class MultiTenancyModule {
-};
-exports.MultiTenancyModule = __decorate([
-    common.Module({})
-], exports.MultiTenancyModule);
-
-class QueryBuilderBase {
-    getIndexBasedPagingResult({ paging, totResults, currentPageResults, }) {
-        if (!paging) {
-            return undefined;
-        }
-        const cursor = paging.cursor ?? 0;
-        const hasMorePages = cursor * paging.pageSize + currentPageResults < totResults;
-        return {
-            pageIndex: cursor,
-            pageSize: paging.pageSize,
-            totItems: totResults,
-            totPageItems: currentPageResults,
-            totPages: Math.ceil(totResults / paging.pageSize),
-            currentPageCursor: cursor,
-            prevPageCursor: cursor > 0 ? cursor - 1 : undefined,
-            nextPageCursor: hasMorePages ? cursor + 1 : undefined,
-        };
-    }
-}
-
-class TypeOrmQueryBuilder extends QueryBuilderBase {
-    constructor(services) {
-        super();
-        this.services = services;
-    }
-    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);
-        const results = await this.findPagedQueryResults(request, context);
-        const facets = await this.calculateFacets(request, context);
-        return {
-            items: results,
-            request,
-            paging: this.getIndexBasedPagingResult({
-                paging: request.paging,
-                currentPageResults: results.length,
-                totResults: queryResults,
-            }),
-            facets,
-        };
-    }
-    async findPagedQueryResults(request, context) {
-        return await this.getRepository().find({
-            where: {
-                ...(context ? this.buildContextFilter(context) : {}),
-                ...this.buildWhereClause(request),
-            },
-            relations: this.getRelationsToLoad(request),
-            ...this.buildPagingParameters(request),
-        });
-    }
-    getRelationsToLoad(request, context) {
-        return undefined;
-    }
-    buildPagingParameters(request) {
-        return {
-            skip: request.paging?.cursor
-                ? request.paging.cursor * request.paging.pageSize
-                : undefined,
-            take: request.paging?.pageSize,
-        };
-    }
-    async countQueryResults(request, context) {
-        return await this.getRepository().count({
-            where: {
-                ...(context ? this.buildContextFilter(context) : {}),
-                ...this.buildWhereClause(request),
-            },
-        });
-    }
-    getRepository() {
-        if (!this.repository) {
-            this.repository = this.services.resolveRepository();
-        }
-        return this.repository;
-    }
-}
+const asyncLocalStorage = new async_hooks.AsyncLocalStorage();
 
-class TypeOrmRepository {
-    constructor(innerRepository) {
-        this.innerRepository = innerRepository;
-    }
-    async exists(id) {
-        if (typeof id === "undefined") {
-            throw new Error("Invalid 'id' parameter.");
-        }
-        return await this.innerRepository.exist({
-            where: {
-                id: id,
-            },
-        });
-    }
-    async existsBy(condition) {
-        return await this.innerRepository.exist(condition);
-    }
-    async get(id) {
-        if (typeof id === "undefined") {
-            throw new Error("Invalid 'id' parameter.");
-        }
-        const result = await this.innerRepository.findOne({
-            where: {
-                id: id,
-            },
-        });
-        return result ?? undefined;
-    }
-    async getBy(condition) {
-        const result = await this.innerRepository.findOne(condition);
-        return result ?? undefined;
-    }
-    async all() {
-        return await this.innerRepository.find();
-    }
-    async count(condition) {
-        return await this.innerRepository.count(condition);
-    }
-    async find(condition) {
-        return await this.innerRepository.find(condition);
-    }
-    async findById(id) {
-        return await this.innerRepository.findBy({
-            id: typeorm.In(id),
-        });
-    }
-    async delete(id) {
-        await this.innerRepository.delete({
-            id: id,
-        });
-    }
-    async deleteBy(condition) {
-        await this.innerRepository.delete(condition);
+exports.AppSessionService = class AppSessionService {
+    getValue(key) {
+        return this.getSession().get(key);
     }
-    async create(entity) {
-        const createResult = await this.innerRepository.insert(entity);
-        const current = await this.get(createResult.identifiers[0].id);
-        if (!current) {
-            throw new Error(`Entity ${entity.id} not found`);
-        }
-        return current;
+    setValue(key, value) {
+        this.getSession().set(key, value);
     }
-    async update(id, entity) {
-        await this.innerRepository.update(id, entity);
-        const current = await this.get(id);
-        if (!current) {
-            throw new Error(`Entity ${id} not found`);
-        }
-        return current;
+    clearValue(key) {
+        this.getSession().set(key, undefined);
     }
-    async updateBy(entity, condition) {
-        const updateResult = await this.innerRepository.update(condition, entity);
-        return await this.findById(updateResult.generatedMaps.map((x) => x.id));
+    getRequest() {
+        return this.getSession().request;
     }
-    async upsert(id, entity) {
-        if (await this.exists(id)) {
-            return await this.update(id, entity);
+    getSession() {
+        const store = asyncLocalStorage.getStore();
+        if (!store) {
+            throw new Error("No active context found");
         }
-        return await this.create({
-            ...entity,
-            id,
-        });
+        return store;
     }
-}
+};
+exports.AppSessionService = __decorate([
+    common.Injectable()
+], exports.AppSessionService);
 
-class NestTypeOrmQueryBuilder extends TypeOrmQueryBuilder {
-    constructor(entityName, registry) {
-        // todo: discover entityName from decorator
-        super(registry.resolveEntityServicesCollection(entityName));
+exports.AppHashingService = class AppHashingService {
+    async hash(value, salt) {
+        return await bcrypt.hash(value, salt);
     }
-}
-
-class NestTypeOrmRepository extends TypeOrmRepository {
-    constructor(repository) {
-        super(repository);
+    async compare(hash, value, salt) {
+        return (await this.hash(value, salt)) === hash;
     }
-}
+};
+exports.AppHashingService = __decorate([
+    common.Injectable()
+], exports.AppHashingService);
 
 class EntityCreateAction {
     constructor(services) {
@@ -757,6 +645,10 @@ const GlobalServices = {
     Authentication: {
         IAuthenticationContextProvider: "IAuthenticationContextProvider",
     },
+    Messaging: {
+        IEmailProvider: "IEmailProvider",
+        IEmailTemplatesCollection: "IEmailTemplatesCollection",
+    },
 };
 
 class EntityServiceLocator {
@@ -870,6 +762,18 @@ class EntitiesServiceLocator {
     registerEventEmitter(instance) {
         this.provider.register(GlobalServices.Events.IEventEmitter, instance);
     }
+    resolveEmailProvider() {
+        return this.provider.resolve(GlobalServices.Messaging.IEmailProvider);
+    }
+    registerEmailProvider(instance) {
+        this.provider.register(GlobalServices.Messaging.IEmailProvider, instance);
+    }
+    resolveEmailTemplatesCollection() {
+        return this.provider.resolve(GlobalServices.Messaging.IEmailTemplatesCollection);
+    }
+    registerEmailTemplatesCollection(instance) {
+        this.provider.register(GlobalServices.Messaging.IEmailTemplatesCollection, instance);
+    }
     resolveAuthenticationContextProvider() {
         return this.provider.resolve(GlobalServices.Authentication.IAuthenticationContextProvider);
     }
@@ -18798,6 +18702,19 @@ let CustomDiscoveryService = class CustomDiscoveryService {
             discoveredClass: x,
         }));
     }
+    async providerWithMetaAtKey(metaKey) {
+        const providers = await this.providers(withMetaAtKey(metaKey));
+        if (providers.length > 1) {
+            throw new Error(`Found multiple providers with meta key ${metaKey.toString()}`);
+        }
+        if (!providers.length) {
+            return undefined;
+        }
+        return {
+            meta: getComponentMetaAtKey(metaKey, providers[0]),
+            discoveredClass: providers[0],
+        };
+    }
     /**
      * Discovers all controllers in a Nest App that match a filter
      * @param filter
@@ -18924,42 +18841,596 @@ CustomDiscoveryModule = __decorate([
     })
 ], CustomDiscoveryModule);
 
-class AppExceptionsFilterBase {
-    catch(exception, host) {
-        const ctx = host.switchToHttp();
-        const response = ctx.getResponse();
-        const request = ctx.getRequest();
-        this.logError({
-            exception,
-            request,
-            response,
-        }).catch((error) => {
-            backendCore.Log.getLogger("AllExceptionsFilter").error("Error logging failed", error);
-        });
-        const status = this.getErrorStatusCode(exception);
-        response.status(status).json({
-            statusCode: status,
-            timestamp: new Date().toISOString(),
-            path: request.url,
+exports.EntityManagerService = class EntityManagerService {
+    constructor(registry) {
+        this.registry = registry;
+    }
+    getManager(entityName) {
+        return this.registry
+            .resolveEntityServicesCollection(entityName)
+            .resolveEntityManager();
+    }
+    getActions(entityName) {
+        return this.registry
+            .resolveEntityServicesCollection(entityName)
+            .resolveEntityActions();
+    }
+    getRepository(entityName) {
+        return this.registry
+            .resolveEntityServicesCollection(entityName)
+            .resolveRepository();
+    }
+};
+exports.EntityManagerService = __decorate([
+    common.Injectable(),
+    __metadata("design:paramtypes", [exports.EntityManagerRegistry])
+], exports.EntityManagerService);
+
+exports.EmailService = class EmailService {
+    constructor(registry) {
+        this.registry = registry;
+    }
+    async sendTemplatedEmail(input) {
+        await this.provider.sendTemplatedEmail(input);
+    }
+    async sendHtmlEmail(input) {
+        await this.provider.sendHtmlEmail(input);
+    }
+    get provider() {
+        return this.registry
+            .getContainer()
+            .getEntitiesServicesLocator()
+            .resolveEmailProvider();
+    }
+};
+exports.EmailService = __decorate([
+    common.Injectable(),
+    __metadata("design:paramtypes", [exports.EntityManagerRegistry])
+], exports.EmailService);
+
+let AuthenticationServicesResolver = class AuthenticationServicesResolver {
+    registerUsersService(usersService) {
+        this.usersService = usersService;
+    }
+    getUsersService() {
+        if (!this.usersService) {
+            throw new Error("Users service is not registered");
+        }
+        return this.usersService;
+    }
+};
+AuthenticationServicesResolver = __decorate([
+    common.Injectable()
+], AuthenticationServicesResolver);
+
+let settings;
+const setAuthSettings = (input) => {
+    settings = input;
+};
+const getAuthSettings = () => settings;
+
+let JwtProvider = class JwtProvider {
+    constructor(jwtService) {
+        this.jwtService = jwtService;
+    }
+    async sign(payload) {
+        return await this.jwtService.signAsync(JSON.stringify(payload), {
+            secret: getAuthSettings().jwtSecret,
         });
     }
-    getErrorStatusCode(exception) {
-        const customErrorCode = this.getCustomErrorStatusCode(exception);
-        if (customErrorCode) {
-            return customErrorCode;
+    async parse(token) {
+        return await this.jwtService.verifyAsync(token, {
+            ignoreExpiration: true,
+            secret: getAuthSettings().jwtSecret,
+        });
+    }
+    async verify(token) {
+        return await this.jwtService.verifyAsync(token, {
+            ignoreExpiration: false,
+            secret: getAuthSettings().jwtSecret,
+        });
+    }
+};
+JwtProvider = __decorate([
+    common.Injectable(),
+    __metadata("design:paramtypes", [jwt.JwtService])
+], JwtProvider);
+
+let PasswordHashingProvider = class PasswordHashingProvider {
+    constructor(hashing) {
+        this.hashing = hashing;
+        this.buildUserSalt = (input) => {
+            return `${input.salt}${input.userId}`;
+        };
+    }
+    async hashPassword(input) {
+        return await this.hashing.hash(input.password, this.buildUserSalt({
+            salt: getAuthSettings().passwordSalt,
+            userId: input.userId,
+        }));
+    }
+    async verifyPassword(input) {
+        const padHash = await this.hashPassword({
+            password: input.password,
+            userId: input.userId,
+        });
+        return {
+            isMatching: padHash === input.hash,
+        };
+    }
+};
+PasswordHashingProvider = __decorate([
+    common.Injectable(),
+    __metadata("design:paramtypes", [exports.AppHashingService])
+], PasswordHashingProvider);
+
+var UserRegistrationError;
+(function (UserRegistrationError) {
+    UserRegistrationError[UserRegistrationError["UserAlreadyExists"] = 0] = "UserAlreadyExists";
+})(UserRegistrationError || (UserRegistrationError = {}));
+let UserRegistrationHandler = class UserRegistrationHandler {
+    constructor(services, passwordHashingProvider, emailService, jwtProvider) {
+        this.services = services;
+        this.passwordHashingProvider = passwordHashingProvider;
+        this.emailService = emailService;
+        this.jwtProvider = jwtProvider;
+    }
+    async execute(input) {
+        const user = await this.resolveUser(input.email, input.context);
+        if (user && user.verified) {
+            return {
+                success: false,
+                error: UserRegistrationError.UserAlreadyExists,
+            };
         }
-        if (exception instanceof EntityOperationUnauthorizedException) {
-            return common.HttpStatus.UNAUTHORIZED;
+        if (user && !user.verified) {
+            const passwordHash = await this.createPasswordHash(input.password, user.id);
+            await this.services.getUsersService().update(user.id, {
+                passwordHash,
+                passwordUpdateTimestamp: new Date(),
+            });
+            await this.sendRegistrationEmail(user, input.callback);
+            return {
+                success: true,
+            };
         }
-        if (exception instanceof EntityNotFoundException) {
-            return common.HttpStatus.NOT_FOUND;
+        const newUser = await this.createUser(input.email, input.registrationInfo, input.context);
+        const passwordHash = await this.createPasswordHash(input.password, newUser.id);
+        await this.services.getUsersService().update(newUser.id, {
+            passwordHash,
+            passwordUpdateTimestamp: new Date(),
+        });
+        await this.sendRegistrationEmail(newUser, input.callback);
+        return {
+            success: true,
+        };
+    }
+    async createPasswordHash(password, userId) {
+        return await this.passwordHashingProvider.hashPassword({
+            password,
+            userId,
+        });
+    }
+    async sendRegistrationEmail(user, callback) {
+        const token = await this.generateEmailVerifyToken(user);
+        await this.emailService.sendTemplatedEmail({
+            to: [user.email],
+            templateId: AuthenticationEmailTemplates.Registration,
+            payload: {
+                firstName: user.profile?.firstName,
+                lastName: user.profile?.lastName,
+                callbackUrl: callback.urlTemplate.replace(callback.tokenPlaceholder, token),
+            },
+        });
+    }
+    async generateEmailVerifyToken(user) {
+        return await this.jwtProvider.sign({
+            email: user.email,
+            userId: user.id,
+            timestamp: Date.now(),
+        });
+    }
+    async createUser(email, info, context) {
+        return await this.services.getUsersService().create(email, info, context);
+    }
+    async resolveUser(userName, context) {
+        return ((await this.services
+            .getUsersService()
+            .getByUserName(userName, context)) ??
+            (await this.services.getUsersService().getByEmail(userName, context)));
+    }
+};
+UserRegistrationHandler = __decorate([
+    common.Injectable(),
+    __metadata("design:paramtypes", [AuthenticationServicesResolver,
+        PasswordHashingProvider,
+        exports.EmailService,
+        JwtProvider])
+], UserRegistrationHandler);
+
+let UserDisableHandler = class UserDisableHandler {
+    constructor(services) {
+        this.services = services;
+    }
+    async execute(input) {
+        await this.services.getUsersService().update(input.userId, {
+            disabled: true,
+        });
+    }
+};
+UserDisableHandler = __decorate([
+    common.Injectable(),
+    __metadata("design:paramtypes", [AuthenticationServicesResolver])
+], UserDisableHandler);
+
+let UserEnableHandler = class UserEnableHandler {
+    constructor(services) {
+        this.services = services;
+    }
+    async execute(input) {
+        await this.services.getUsersService().update(input.userId, {
+            disabled: false,
+        });
+    }
+};
+UserEnableHandler = __decorate([
+    common.Injectable(),
+    __metadata("design:paramtypes", [AuthenticationServicesResolver])
+], UserEnableHandler);
+
+const extractUserTokenData = (user, context) => ({
+    email: user.email,
+    userId: user.id,
+    context,
+});
+
+let UserLoginHandler = class UserLoginHandler {
+    constructor(services, passwordHashingProvider, jwtProvider) {
+        this.services = services;
+        this.passwordHashingProvider = passwordHashingProvider;
+        this.jwtProvider = jwtProvider;
+    }
+    async execute(input) {
+        const user = await this.resolveUser(input.userName, input.context);
+        if (!user) {
+            return {
+                success: false,
+            };
         }
-        if (exception instanceof common.HttpException) {
-            return exception.getStatus();
+        const newPasswordHash = await this.passwordHashingProvider.verifyPassword({
+            password: input.password,
+            hash: user.passwordHash,
+            userId: user.id,
+        });
+        if (!newPasswordHash.isMatching) {
+            return {
+                success: false,
+            };
         }
-        return common.HttpStatus.INTERNAL_SERVER_ERROR;
+        return {
+            success: true,
+            token: await this.generateUserJwtToken(user, input.context),
+        };
     }
-}
+    async generateUserJwtToken(user, context) {
+        return await this.jwtProvider.sign(extractUserTokenData(user, context));
+    }
+    async resolveUser(userName, context) {
+        return ((await this.services
+            .getUsersService()
+            .getByUserName(userName, context)) ??
+            (await this.services.getUsersService().getByEmail(userName, context)));
+    }
+};
+UserLoginHandler = __decorate([
+    common.Injectable(),
+    __metadata("design:paramtypes", [AuthenticationServicesResolver,
+        PasswordHashingProvider,
+        JwtProvider])
+], UserLoginHandler);
+
+let UserPasswordChangeHandler = class UserPasswordChangeHandler {
+    constructor(services, passwordHashingProvider) {
+        this.services = services;
+        this.passwordHashingProvider = passwordHashingProvider;
+    }
+    async execute(input) {
+        const newPasswordHash = await this.passwordHashingProvider.hashPassword({
+            password: input.newPassword,
+            userId: input.userId,
+        });
+        await this.services.getUsersService().update(input.userId, {
+            passwordHash: newPasswordHash,
+            passwordUpdateTimestamp: new Date(),
+            temporaryPassword: input.temporary ?? false,
+        });
+    }
+};
+UserPasswordChangeHandler = __decorate([
+    common.Injectable(),
+    __metadata("design:paramtypes", [AuthenticationServicesResolver,
+        PasswordHashingProvider])
+], UserPasswordChangeHandler);
+
+let UserPasswordResetCompleteHandler = class UserPasswordResetCompleteHandler {
+    constructor(services, passwordHashingProvider, jwtProvider) {
+        this.services = services;
+        this.passwordHashingProvider = passwordHashingProvider;
+        this.jwtProvider = jwtProvider;
+    }
+    async execute(input) {
+        const tokenPayload = await this.decodeToken(input.token);
+        const user = await this.getUser(tokenPayload);
+        this.validateUser(user, tokenPayload);
+        const newPasswordHash = await this.passwordHashingProvider.hashPassword({
+            password: input.newPassword,
+            userId: user.id,
+        });
+        await this.services.getUsersService().update(user.id, {
+            passwordHash: newPasswordHash,
+            passwordUpdateTimestamp: new Date(),
+            temporaryPassword: input.temporary ?? false,
+            ...(!user.verified
+                ? {
+                    verified: true,
+                    verifiedTimestamp: new Date(),
+                }
+                : {}),
+        });
+    }
+    async decodeToken(token) {
+        return await this.jwtProvider.verify(token);
+    }
+    validateUser(user, tokenPayload) {
+        if (user.email !== tokenPayload.email) {
+            throw new OperationTokenMismatchError("Verify token user email not matching");
+        }
+    }
+    async getUser(tokenPayload) {
+        const user = await this.services
+            .getUsersService()
+            .getById(tokenPayload.userId);
+        if (!user) {
+            throw new OperationTokenMismatchError("Verify token user not found");
+        }
+        return user;
+    }
+};
+UserPasswordResetCompleteHandler = __decorate([
+    common.Injectable(),
+    __metadata("design:paramtypes", [AuthenticationServicesResolver,
+        PasswordHashingProvider,
+        JwtProvider])
+], UserPasswordResetCompleteHandler);
+
+let UserPasswordResetRequestHandler = class UserPasswordResetRequestHandler {
+    constructor(services, emailService, jwtProvider) {
+        this.services = services;
+        this.emailService = emailService;
+        this.jwtProvider = jwtProvider;
+    }
+    async execute(input) {
+        const user = await this.resolveUser(input.email, input.context);
+        if (!user) {
+            return {
+                success: false,
+            };
+        }
+        await this.sendPasswordResetEmail(user, input.callback);
+        return {
+            success: true,
+        };
+    }
+    async sendPasswordResetEmail(user, callback) {
+        const token = await this.generatePasswordResetToken(user);
+        await this.emailService.sendTemplatedEmail({
+            to: [user.email],
+            templateId: AuthenticationEmailTemplates.PasswordReset,
+            payload: {
+                firstName: user.profile.firstName,
+                lastName: user.profile.lastName,
+                callbackUrl: callback.urlTemplate.replace(callback.tokenPlaceholder, token),
+            },
+        });
+    }
+    async generatePasswordResetToken(user) {
+        return await this.jwtProvider.sign({
+            email: user.email,
+            userId: user.id,
+            timestamp: Date.now(),
+        });
+    }
+    async resolveUser(userName, context) {
+        return ((await this.services
+            .getUsersService()
+            .getByUserName(userName, context)) ??
+            (await this.services.getUsersService().getByEmail(userName, context)));
+    }
+};
+UserPasswordResetRequestHandler = __decorate([
+    common.Injectable(),
+    __metadata("design:paramtypes", [AuthenticationServicesResolver,
+        exports.EmailService,
+        JwtProvider])
+], UserPasswordResetRequestHandler);
+
+let UserVerifyCompleteHandler = class UserVerifyCompleteHandler {
+    constructor(services, jwtProvider) {
+        this.services = services;
+        this.jwtProvider = jwtProvider;
+    }
+    async execute(input) {
+        const tokenPayload = await this.decodeToken(input.token);
+        const user = await this.getUser(tokenPayload);
+        this.validateUser(user, tokenPayload);
+        await this.services.getUsersService().update(user.id, {
+            verified: true,
+            verifiedTimestamp: new Date(),
+        });
+    }
+    async decodeToken(token) {
+        return await this.jwtProvider.verify(token);
+    }
+    validateUser(user, tokenPayload) {
+        if (user.email !== tokenPayload.email) {
+            throw new OperationTokenMismatchError("Verify token user email not matching");
+        }
+    }
+    async getUser(tokenPayload) {
+        const user = await this.services
+            .getUsersService()
+            .getById(tokenPayload.userId);
+        if (!user) {
+            throw new OperationTokenMismatchError("Verify token user not found");
+        }
+        return user;
+    }
+};
+UserVerifyCompleteHandler = __decorate([
+    common.Injectable(),
+    __metadata("design:paramtypes", [AuthenticationServicesResolver,
+        JwtProvider])
+], UserVerifyCompleteHandler);
+
+let UserTokenVerifyHandler = class UserTokenVerifyHandler {
+    constructor(jwtProvider) {
+        this.jwtProvider = jwtProvider;
+    }
+    async execute(input) {
+        const decodedToken = await this.decodeUserJwtToken(input.token);
+        return {
+            isValid: !!decodedToken,
+            data: decodedToken,
+        };
+    }
+    async decodeUserJwtToken(token) {
+        return await this.jwtProvider.verify(token);
+    }
+};
+UserTokenVerifyHandler = __decorate([
+    common.Injectable(),
+    __metadata("design:paramtypes", [JwtProvider])
+], UserTokenVerifyHandler);
+
+let UserVerifyRequestHandler = class UserVerifyRequestHandler {
+    constructor(services, emailService, jwtProvider) {
+        this.services = services;
+        this.emailService = emailService;
+        this.jwtProvider = jwtProvider;
+    }
+    async execute(input) {
+        const user = await this.resolveUser(input.email, input.context);
+        if (!user) {
+            return {
+                success: false,
+            };
+        }
+        await this.sendEmailVerifyEmail(user, input.callback);
+        return {
+            success: true,
+        };
+    }
+    async sendEmailVerifyEmail(user, callback) {
+        const token = await this.generateEmailVerifyToken(user);
+        await this.emailService.sendTemplatedEmail({
+            to: [user.email],
+            templateId: AuthenticationEmailTemplates.EmailVerify,
+            payload: {
+                firstName: user.profile.firstName,
+                lastName: user.profile.lastName,
+                callbackUrl: callback.urlTemplate.replace(callback.tokenPlaceholder, token),
+            },
+        });
+    }
+    async generateEmailVerifyToken(user) {
+        return await this.jwtProvider.sign({
+            email: user.email,
+            userId: user.id,
+            timestamp: Date.now(),
+        });
+    }
+    async resolveUser(userName, context) {
+        return ((await this.services
+            .getUsersService()
+            .getByUserName(userName, context)) ??
+            (await this.services.getUsersService().getByEmail(userName, context)));
+    }
+};
+UserVerifyRequestHandler = __decorate([
+    common.Injectable(),
+    __metadata("design:paramtypes", [AuthenticationServicesResolver,
+        exports.EmailService,
+        JwtProvider])
+], UserVerifyRequestHandler);
+
+exports.AuthenticationService = class AuthenticationService {
+    constructor(userDisableHandler, userEnableHandler, userLoginHandler, userPasswordChangeHandler, userPasswordResetFinalizeHandler, userPasswordResetRequestHandler, userRegistrationHandler, userTokenVerifyHandler, userVerifyRequestHandler, userVerifyCompleteHandler) {
+        this.userDisableHandler = userDisableHandler;
+        this.userEnableHandler = userEnableHandler;
+        this.userLoginHandler = userLoginHandler;
+        this.userPasswordChangeHandler = userPasswordChangeHandler;
+        this.userPasswordResetFinalizeHandler = userPasswordResetFinalizeHandler;
+        this.userPasswordResetRequestHandler = userPasswordResetRequestHandler;
+        this.userRegistrationHandler = userRegistrationHandler;
+        this.userTokenVerifyHandler = userTokenVerifyHandler;
+        this.userVerifyRequestHandler = userVerifyRequestHandler;
+        this.userVerifyCompleteHandler = userVerifyCompleteHandler;
+    }
+    async userDisable(input) {
+        return await this.userDisableHandler.execute(input);
+    }
+    async userEnable(input) {
+        return await this.userEnableHandler.execute(input);
+    }
+    async userLogin(input) {
+        return await this.userLoginHandler.execute(input);
+    }
+    async userPasswordChange(input) {
+        return await this.userPasswordChangeHandler.execute(input);
+    }
+    async userPasswordResetFinalize(input) {
+        return await this.userPasswordResetFinalizeHandler.execute(input);
+    }
+    async userPasswordResetRequest(input) {
+        return await this.userPasswordResetRequestHandler.execute(input);
+    }
+    async userRegister(input) {
+        return await this.userRegistrationHandler.execute(input);
+    }
+    async userVerifyRequest(input) {
+        return await this.userVerifyRequestHandler.execute(input);
+    }
+    async userVerifyComplete(input) {
+        return await this.userVerifyCompleteHandler.execute(input);
+    }
+    async userTokenVerify(input) {
+        return await this.userTokenVerifyHandler.execute(input);
+    }
+};
+exports.AuthenticationService = __decorate([
+    common.Injectable(),
+    __metadata("design:paramtypes", [UserDisableHandler,
+        UserEnableHandler,
+        UserLoginHandler,
+        UserPasswordChangeHandler,
+        UserPasswordResetCompleteHandler,
+        UserPasswordResetRequestHandler,
+        UserRegistrationHandler,
+        UserTokenVerifyHandler,
+        UserVerifyRequestHandler,
+        UserVerifyCompleteHandler])
+], exports.AuthenticationService);
+
+const Services$1 = [exports.AuthenticationService];
+
+const Services = [
+    exports.AppSessionService,
+    exports.AppHashingService,
+    exports.EntityManagerService,
+    exports.EmailService,
+];
+
+const IoC = [exports.EntityManagerRegistry];
 
 let NestEventEmitter = class NestEventEmitter {
     constructor() { }
@@ -18975,6 +19446,24 @@ NestEventEmitter = __decorate([
     __metadata("design:paramtypes", [])
 ], NestEventEmitter);
 
+class EmailTemplatesCollection {
+    constructor() {
+        this._collection = new Map();
+    }
+    registerTemplate(id, template) {
+        if (this._collection.has(id)) {
+            throw new EntityManagerConfigurationError(`Email template with id "${id}" already registered`);
+        }
+        this._collection.set(id, template);
+    }
+    getTemplate(id) {
+        if (!this._collection.has(id)) {
+            throw new EntityManagerConfigurationError(`Email template with id "${id}" not found`);
+        }
+        return this._collection.get(id);
+    }
+}
+
 var EntityManagerInitializer_1;
 exports.EntityManagerInitializer = EntityManagerInitializer_1 = class EntityManagerInitializer {
     constructor(discover, registry, eventEmitter) {
@@ -18991,7 +19480,22 @@ exports.EntityManagerInitializer = EntityManagerInitializer_1 = class EntityMana
             eventEmitter: this.eventEmitter,
         });
         this.logger.log("Initializing entity manager types 🥁");
-        // const entities = await this.discoverEntities()
+        await this.registerEntities(app);
+        if (staticProviders.authenticationProvider) {
+            await this.registerAuthentication(staticProviders.authenticationProvider);
+            this.logger.log("Entity manager authentication initialized 🔑");
+        }
+        await this.registerEmailTemplates();
+        await this.registerEmailProviders();
+        await this.executeInitializers(app);
+        this.logger.log("Entity manager initialization completed 🚀");
+    }
+    async registerAuthentication(authenticationProvider) {
+        this.registry.getContainer().addAuthentication({
+            provider: authenticationProvider,
+        });
+    }
+    async registerEntities(app) {
         const repositories = await this.discoverRepositories();
         const queryBuilders = await this.discoverQueryBuilders();
         const converters = await this.discoverConverters();
@@ -19018,7 +19522,7 @@ exports.EntityManagerInitializer = EntityManagerInitializer_1 = class EntityMana
                 converter,
                 authMiddleware,
             });
-            this.logger.debug(`Entity ${entityName} registered:
+            this.logger.log(`Entity ${entityName} registered:
   - Repository: ${repository.discoveredClass.injectType?.name ?? ""}
   - Query builder: ${queryBuilder.discoveredClass.injectType?.name ?? ""}
   - Adapter: ${adapter?.discoveredClass.injectType?.name ?? ""}
@@ -19027,13 +19531,39 @@ exports.EntityManagerInitializer = EntityManagerInitializer_1 = class EntityMana
 ✨
       `);
         }
-        this.logger.log("Entity manager types initialized 🚀");
-        if (staticProviders.authenticationProvider) {
-            this.registry.getContainer().addAuthentication({
-                provider: staticProviders.authenticationProvider,
-            });
-            this.logger.log("Entity manager authentication initialized 🔑");
+        this.logger.log("Entity manager types initialized 👌");
+    }
+    async executeInitializers(app) {
+        const initializers = await this.discoverAppInitializers();
+        for (const initializer of initializers) {
+            await initializer.discoveredClass.instance.initialize(app);
+            this.logger.log(`Entity manager app initializer ${initializer.discoveredClass.name} initialized 💪`);
+        }
+    }
+    async registerEmailProviders() {
+        const providers = await this.discoverEmailProviders();
+        if (!providers.length) {
+            this.logger.warn("No email providers found ⚠️");
+            return;
+        }
+        // todo: handle multiple email providers
+        this.registry
+            .getContainer()
+            .getEntitiesServicesLocator()
+            .registerEmailProvider(providers[0].discoveredClass.instance);
+        this.logger.log(`Email provider ${providers[0].discoveredClass.name} registered 📧`);
+    }
+    async registerEmailTemplates() {
+        const emailTemplates = await this.discoverEmailTemplates();
+        const collection = new EmailTemplatesCollection();
+        for (const emailTemplate of emailTemplates) {
+            collection.registerTemplate(emailTemplate.meta.templateId, emailTemplate.discoveredClass.instance);
+            this.logger.log(`Entity manager email template ${emailTemplate.discoveredClass.name} registered 📧`);
         }
+        this.registry
+            .getContainer()
+            .getEntitiesServicesLocator()
+            .registerEmailTemplatesCollection(collection);
     }
     async initializeProviders(app, staticProviders) {
         app
@@ -19041,9 +19571,6 @@ exports.EntityManagerInitializer = EntityManagerInitializer_1 = class EntityMana
             .setModulesContainer(staticProviders.modulesContainer);
         app.get(NestEventEmitter).setEmitter(staticProviders.eventEmitter);
     }
-    async discoverEntities() {
-        return await this.discover.providersWithMetaAtKey(EntityManagerSymbols.Entity);
-    }
     async discoverRepositories() {
         return await this.discover.providersWithMetaAtKey(EntityManagerSymbols.EntityRepository);
     }
@@ -19059,6 +19586,15 @@ exports.EntityManagerInitializer = EntityManagerInitializer_1 = class EntityMana
     async discoverAuthMiddlewares() {
         return await this.discover.providersWithMetaAtKey(EntityManagerSymbols.EntityAuthMiddleware);
     }
+    async discoverAppInitializers() {
+        return await this.discover.providersWithMetaAtKey(EntityManagerSymbols.AppInitializer);
+    }
+    async discoverEmailTemplates() {
+        return await this.discover.providersWithMetaAtKey(EntityManagerSymbols.EmailTemplate);
+    }
+    async discoverEmailProviders() {
+        return await this.discover.providersWithMetaAtKey(EntityManagerSymbols.EmailProvider);
+    }
 };
 exports.EntityManagerInitializer = EntityManagerInitializer_1 = __decorate([
     common.Injectable(),
@@ -19067,24 +19603,322 @@ exports.EntityManagerInitializer = EntityManagerInitializer_1 = __decorate([
         NestEventEmitter])
 ], exports.EntityManagerInitializer);
 
-const asyncLocalStorage = new async_hooks.AsyncLocalStorage();
+const Processors = [exports.EntityManagerInitializer];
 
-class AppSession {
-    constructor(request, response) {
-        this._map = new Map();
-        this._request = request;
-        this._response = response;
-    }
-    get(key) {
-        return this._map.get(key);
+const Providers = [NestEventEmitter];
+
+exports.EntityManagerModule = class EntityManagerModule {
+};
+exports.EntityManagerModule = __decorate([
+    common.Module({
+        imports: [CustomDiscoveryModule, eventEmitter.EventEmitterModule],
+        providers: [...IoC, ...Providers, ...Processors, ...Services],
+        exports: [exports.EntityManagerRegistry, ...Services],
+    })
+], exports.EntityManagerModule);
+
+const UserHandlers = [
+    UserDisableHandler,
+    UserEnableHandler,
+    UserLoginHandler,
+    UserPasswordChangeHandler,
+    UserPasswordResetCompleteHandler,
+    UserPasswordResetRequestHandler,
+    UserRegistrationHandler,
+    UserTokenVerifyHandler,
+    UserVerifyCompleteHandler,
+    UserVerifyRequestHandler,
+];
+
+const AuthenticationProviders = [JwtProvider, PasswordHashingProvider];
+
+var AuthenticationInitializer_1;
+let AuthenticationInitializer = AuthenticationInitializer_1 = class AuthenticationInitializer {
+    constructor(discover, registry) {
+        this.discover = discover;
+        this.registry = registry;
+        this.logger = new common.Logger(AuthenticationInitializer_1.name);
     }
-    set(key, value) {
-        this._map.set(key, value);
+    async initialize(app) {
+        const userService = await this.discoverUserService();
+        if (!userService) {
+            throw new Error("No user service found");
+        }
+        this.registry.registerUsersService(userService.discoveredClass.instance);
+        this.logger.log("Authentication initialized 🔑");
     }
-    delete(key) {
-        this._map.delete(key);
+    async discoverUserService() {
+        return await this.discover.providerWithMetaAtKey(AuthenticationExtensionSymbols.UserService);
     }
-    clear() {
+};
+AuthenticationInitializer = AuthenticationInitializer_1 = __decorate([
+    WpAppInitializer(),
+    __metadata("design:paramtypes", [CustomDiscoveryService,
+        AuthenticationServicesResolver])
+], AuthenticationInitializer);
+
+var AuthenticationModule_1;
+const ModuleData = {
+    imports: [exports.EntityManagerModule, jwt.JwtModule],
+    providers: [
+        AuthenticationServicesResolver,
+        AuthenticationInitializer,
+        ...Services$1,
+        ...UserHandlers,
+        ...AuthenticationProviders,
+    ],
+    exports: [...Services$1],
+};
+exports.AuthenticationModule = AuthenticationModule_1 = class AuthenticationModule {
+    static forRoot(input) {
+        setAuthSettings(input);
+        return {
+            module: AuthenticationModule_1,
+            ...ModuleData,
+        };
+    }
+};
+exports.AuthenticationModule = AuthenticationModule_1 = __decorate([
+    common.Module({
+        ...ModuleData,
+    })
+], exports.AuthenticationModule);
+
+exports.MultiTenancyModule = class MultiTenancyModule {
+};
+exports.MultiTenancyModule = __decorate([
+    common.Module({})
+], exports.MultiTenancyModule);
+
+class QueryBuilderBase {
+    getIndexBasedPagingResult({ paging, totResults, currentPageResults, }) {
+        if (!paging) {
+            return undefined;
+        }
+        const cursor = paging.cursor ?? 0;
+        const hasMorePages = cursor * paging.pageSize + currentPageResults < totResults;
+        return {
+            pageIndex: cursor,
+            pageSize: paging.pageSize,
+            totItems: totResults,
+            totPageItems: currentPageResults,
+            totPages: Math.ceil(totResults / paging.pageSize),
+            currentPageCursor: cursor,
+            prevPageCursor: cursor > 0 ? cursor - 1 : undefined,
+            nextPageCursor: hasMorePages ? cursor + 1 : undefined,
+        };
+    }
+}
+
+class TypeOrmQueryBuilder extends QueryBuilderBase {
+    constructor(services) {
+        super();
+        this.services = services;
+    }
+    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);
+        const results = await this.findPagedQueryResults(request, context);
+        const facets = await this.calculateFacets(request, context);
+        return {
+            items: results,
+            request,
+            paging: this.getIndexBasedPagingResult({
+                paging: request.paging,
+                currentPageResults: results.length,
+                totResults: queryResults,
+            }),
+            facets,
+        };
+    }
+    async findPagedQueryResults(request, context) {
+        return await this.getRepository().find({
+            where: {
+                ...(context ? this.buildContextFilter(context) : {}),
+                ...this.buildWhereClause(request),
+            },
+            relations: this.getRelationsToLoad(request),
+            ...this.buildPagingParameters(request),
+        });
+    }
+    getRelationsToLoad(request, context) {
+        return undefined;
+    }
+    buildPagingParameters(request) {
+        return {
+            skip: request.paging?.cursor
+                ? request.paging.cursor * request.paging.pageSize
+                : undefined,
+            take: request.paging?.pageSize,
+        };
+    }
+    async countQueryResults(request, context) {
+        return await this.getRepository().count({
+            where: {
+                ...(context ? this.buildContextFilter(context) : {}),
+                ...this.buildWhereClause(request),
+            },
+        });
+    }
+    getRepository() {
+        if (!this.repository) {
+            this.repository = this.services.resolveRepository();
+        }
+        return this.repository;
+    }
+}
+
+class TypeOrmRepository {
+    constructor(innerRepository) {
+        this.innerRepository = innerRepository;
+    }
+    async exists(id) {
+        if (typeof id === "undefined") {
+            throw new Error("Invalid 'id' parameter.");
+        }
+        return await this.innerRepository.exist({
+            where: {
+                id: id,
+            },
+        });
+    }
+    async existsBy(condition) {
+        return await this.innerRepository.exist(condition);
+    }
+    async get(id) {
+        if (typeof id === "undefined") {
+            throw new Error("Invalid 'id' parameter.");
+        }
+        const result = await this.innerRepository.findOne({
+            where: {
+                id: id,
+            },
+        });
+        return result ?? undefined;
+    }
+    async getBy(condition) {
+        const result = await this.innerRepository.findOne(condition);
+        return result ?? undefined;
+    }
+    async all() {
+        return await this.innerRepository.find();
+    }
+    async count(condition) {
+        return await this.innerRepository.count(condition);
+    }
+    async find(condition) {
+        return await this.innerRepository.find(condition);
+    }
+    async findById(id) {
+        return await this.innerRepository.findBy({
+            id: typeorm.In(id),
+        });
+    }
+    async delete(id) {
+        await this.innerRepository.delete({
+            id: id,
+        });
+    }
+    async deleteBy(condition) {
+        await this.innerRepository.delete(condition);
+    }
+    async create(entity) {
+        const createResult = await this.innerRepository.insert(entity);
+        const current = await this.get(createResult.identifiers[0].id);
+        if (!current) {
+            throw new Error(`Entity ${entity.id} not found`);
+        }
+        return current;
+    }
+    async update(id, entity) {
+        await this.innerRepository.update(id, entity);
+        const current = await this.get(id);
+        if (!current) {
+            throw new Error(`Entity ${id} not found`);
+        }
+        return current;
+    }
+    async updateBy(entity, condition) {
+        const updateResult = await this.innerRepository.update(condition, entity);
+        return await this.findById(updateResult.generatedMaps.map((x) => x.id));
+    }
+    async upsert(id, entity) {
+        if (await this.exists(id)) {
+            return await this.update(id, entity);
+        }
+        return await this.create({
+            ...entity,
+            id,
+        });
+    }
+}
+
+class NestTypeOrmQueryBuilder extends TypeOrmQueryBuilder {
+    constructor(entityName, registry) {
+        // todo: discover entityName from decorator
+        super(registry.resolveEntityServicesCollection(entityName));
+    }
+}
+
+class NestTypeOrmRepository extends TypeOrmRepository {
+    constructor(repository) {
+        super(repository);
+    }
+}
+
+class AppExceptionsFilterBase {
+    catch(exception, host) {
+        const ctx = host.switchToHttp();
+        const response = ctx.getResponse();
+        const request = ctx.getRequest();
+        this.logError({
+            exception,
+            request,
+            response,
+        }).catch((error) => {
+            backendCore.Log.getLogger("AllExceptionsFilter").error("Error logging failed", error);
+        });
+        const status = this.getErrorStatusCode(exception);
+        response.status(status).json({
+            statusCode: status,
+            timestamp: new Date().toISOString(),
+            path: request.url,
+        });
+    }
+    getErrorStatusCode(exception) {
+        const customErrorCode = this.getCustomErrorStatusCode(exception);
+        if (customErrorCode) {
+            return customErrorCode;
+        }
+        if (exception instanceof EntityOperationUnauthorizedException) {
+            return common.HttpStatus.UNAUTHORIZED;
+        }
+        if (exception instanceof EntityNotFoundException) {
+            return common.HttpStatus.NOT_FOUND;
+        }
+        if (exception instanceof common.HttpException) {
+            return exception.getStatus();
+        }
+        return common.HttpStatus.INTERNAL_SERVER_ERROR;
+    }
+}
+
+class AppSession {
+    constructor(request, response) {
+        this._map = new Map();
+        this._request = request;
+        this._response = response;
+    }
+    get(key) {
+        return this._map.get(key);
+    }
+    set(key, value) {
+        this._map.set(key, value);
+    }
+    delete(key) {
+        this._map.delete(key);
+    }
+    clear() {
         this._map.clear();
     }
     get request() {
@@ -19106,64 +19940,29 @@ exports.AppSessionMiddleware = __decorate([
     common.Injectable()
 ], exports.AppSessionMiddleware);
 
-exports.AppSessionService = class AppSessionService {
-    getValue(key) {
-        return this.getSession().get(key);
-    }
-    setValue(key, value) {
-        this.getSession().set(key, value);
-    }
-    clearValue(key) {
-        this.getSession().set(key, undefined);
-    }
-    getRequest() {
-        return this.getSession().request;
-    }
-    getSession() {
-        const store = asyncLocalStorage.getStore();
-        if (!store) {
-            throw new Error("No active context found");
-        }
-        return store;
-    }
-};
-exports.AppSessionService = __decorate([
-    common.Injectable()
-], exports.AppSessionService);
-
-const Services = [exports.AppSessionService];
-
-const IoC = [exports.EntityManagerRegistry];
-
-const Processors = [exports.EntityManagerInitializer];
-
-const Providers = [NestEventEmitter];
-
-exports.EntityManagerModule = class EntityManagerModule {
-};
-exports.EntityManagerModule = __decorate([
-    common.Module({
-        imports: [CustomDiscoveryModule, eventEmitter.EventEmitterModule],
-        providers: [...IoC, ...Providers, ...Processors, ...Services],
-        exports: [exports.EntityManagerRegistry, ...Services],
-    })
-], exports.EntityManagerModule);
-
 const newUuid = backendCore.newUuid;
 
 exports.AppExceptionsFilterBase = AppExceptionsFilterBase;
+exports.AuthenticationEmailTemplates = AuthenticationEmailTemplates;
+exports.AuthenticationError = AuthenticationError;
+exports.AuthenticationExtensionSymbols = AuthenticationExtensionSymbols;
+exports.EntityManagerConfigurationError = EntityManagerConfigurationError;
 exports.EntityManagerException = EntityManagerException;
 exports.EntityManagerSymbols = EntityManagerSymbols;
 exports.EntityManagerUnauthorizedException = EntityManagerUnauthorizedException;
 exports.EntityNotFoundException = EntityNotFoundException;
 exports.EntityOperationUnauthorizedException = EntityOperationUnauthorizedException;
+exports.InvalidCredentialsError = InvalidCredentialsError;
 exports.MultipleEntitiesFoundException = MultipleEntitiesFoundException;
 exports.NestEntityActions = NestEntityActions;
 exports.NestEntityAuthorizationMiddleware = NestEntityAuthorizationMiddleware;
 exports.NestEntityManager = NestEntityManager;
 exports.NestTypeOrmQueryBuilder = NestTypeOrmQueryBuilder;
 exports.NestTypeOrmRepository = NestTypeOrmRepository;
+exports.OperationTokenMismatchError = OperationTokenMismatchError;
 exports.QueryBuilderBase = QueryBuilderBase;
+exports.WpAppInitializer = WpAppInitializer;
+exports.WpEmailTemplate = WpEmailTemplate;
 exports.WpEntity = WpEntity;
 exports.WpEntityActions = WpEntityActions;
 exports.WpEntityAdapter = WpEntityAdapter;
@@ -19173,5 +19972,6 @@ exports.WpEntityConverter = WpEntityConverter;
 exports.WpEntityManager = WpEntityManager;
 exports.WpEntityQueryBuilder = WpEntityQueryBuilder;
 exports.WpEntityRepository = WpEntityRepository;
+exports.WpUserService = WpUserService;
 exports.newUuid = newUuid;
 //# sourceMappingURL=index.js.map