@punks/backend-entity-manager 0.0.94 → 0.0.95

package/dist/cjs/index.js

@@ -285,941 +285,550 @@ class EntitySerializer {
     }
 }
 
-const PLATFORM_EVENT_NAMESPACE = "platform";
-const PlatformEvents = {
-    Messaging: {
-        EmailSent: `${PLATFORM_EVENT_NAMESPACE}:messaging.emailSent`,
-    },
-};
-
-class NestEntityAuthorizationMiddleware {
+class EntitiesCountAction {
+    constructor(services) {
+        this.services = services;
+    }
+    async execute(filters) {
+        return await this.services.resolveCountQuery().execute(filters);
+    }
 }
 
-class NestEntityActions {
-    // todo: resolve entity name from decorator
-    constructor(entityName, registry) {
-        this.services = registry.resolveEntityServicesCollection(entityName);
+class EntityCreateAction {
+    constructor(services) {
+        this.services = services;
+        this.logger = backendCore.Log.getLogger(`${services.getEntityName()} -> Create`);
     }
-    get manager() {
-        if (!this.actionsInstance) {
-            this.actionsInstance =
-                this.services.resolveEntityActions();
-        }
-        return this.actionsInstance;
+    async execute(input) {
+        this.logger.debug("Create action started", { input });
+        const converter = this.services.resolveConverter();
+        const createInput = converter?.createDtoToEntity(input) ?? input;
+        const entity = await this.services
+            .resolveCreateCommand()
+            .execute(createInput);
+        const result = converter?.toEntityDto(entity) ?? entity;
+        this.logger.debug("Create action completed", { input, result });
+        return result;
     }
 }
 
-class NestEntityManager {
-    // todo: resolve entity name from decorator
-    constructor(entityName, registry) {
-        this.services = registry.resolveEntityServicesCollection(entityName);
+class EntityDeleteAction {
+    constructor(services) {
+        this.services = services;
+        this.logger = backendCore.Log.getLogger(`${services.getEntityName()} -> Delete`);
     }
-    get manager() {
-        if (!this.managerInstance) {
-            this.managerInstance =
-                this.services.resolveEntityManager();
-        }
-        return this.managerInstance;
+    async execute(id) {
+        this.logger.debug("Delete action started", { id });
+        await this.services.resolveDeleteCommand().execute(id);
+        this.logger.debug("Delete action completed", { id });
     }
 }
 
-class NestEntitySerializer extends EntitySerializer {
-    constructor(entityName, registry) {
-        super(entityName);
-        // this.services = registry.resolveEntityServicesCollection(entityName)
+class EntitiesDeleteAction {
+    constructor(services) {
+        this.services = services;
+        this.logger = backendCore.Log.getLogger(`${services.getEntityName()} -> DeleteItems`);
+    }
+    async execute(params) {
+        this.logger.debug("DeleteItems action started");
+        await this.services.resolveDeleteItemsCommand().execute(params);
+        this.logger.debug("DeleteItems action completed");
     }
 }
 
-const EntityManagerSymbols = {
-    AppInitializer: Symbol.for("WP:APP_INITIALIZER"),
-    EventsTracker: Symbol.for("WP:EVENTS_TRACKER"),
-    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"),
-    EntitySerializer: Symbol.for("WP:ENTITY_SERIALIZER"),
-    EntityManager: Symbol.for("WP:ENTITY_MANAGER"),
-    EntityQueryBuilder: Symbol.for("WP:ENTITY_QUERY_BUILDER"),
-    EntitySeeder: Symbol.for("WP:ENTITY_SEEDER"),
-    EmailProvider: Symbol.for("WP:EMAIL_PROVIDER"),
-    EmailTemplate: Symbol.for("WP:EMAIL_TEMPLATE"),
-    BucketProvider: Symbol.for("WP:BUCKET_PROVIDER"),
-    PipelineTemplate: Symbol.for("WP:PIPELINE_TEMPLATE"),
-};
-
-const WpEntityAuthMiddleware = (entityName, props = {}) => common.applyDecorators(common.Injectable(), common.SetMetadata(EntityManagerSymbols.EntityAuthMiddleware, {
-    entityName,
-    ...props,
-}));
-
-const WpBucketProvider = (providerId) => common.applyDecorators(common.Injectable(), common.SetMetadata(EntityManagerSymbols.BucketProvider, {
-    providerId,
-}));
-
-const WpEntityActions = (entityName, props = {}) => common.applyDecorators(common.Injectable(), common.SetMetadata(EntityManagerSymbols.EntityActions, {
-    entityName,
-    ...props,
-}));
-
-const WpEntityAdapter = (entityName, props = {}) => common.applyDecorators(common.Injectable(), common.SetMetadata(EntityManagerSymbols.EntityAdapter, {
-    entityName,
-    ...props,
-}));
-
-const WpEntityConnector = (entityName, props = {}) => common.applyDecorators(common.Injectable(), common.SetMetadata(EntityManagerSymbols.EntityConnector, {
-    entityName,
-    ...props,
-}));
-
-const WpEntityConverter = (entityName, props = {}) => common.applyDecorators(common.Injectable(), common.SetMetadata(EntityManagerSymbols.EntityConverter, {
-    entityName,
-    ...props,
-}));
+class EntityExistsAction {
+    constructor(services) {
+        this.services = services;
+    }
+    async execute(filters) {
+        return await this.services.resolveExistsQuery().execute(filters);
+    }
+}
 
-const WpEmailTemplate = (templateId) => common.applyDecorators(common.Injectable(), common.SetMetadata(EntityManagerSymbols.EmailTemplate, {
-    templateId,
-}));
-const WpEmailProvider = (providerId) => common.applyDecorators(common.Injectable(), common.SetMetadata(EntityManagerSymbols.EmailProvider, {
-    providerId,
-}));
+class EntitiesExportAction {
+    constructor(services) {
+        this.services = services;
+        this.logger = backendCore.Log.getLogger(`${services.getEntityName()} -> Export`);
+    }
+    async execute(input) {
+        this.logger.debug("Export action started", { input });
+        const result = await this.services.resolveExportCommand().execute(input);
+        this.logger.debug("Export action completed", { input });
+        return result;
+    }
+}
 
-const WpEntity = (name, props = {}) => common.applyDecorators(common.SetMetadata(EntityManagerSymbols.Entity, {
-    name,
-    ...props,
-}));
+class EntityGetAction {
+    constructor(services) {
+        this.services = services;
+    }
+    async execute(id) {
+        const entity = await this.services.resolveGetQuery().execute(id);
+        const converter = this.services.resolveConverter();
+        return entity
+            ? converter?.toEntityDto(entity) ?? entity
+            : undefined;
+    }
+}
 
-const WpAppInitializer = (props = {}) => common.applyDecorators(common.Injectable(), common.SetMetadata(EntityManagerSymbols.AppInitializer, props));
+class EntitiesImportAction {
+    constructor(services) {
+        this.services = services;
+        this.logger = backendCore.Log.getLogger(`${services.getEntityName()} -> Import`);
+    }
+    async execute(input) {
+        this.logger.debug("Import action started", { input });
+        const result = await this.services.resolveImportCommand().execute(input);
+        this.logger.debug("Import action completed", { input });
+        return result;
+    }
+}
 
-const WpEntityRepository = (entityName, props = {}) => common.applyDecorators(common.Injectable(), common.SetMetadata(EntityManagerSymbols.EntityRepository, {
-    entityName,
-    ...props,
-}));
+class EntitiesSampleDownloadAction {
+    constructor(services) {
+        this.services = services;
+        this.logger = backendCore.Log.getLogger(`${services.getEntityName()} -> Import`);
+    }
+    async execute(input) {
+        this.logger.debug("Sample download action started", { input });
+        const result = await this.services
+            .resolveSampleDownloadCommand()
+            .execute(input);
+        this.logger.debug("Sample download action completed", { input });
+        return result;
+    }
+}
 
-const WpEntityManager = (entityName, props = {}) => common.applyDecorators(common.Injectable(), common.SetMetadata(EntityManagerSymbols.EntityManager, {
-    entityName,
-    ...props,
-}));
+class EntitiesSearchAction {
+    constructor(services) {
+        this.services = services;
+    }
+    async execute(request) {
+        const results = await this.services
+            .resolveSearchQuery()
+            .execute(request);
+        const converter = this.services.resolveConverter();
+        return {
+            facets: results.facets,
+            paging: results.paging,
+            request: results.request,
+            items: results.items.map((x) => (converter?.toListItemDto(x) ?? x)),
+        };
+    }
+}
 
-const WpEntityQueryBuilder = (entityName, props = {}) => common.applyDecorators(common.Injectable(), common.SetMetadata(EntityManagerSymbols.EntityQueryBuilder, {
-    entityName,
-    ...props,
-}));
+class EntityUpdateAction {
+    constructor(services) {
+        this.services = services;
+        this.logger = backendCore.Log.getLogger(`${services.getEntityName()} -> Update`);
+    }
+    async execute(id, input) {
+        this.logger.debug("Update action started", { id, input });
+        const converter = this.services.resolveConverter();
+        const updateInput = converter?.updateDtoToEntity(input) ?? input;
+        const entity = await this.services
+            .resolveUpdateCommand()
+            .execute(id, updateInput);
+        const result = converter?.toEntityDto(entity) ?? entity;
+        this.logger.debug("Update action started", { id, input, result });
+        return result;
+    }
+}
 
-const WpPipeline = (name, props = {}) => common.applyDecorators(common.Injectable(), common.SetMetadata(EntityManagerSymbols.PipelineTemplate, {
-    name,
-    ...props,
-}));
+class EntityUpsertAction {
+    constructor(services) {
+        this.services = services;
+        this.logger = backendCore.Log.getLogger(`${services.getEntityName()} -> Upsert`);
+    }
+    async execute(id, input) {
+        this.logger.debug("Upsert action started", { id, input });
+        const converter = this.services.resolveConverter();
+        const updateInput = converter?.updateDtoToEntity(input) ?? input;
+        const entity = await this.services
+            .resolveUpsertCommand()
+            .execute(id, updateInput);
+        const result = converter?.toEntityDto(entity) ?? entity;
+        this.logger.debug("Upsert action started", { id, input, result });
+        return result;
+    }
+}
 
-const WpEntitySeeder = (entityName, props = {}) => common.applyDecorators(common.Injectable(), common.SetMetadata(EntityManagerSymbols.EntitySeeder, {
-    entityName,
-    ...props,
-}));
-
-const WpEntitySerializer = (entityName, props = {}) => common.applyDecorators(common.Injectable(), common.SetMetadata(EntityManagerSymbols.EntitySerializer, {
-    entityName,
-    ...props,
-}));
-
-const WpEventsTracker = (props = {}) => common.applyDecorators(common.Injectable(), common.SetMetadata(EntityManagerSymbols.EventsTracker, {
-    ...props,
-}));
-
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-function __decorate(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-
-function __metadata(metadataKey, metadataValue) {
-  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-  var e = new Error(message);
-  return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
-class NumericFacetItem {
-}
-__decorate([
-    swagger.ApiProperty(),
-    __metadata("design:type", Number)
-], NumericFacetItem.prototype, "value", void 0);
-__decorate([
-    swagger.ApiProperty({ required: false }),
-    __metadata("design:type", String)
-], NumericFacetItem.prototype, "name", void 0);
-__decorate([
-    swagger.ApiProperty({ required: false }),
-    __metadata("design:type", Number)
-], NumericFacetItem.prototype, "count", void 0);
-class NumericFacet {
-}
-__decorate([
-    swagger.ApiProperty({ type: [NumericFacetItem] }),
-    __metadata("design:type", Array)
-], NumericFacet.prototype, "items", void 0);
-class BooleanFacetItem {
-}
-__decorate([
-    swagger.ApiProperty(),
-    __metadata("design:type", Boolean)
-], BooleanFacetItem.prototype, "value", void 0);
-__decorate([
-    swagger.ApiProperty({ required: false }),
-    __metadata("design:type", String)
-], BooleanFacetItem.prototype, "name", void 0);
-__decorate([
-    swagger.ApiProperty({ required: false }),
-    __metadata("design:type", Number)
-], BooleanFacetItem.prototype, "count", void 0);
-class BooleanFacet {
-}
-__decorate([
-    swagger.ApiProperty({ type: [BooleanFacetItem] }),
-    __metadata("design:type", Array)
-], BooleanFacet.prototype, "items", void 0);
-class StringFacetItem {
-}
-__decorate([
-    swagger.ApiProperty(),
-    __metadata("design:type", String)
-], StringFacetItem.prototype, "value", void 0);
-__decorate([
-    swagger.ApiProperty({ required: false }),
-    __metadata("design:type", String)
-], StringFacetItem.prototype, "name", void 0);
-__decorate([
-    swagger.ApiProperty({ required: false }),
-    __metadata("design:type", Number)
-], StringFacetItem.prototype, "count", void 0);
-class StringFacet {
-}
-__decorate([
-    swagger.ApiProperty({ type: [StringFacetItem] }),
-    __metadata("design:type", Array)
-], StringFacet.prototype, "items", void 0);
-
-const AuthenticationExtensionSymbols = {
-    UserService: Symbol.for("WP.EXT:AUTHENTICATION.USER_SERVICE"),
-    RolesService: Symbol.for("WP.EXT:AUTHENTICATION.ROLES_SERVICE"),
-    UserRolesService: Symbol.for("WP.EXT:AUTHENTICATION.USER_ROLES_SERVICE"),
-};
-const AuthenticationGuardsSymbols = {
-    Authenticated: "guard:authenticated",
-    Public: "guard:public",
-    Roles: "guard:roles",
-    MemberOf: "guard:memberOf",
-};
-
-const Public = () => common.SetMetadata(AuthenticationGuardsSymbols.Public, true);
-const Authenticated = () => common.SetMetadata(AuthenticationGuardsSymbols.Authenticated, true);
-const Roles = (...roles) => common.SetMetadata(AuthenticationGuardsSymbols.Roles, roles);
-const MemberOf = (...groups) => common.SetMetadata(AuthenticationGuardsSymbols.MemberOf, groups);
-const buildRolesGuard = ({ mainRole, inheritedRoles, }, options) => Roles(mainRole.uid, ...(options?.inheritRoles && inheritedRoles
-    ? inheritedRoles.map((role) => role.uid)
-    : []));
-
-const WpRolesService = () => common.applyDecorators(common.Injectable(), common.SetMetadata(AuthenticationExtensionSymbols.RolesService, true));
-
-const WpUserService = () => common.applyDecorators(common.Injectable(), common.SetMetadata(AuthenticationExtensionSymbols.UserService, true));
-
-const WpUserRolesService = () => common.applyDecorators(common.Injectable(), common.SetMetadata(AuthenticationExtensionSymbols.UserRolesService, true));
-
-const AuthenticationEmailTemplates = {
-    Registration: "registration",
-    PasswordReset: "passwordReset",
-    EmailVerify: "emailVerify",
-};
-
-class AuthenticationError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "AuthenticationError";
+class EntityCreateCommand {
+    constructor(services) {
+        this.services = services;
     }
-}
-class InvalidCredentialsError extends AuthenticationError {
-    constructor(message) {
-        super(message);
-        this.name = "InvalidCredentialsError";
+    async execute(input) {
+        var entity = this.adaptEntity(input);
+        await this.authorize(entity);
+        var createdItem = await this.services.resolveRepository().create(entity);
+        await this.services
+            .resolveEventsManager()
+            .processEntityCreatedEvent(createdItem);
+        return createdItem;
     }
-}
-class OperationTokenMismatchError extends AuthenticationError {
-    constructor(message) {
-        super(message);
-        this.name = "OperationTokenMismatchError";
+    adaptEntity(input) {
+        const adapter = this.services.resolveAdapter();
+        return adapter
+            ? adapter.createDataToEntity(input)
+            : input;
+    }
+    async authorize(entity) {
+        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.canCreate(entity, context);
+        if (!authorizationResult.isAuthorized)
+            throw new EntityOperationUnauthorizedException(exports.EntityOperationType.Create, this.services.getEntityName(), entity);
     }
 }
 
-const AUTHENTICATION_EVENTS_NAMESPACE = "authentication";
-const AuthenticationEvents = {
-    UserLogin: `${AUTHENTICATION_EVENTS_NAMESPACE}:user.login`,
-    UserRegistrationStarted: `${AUTHENTICATION_EVENTS_NAMESPACE}:user.registrationStarted`,
-    UserRegistrationCompleted: `${AUTHENTICATION_EVENTS_NAMESPACE}:user.registrationCompleted`,
-    UserPasswordResetStarted: `${AUTHENTICATION_EVENTS_NAMESPACE}:user.passwordResetStarted`,
-    UserPasswordResetCompleted: `${AUTHENTICATION_EVENTS_NAMESPACE}:user.passwordResetCompleted`,
-};
-
-exports.AuthGuard = class AuthGuard {
-    constructor(reflector) {
-        this.reflector = reflector;
+class EntityDeleteCommand {
+    constructor(services) {
+        this.services = services;
     }
-    canActivate(context) {
-        const isPublic = this.getIsPublic(context);
-        if (isPublic) {
-            return true;
+    async execute(id) {
+        if (backendCore.isNullOrUndefined(id)) {
+            throw new MissingEntityIdError();
         }
-        const auth = this.getCurrentAuth(context);
-        const allowedRoles = this.getAllowedRoles(context);
-        if (allowedRoles) {
-            return this.isRoleMatching(allowedRoles, auth?.roles ?? []);
+        await this.authorize(id);
+        await this.services.resolveRepository().delete(id);
+        await this.services.resolveEventsManager().processEntityDeletedEvent(id);
+    }
+    async authorize(id) {
+        const authorization = this.services.resolveAuthorizationMiddleware();
+        if (!authorization) {
+            return;
         }
-        const isForAllAuthenticated = this.getIsForAllAuthenticated(context);
-        if (isForAllAuthenticated) {
-            return !!auth?.user;
+        const entity = await this.services.resolveRepository().get(id);
+        if (entity == null) {
+            throw new EntityNotFoundException(id);
         }
-        return false;
+        const contextService = this.services.resolveAuthenticationContextProvider();
+        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);
     }
-    isRoleMatching(allowedRoles, userRoles) {
-        return userRoles.some((role) => allowedRoles.includes(role.uid));
+}
+
+class EntitiesDeleteCommand {
+    constructor(services) {
+        this.services = services;
     }
-    getIsForAllAuthenticated(context) {
-        return this.getMetadata(AuthenticationGuardsSymbols.Authenticated, context);
+    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;
     }
-    getIsPublic(context) {
-        return this.getMetadata(AuthenticationGuardsSymbols.Public, context);
+    async getContext() {
+        const authorization = this.services.resolveAuthorizationMiddleware();
+        if (!authorization) {
+            return undefined;
+        }
+        const contextService = this.services.resolveAuthenticationContextProvider();
+        return await contextService.getContext();
     }
-    getAllowedRoles(context) {
-        return this.getMetadata(AuthenticationGuardsSymbols.Roles, context);
-    }
-    getCurrentAuth(context) {
-        const request = context.switchToHttp()?.getRequest();
-        return request?.auth?.user
-            ? {
-                user: request.auth.user,
-                roles: request.auth.roles,
-            }
-            : undefined;
-    }
-    getMetadata(symbol, context) {
-        return this.reflector.getAllAndOverride(symbol, [
-            context.getHandler(),
-            context.getClass(),
-        ]);
+    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());
     }
-};
-exports.AuthGuard = __decorate([
-    common.Injectable(),
-    __metadata("design:paramtypes", [core.Reflector])
-], exports.AuthGuard);
-
-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) {
-        return this.getSession().get(key);
-    }
-    setValue(key, value) {
-        this.getSession().set(key, value);
-    }
-    clearValue(key) {
-        this.getSession().set(key, undefined);
+const createDayPath = (d) => `${d.getFullYear()}/${(d.getMonth() + 1).toString().padStart(2, "0")}/${d
+    .getDate()
+    .toString()
+    .padStart(2, "0")}`;
+class EntitiesExportCommand {
+    constructor(services, settings) {
+        this.services = services;
+        this.settings = settings;
     }
-    getRequest() {
-        return this.getSession().request;
+    async execute(input) {
+        const exportEntities = await this.getExportEntities(input.filter);
+        const outputFile = await this.buildExportFile(exportEntities.items, input.options.format);
+        const downloadUrl = await this.uploadExportFile(outputFile);
+        return {
+            downloadUrl,
+            file: {
+                content: outputFile.content,
+                contentType: outputFile.contentType,
+                name: outputFile.fileName,
+            },
+        };
     }
-    getSession() {
-        const store = sessionStorage.getStore();
-        if (!store) {
-            throw new Error("No active context found");
-        }
-        return store;
+    async buildExportFile(data, format) {
+        return await this.services.resolveSerializer().serialize(data, format);
     }
-};
-exports.AppSessionService = __decorate([
-    common.Injectable()
-], exports.AppSessionService);
-
-exports.AppHashingService = class AppHashingService {
-    async hash(value, salt) {
-        return await bcrypt.hash(value, salt);
+    async uploadExportFile(file) {
+        await this.bucket.fileUpload({
+            bucket: this.settings.exportBucket.bucket,
+            filePath: this.buildAbsoluteBucketPath(file.fileName),
+            content: file.content,
+            contentType: file.contentType,
+        });
+        return await this.bucket.filePublicUrlCreate({
+            bucket: this.settings.exportBucket.bucket,
+            expirationMinutes: this.settings.exportBucket.publicLinksExpirationMinutes,
+            filePath: this.buildAbsoluteBucketPath(file.fileName),
+        });
     }
-    async compare(hash, value, salt) {
-        return (await this.hash(value, salt)) === hash;
+    buildAbsoluteBucketPath(relativePath) {
+        return `${this.settings.exportBucket.rootFolderPath ?? ""}/exports/${createDayPath(new Date())}/${relativePath}`;
     }
-};
-exports.AppHashingService = __decorate([
-    common.Injectable()
-], exports.AppHashingService);
-
-class EntitiesCountAction {
-    constructor(services) {
-        this.services = services;
+    async getExportEntities(filters) {
+        return this.services.resolveSearchQuery().execute(filters ?? {});
     }
-    async execute(filters) {
-        return await this.services.resolveCountQuery().execute(filters);
+    get bucket() {
+        return this.services.getRootServices().resolveBucketProvider();
     }
 }
 
-class EntityCreateAction {
-    constructor(services) {
+class EntitiesImportCommand {
+    constructor(services, settings) {
         this.services = services;
-        this.logger = backendCore.Log.getLogger(`${services.getEntityName()} -> Create`);
+        this.settings = settings;
     }
     async execute(input) {
-        this.logger.debug("Create action started", { input });
-        const converter = this.services.resolveConverter();
-        const createInput = converter?.createDtoToEntity(input) ?? input;
-        const entity = await this.services
-            .resolveCreateCommand()
-            .execute(createInput);
-        const result = converter?.toEntityDto(entity) ?? entity;
-        this.logger.debug("Create action completed", { input, result });
-        return result;
-    }
-}
-
-class EntityDeleteAction {
-    constructor(services) {
-        this.services = services;
-        this.logger = backendCore.Log.getLogger(`${services.getEntityName()} -> Delete`);
+        await this.uploadImportFile({
+            content: input.file.content,
+            contentType: input.file.contentType,
+            fileName: input.file.fileName,
+        });
+        const importEntities = await this.parseImportFile(input.file.content, input.format);
+        for (const entry of importEntities) {
+            await this.importEntity(entry);
+        }
+        return {
+            statistics: {
+                importedCount: importEntities.length,
+                createdCount: 0,
+                unchangedCount: 0,
+                updatedCount: 0,
+            },
+        };
     }
-    async execute(id) {
-        this.logger.debug("Delete action started", { id });
-        await this.services.resolveDeleteCommand().execute(id);
-        this.logger.debug("Delete action completed", { id });
+    async importEntity(entry) {
+        try {
+            if (!entry.id) {
+                return this.services.resolveCreateCommand().execute(entry.item);
+            }
+            return this.services.resolveUpsertCommand().execute(entry.id, entry.item);
+        }
+        catch (error) {
+            throw new Error(`Error importing entry with id ${entry.id}`);
+        }
     }
-}
-
-class EntitiesDeleteAction {
-    constructor(services) {
-        this.services = services;
-        this.logger = backendCore.Log.getLogger(`${services.getEntityName()} -> DeleteItems`);
+    async parseImportFile(content, format) {
+        return await this.services.resolveSerializer().parse(content, format);
     }
-    async execute(params) {
-        this.logger.debug("DeleteItems action started");
-        await this.services.resolveDeleteItemsCommand().execute(params);
-        this.logger.debug("DeleteItems action completed");
+    async uploadImportFile(file) {
+        await this.bucket.fileUpload({
+            bucket: this.settings.exportBucket.bucket,
+            filePath: this.buildAbsoluteBucketPath(file.fileName),
+            content: file.content,
+            contentType: file.contentType,
+        });
     }
-}
-
-class EntityExistsAction {
-    constructor(services) {
-        this.services = services;
+    buildAbsoluteBucketPath(relativePath) {
+        return `${this.settings.exportBucket.rootFolderPath ?? ""}/imports/${createDayPath(new Date())}/${relativePath}`;
     }
-    async execute(filters) {
-        return await this.services.resolveExistsQuery().execute(filters);
+    get bucket() {
+        return this.services.getRootServices().resolveBucketProvider();
     }
 }
 
-class EntitiesExportAction {
-    constructor(services) {
+class EntitiesSampleDownloadCommand {
+    constructor(services, settings) {
         this.services = services;
-        this.logger = backendCore.Log.getLogger(`${services.getEntityName()} -> Export`);
+        this.settings = settings;
     }
     async execute(input) {
-        this.logger.debug("Export action started", { input });
-        const result = await this.services.resolveExportCommand().execute(input);
-        this.logger.debug("Export action completed", { input });
-        return result;
+        const sample = await this.services
+            .resolveSerializer()
+            .createSample(input.format);
+        const downloadUrl = await this.uploadSampleFile(sample);
+        return {
+            file: {
+                content: sample.content,
+                contentType: sample.contentType,
+                name: sample.fileName,
+            },
+            downloadUrl,
+        };
     }
-}
-
-class EntityGetAction {
-    constructor(services) {
-        this.services = services;
+    async uploadSampleFile(file) {
+        await this.bucket.fileUpload({
+            bucket: this.settings.exportBucket.bucket,
+            filePath: this.buildAbsoluteBucketPath(file.fileName),
+            content: file.content,
+            contentType: file.contentType,
+        });
+        return await this.bucket.filePublicUrlCreate({
+            bucket: this.settings.exportBucket.bucket,
+            expirationMinutes: this.settings.exportBucket.publicLinksExpirationMinutes,
+            filePath: this.buildAbsoluteBucketPath(file.fileName),
+        });
     }
-    async execute(id) {
-        const entity = await this.services.resolveGetQuery().execute(id);
-        const converter = this.services.resolveConverter();
-        return entity
-            ? converter?.toEntityDto(entity) ?? entity
-            : undefined;
+    buildAbsoluteBucketPath(relativePath) {
+        return `${this.settings.exportBucket.rootFolderPath ?? ""}/samples/${createDayPath(new Date())}/${relativePath}`;
+    }
+    get bucket() {
+        return this.services.getRootServices().resolveBucketProvider();
     }
 }
 
-class EntitiesImportAction {
+class EntityUpdateCommand {
     constructor(services) {
         this.services = services;
-        this.logger = backendCore.Log.getLogger(`${services.getEntityName()} -> Import`);
-    }
-    async execute(input) {
-        this.logger.debug("Import action started", { input });
-        const result = await this.services.resolveImportCommand().execute(input);
-        this.logger.debug("Import action completed", { input });
-        return result;
-    }
-}
-
-class EntitiesSampleDownloadAction {
-    constructor(services) {
-        this.services = services;
-        this.logger = backendCore.Log.getLogger(`${services.getEntityName()} -> Import`);
-    }
-    async execute(input) {
-        this.logger.debug("Sample download action started", { input });
-        const result = await this.services
-            .resolveSampleDownloadCommand()
-            .execute(input);
-        this.logger.debug("Sample download action completed", { input });
-        return result;
-    }
-}
-
-class EntitiesSearchAction {
-    constructor(services) {
-        this.services = services;
-    }
-    async execute(request) {
-        const results = await this.services
-            .resolveSearchQuery()
-            .execute(request);
-        const converter = this.services.resolveConverter();
-        return {
-            facets: results.facets,
-            paging: results.paging,
-            request: results.request,
-            items: results.items.map((x) => (converter?.toListItemDto(x) ?? x)),
-        };
-    }
-}
-
-class EntityUpdateAction {
-    constructor(services) {
-        this.services = services;
-        this.logger = backendCore.Log.getLogger(`${services.getEntityName()} -> Update`);
-    }
-    async execute(id, input) {
-        this.logger.debug("Update action started", { id, input });
-        const converter = this.services.resolveConverter();
-        const updateInput = converter?.updateDtoToEntity(input) ?? input;
-        const entity = await this.services
-            .resolveUpdateCommand()
-            .execute(id, updateInput);
-        const result = converter?.toEntityDto(entity) ?? entity;
-        this.logger.debug("Update action started", { id, input, result });
-        return result;
-    }
-}
-
-class EntityUpsertAction {
-    constructor(services) {
-        this.services = services;
-        this.logger = backendCore.Log.getLogger(`${services.getEntityName()} -> Upsert`);
     }
     async execute(id, input) {
-        this.logger.debug("Upsert action started", { id, input });
-        const converter = this.services.resolveConverter();
-        const updateInput = converter?.updateDtoToEntity(input) ?? input;
-        const entity = await this.services
-            .resolveUpsertCommand()
-            .execute(id, updateInput);
-        const result = converter?.toEntityDto(entity) ?? entity;
-        this.logger.debug("Upsert action started", { id, input, result });
-        return result;
-    }
-}
-
-class EntityCreateCommand {
-    constructor(services) {
-        this.services = services;
-    }
-    async execute(input) {
-        var entity = this.adaptEntity(input);
-        await this.authorize(entity);
-        var createdItem = await this.services.resolveRepository().create(entity);
+        const entity = this.adaptEntity(input);
+        await this.authorize(id);
+        const updatedEntity = await this.services
+            .resolveRepository()
+            .update(id, entity);
         await this.services
             .resolveEventsManager()
-            .processEntityCreatedEvent(createdItem);
-        return createdItem;
+            .processEntityUpdatedEvent(updatedEntity);
+        return updatedEntity;
     }
     adaptEntity(input) {
         const adapter = this.services.resolveAdapter();
         return adapter
-            ? adapter.createDataToEntity(input)
+            ? adapter.updateDataToEntity(input)
             : input;
     }
-    async authorize(entity) {
+    async authorize(id) {
         const authorization = this.services.resolveAuthorizationMiddleware();
         if (!authorization) {
             return;
         }
+        const currentEntity = await this.services.resolveRepository().get(id);
+        if (currentEntity == null) {
+            throw new EntityNotFoundException();
+        }
         const contextService = this.services.resolveAuthenticationContextProvider();
         const context = await contextService?.getContext();
         if (!context) {
             return;
         }
-        const authorizationResult = await authorization.canCreate(entity, context);
+        const authorizationResult = await authorization.canUpdate(currentEntity, context);
         if (!authorizationResult.isAuthorized)
-            throw new EntityOperationUnauthorizedException(exports.EntityOperationType.Create, this.services.getEntityName(), entity);
+            throw new EntityOperationUnauthorizedException(exports.EntityOperationType.Create, this.services.getEntityName(), currentEntity);
     }
 }
 
-class EntityDeleteCommand {
+class EntityUpsertCommand {
     constructor(services) {
         this.services = services;
     }
-    async execute(id) {
-        if (backendCore.isNullOrUndefined(id)) {
-            throw new MissingEntityIdError();
-        }
-        await this.authorize(id);
-        await this.services.resolveRepository().delete(id);
-        await this.services.resolveEventsManager().processEntityDeletedEvent(id);
+    async execute(id, data) {
+        const entity = this.adaptEntity(data);
+        await this.authorize(id, entity);
+        const updatedEntity = await this.upsertEntity(id, entity);
+        await this.services
+            .resolveEventsManager()
+            .processEntityUpdatedEvent(updatedEntity);
+        return updatedEntity;
     }
-    async authorize(id) {
+    async upsertEntity(id, entity) {
+        return await this.services.resolveRepository().upsert(id, entity);
+    }
+    adaptEntity(input) {
+        const adapter = this.services.resolveAdapter();
+        return adapter
+            ? adapter.updateDataToEntity(input)
+            : input;
+    }
+    async authorize(id, entity) {
         const authorization = this.services.resolveAuthorizationMiddleware();
         if (!authorization) {
             return;
         }
-        const entity = await this.services.resolveRepository().get(id);
-        if (entity == null) {
-            throw new EntityNotFoundException(id);
-        }
+        const currentEntity = await this.services.resolveRepository().get(id);
         const contextService = this.services.resolveAuthenticationContextProvider();
         const context = await contextService?.getContext();
         if (!context) {
             return;
         }
-        const authorizationResult = await authorization.canDelete(entity, context);
+        if (currentEntity) {
+            const updateResult = await authorization.canUpdate(currentEntity, context);
+            if (!updateResult.isAuthorized)
+                throw new EntityOperationUnauthorizedException(exports.EntityOperationType.Update, this.services.getEntityName(), currentEntity);
+            return;
+        }
+        const authorizationResult = await authorization.canCreate(entity, context);
         if (!authorizationResult.isAuthorized)
-            throw new EntityOperationUnauthorizedException(exports.EntityOperationType.Delete, this.services.getEntityName(), entity);
+            throw new EntityOperationUnauthorizedException(exports.EntityOperationType.Create, this.services.getEntityName(), entity);
     }
 }
 
-class EntitiesDeleteCommand {
+class EntityManager {
     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;
+    get exists() {
+        return this.services.resolveExistsQuery();
     }
-    async getContext() {
-        const authorization = this.services.resolveAuthorizationMiddleware();
-        if (!authorization) {
-            return undefined;
-        }
-        const contextService = this.services.resolveAuthenticationContextProvider();
-        return await contextService.getContext();
+    get count() {
+        return this.services.resolveCountQuery();
     }
-    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());
+    get deleteItems() {
+        return this.services.resolveDeleteItemsCommand();
     }
-}
-
-const createDayPath = (d) => `${d.getFullYear()}/${(d.getMonth() + 1).toString().padStart(2, "0")}/${d
-    .getDate()
-    .toString()
-    .padStart(2, "0")}`;
-class EntitiesExportCommand {
-    constructor(services, settings) {
-        this.services = services;
-        this.settings = settings;
+    get get() {
+        return this.services.resolveGetQuery();
     }
-    async execute(input) {
-        const exportEntities = await this.getExportEntities(input.filter);
-        const outputFile = await this.buildExportFile(exportEntities.items, input.options.format);
-        const downloadUrl = await this.uploadExportFile(outputFile);
-        return {
-            downloadUrl,
-            file: {
-                content: outputFile.content,
-                contentType: outputFile.contentType,
-                name: outputFile.fileName,
-            },
-        };
+    get search() {
+        return this.services.resolveSearchQuery();
     }
-    async buildExportFile(data, format) {
-        return await this.services.resolveSerializer().serialize(data, format);
+    get create() {
+        return this.services.resolveCreateCommand();
     }
-    async uploadExportFile(file) {
-        await this.bucket.fileUpload({
-            bucket: this.settings.exportBucket.bucket,
-            filePath: this.buildAbsoluteBucketPath(file.fileName),
-            content: file.content,
-            contentType: file.contentType,
-        });
-        return await this.bucket.filePublicUrlCreate({
-            bucket: this.settings.exportBucket.bucket,
-            expirationMinutes: this.settings.exportBucket.publicLinksExpirationMinutes,
-            filePath: this.buildAbsoluteBucketPath(file.fileName),
-        });
+    get update() {
+        return this.services.resolveUpdateCommand();
     }
-    buildAbsoluteBucketPath(relativePath) {
-        return `${this.settings.exportBucket.rootFolderPath ?? ""}/exports/${createDayPath(new Date())}/${relativePath}`;
+    get upsert() {
+        return this.services.resolveUpsertCommand();
     }
-    async getExportEntities(filters) {
-        return this.services.resolveSearchQuery().execute(filters ?? {});
+    get delete() {
+        return this.services.resolveDeleteCommand();
     }
-    get bucket() {
-        return this.services.getRootServices().resolveBucketProvider();
+    get export() {
+        return this.services.resolveExportCommand();
+    }
+    get import() {
+        return this.services.resolveImportCommand();
+    }
+    get sampleDownload() {
+        return this.services.resolveSampleDownloadCommand();
     }
 }
-
-class EntitiesImportCommand {
-    constructor(services, settings) {
-        this.services = services;
-        this.settings = settings;
-    }
-    async execute(input) {
-        await this.uploadImportFile({
-            content: input.file.content,
-            contentType: input.file.contentType,
-            fileName: input.file.fileName,
-        });
-        const importEntities = await this.parseImportFile(input.file.content, input.format);
-        for (const entry of importEntities) {
-            await this.importEntity(entry);
-        }
-        return {
-            statistics: {
-                importedCount: importEntities.length,
-                createdCount: 0,
-                unchangedCount: 0,
-                updatedCount: 0,
-            },
-        };
-    }
-    async importEntity(entry) {
-        try {
-            if (!entry.id) {
-                return this.services.resolveCreateCommand().execute(entry.item);
-            }
-            return this.services.resolveUpsertCommand().execute(entry.id, entry.item);
-        }
-        catch (error) {
-            throw new Error(`Error importing entry with id ${entry.id}`);
-        }
-    }
-    async parseImportFile(content, format) {
-        return await this.services.resolveSerializer().parse(content, format);
-    }
-    async uploadImportFile(file) {
-        await this.bucket.fileUpload({
-            bucket: this.settings.exportBucket.bucket,
-            filePath: this.buildAbsoluteBucketPath(file.fileName),
-            content: file.content,
-            contentType: file.contentType,
-        });
-    }
-    buildAbsoluteBucketPath(relativePath) {
-        return `${this.settings.exportBucket.rootFolderPath ?? ""}/imports/${createDayPath(new Date())}/${relativePath}`;
-    }
-    get bucket() {
-        return this.services.getRootServices().resolveBucketProvider();
-    }
-}
-
-class EntitiesSampleDownloadCommand {
-    constructor(services, settings) {
-        this.services = services;
-        this.settings = settings;
-    }
-    async execute(input) {
-        const sample = await this.services
-            .resolveSerializer()
-            .createSample(input.format);
-        const downloadUrl = await this.uploadSampleFile(sample);
-        return {
-            file: {
-                content: sample.content,
-                contentType: sample.contentType,
-                name: sample.fileName,
-            },
-            downloadUrl,
-        };
-    }
-    async uploadSampleFile(file) {
-        await this.bucket.fileUpload({
-            bucket: this.settings.exportBucket.bucket,
-            filePath: this.buildAbsoluteBucketPath(file.fileName),
-            content: file.content,
-            contentType: file.contentType,
-        });
-        return await this.bucket.filePublicUrlCreate({
-            bucket: this.settings.exportBucket.bucket,
-            expirationMinutes: this.settings.exportBucket.publicLinksExpirationMinutes,
-            filePath: this.buildAbsoluteBucketPath(file.fileName),
-        });
-    }
-    buildAbsoluteBucketPath(relativePath) {
-        return `${this.settings.exportBucket.rootFolderPath ?? ""}/samples/${createDayPath(new Date())}/${relativePath}`;
-    }
-    get bucket() {
-        return this.services.getRootServices().resolveBucketProvider();
-    }
-}
-
-class EntityUpdateCommand {
-    constructor(services) {
-        this.services = services;
-    }
-    async execute(id, input) {
-        const entity = this.adaptEntity(input);
-        await this.authorize(id);
-        const updatedEntity = await this.services
-            .resolveRepository()
-            .update(id, entity);
-        await this.services
-            .resolveEventsManager()
-            .processEntityUpdatedEvent(updatedEntity);
-        return updatedEntity;
-    }
-    adaptEntity(input) {
-        const adapter = this.services.resolveAdapter();
-        return adapter
-            ? adapter.updateDataToEntity(input)
-            : input;
-    }
-    async authorize(id) {
-        const authorization = this.services.resolveAuthorizationMiddleware();
-        if (!authorization) {
-            return;
-        }
-        const currentEntity = await this.services.resolveRepository().get(id);
-        if (currentEntity == null) {
-            throw new EntityNotFoundException();
-        }
-        const contextService = this.services.resolveAuthenticationContextProvider();
-        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);
-    }
-}
-
-class EntityUpsertCommand {
-    constructor(services) {
-        this.services = services;
-    }
-    async execute(id, data) {
-        const entity = this.adaptEntity(data);
-        await this.authorize(id, entity);
-        const updatedEntity = await this.upsertEntity(id, entity);
-        await this.services
-            .resolveEventsManager()
-            .processEntityUpdatedEvent(updatedEntity);
-        return updatedEntity;
-    }
-    async upsertEntity(id, entity) {
-        return await this.services.resolveRepository().upsert(id, entity);
-    }
-    adaptEntity(input) {
-        const adapter = this.services.resolveAdapter();
-        return adapter
-            ? adapter.updateDataToEntity(input)
-            : input;
-    }
-    async authorize(id, entity) {
-        const authorization = this.services.resolveAuthorizationMiddleware();
-        if (!authorization) {
-            return;
-        }
-        const currentEntity = await this.services.resolveRepository().get(id);
-        const contextService = this.services.resolveAuthenticationContextProvider();
-        const context = await contextService?.getContext();
-        if (!context) {
-            return;
-        }
-        if (currentEntity) {
-            const updateResult = await authorization.canUpdate(currentEntity, context);
-            if (!updateResult.isAuthorized)
-                throw new EntityOperationUnauthorizedException(exports.EntityOperationType.Update, this.services.getEntityName(), currentEntity);
-            return;
-        }
-        const authorizationResult = await authorization.canCreate(entity, context);
-        if (!authorizationResult.isAuthorized)
-            throw new EntityOperationUnauthorizedException(exports.EntityOperationType.Create, this.services.getEntityName(), entity);
-    }
-}
-
-class EntityManager {
-    constructor(services) {
-        this.services = services;
-    }
-    get exists() {
-        return this.services.resolveExistsQuery();
-    }
-    get count() {
-        return this.services.resolveCountQuery();
-    }
-    get deleteItems() {
-        return this.services.resolveDeleteItemsCommand();
-    }
-    get get() {
-        return this.services.resolveGetQuery();
-    }
-    get search() {
-        return this.services.resolveSearchQuery();
-    }
-    get create() {
-        return this.services.resolveCreateCommand();
-    }
-    get update() {
-        return this.services.resolveUpdateCommand();
-    }
-    get upsert() {
-        return this.services.resolveUpsertCommand();
-    }
-    get delete() {
-        return this.services.resolveDeleteCommand();
-    }
-    get export() {
-        return this.services.resolveExportCommand();
-    }
-    get import() {
-        return this.services.resolveImportCommand();
-    }
-    get sampleDownload() {
-        return this.services.resolveSampleDownloadCommand();
-    }
-}
-class EntityActions {
-    constructor(services) {
+class EntityActions {
+    constructor(services) {
         this.services = services;
     }
     get exists() {
@@ -2146,139 +1755,539 @@ class ReplicasConfiguration {
     }
 }
 
-class EntityManagerServiceRoot {
-    constructor() {
-        this.services = new ServiceLocator();
-    }
-    get locator() {
-        return this.services;
-    }
-    getEntitiesServicesLocator() {
-        return new EntitiesServiceLocator(this.services);
-    }
-    getEntityServicesLocator(entityName) {
-        return new EntityServiceLocator(this.getEntitiesServicesLocator(), entityName);
-    }
-    addAuthentication({ provider }) {
-        this.getEntitiesServicesLocator().registerAuthenticationContextProvider(provider);
-    }
-    registerEntity(entityName, repository) {
-        const collection = new EntityManagerServiceCollection(entityName, this.getEntitiesServicesLocator());
-        const services = this.getEntityServicesLocator(entityName);
-        collection.locator.registerEntityManager(entityName, new EntityManager(services));
-        collection.locator.registerEntityActions(entityName, new EntityActions(services));
-        collection.locator.registerRepository(entityName, repository);
-        const replicaManager = new EntityReplicaManager(services);
-        collection.locator.registerReplicaSyncManager(entityName, replicaManager);
-        collection.locator.registerReplicaDeleteManager(entityName, replicaManager);
-        collection.locator.registerReplicaConfiguration(entityName, new ReplicasConfiguration());
-        const connectorsManager = new EntityConnectorsManager(services);
-        collection.locator.registerConnectorSyncManager(entityName, connectorsManager);
-        collection.locator.registerConnectorDeleteManager(entityName, connectorsManager);
-        collection.locator.registerConnectorsConfiguration(entityName, new ConnectorsConfiguration());
-        collection.locator.registerEventsManager(entityName, new EntityEventsManager(entityName, services));
-        return collection;
+class EntityManagerServiceRoot {
+    constructor() {
+        this.services = new ServiceLocator();
+    }
+    get locator() {
+        return this.services;
+    }
+    getEntitiesServicesLocator() {
+        return new EntitiesServiceLocator(this.services);
+    }
+    getEntityServicesLocator(entityName) {
+        return new EntityServiceLocator(this.getEntitiesServicesLocator(), entityName);
+    }
+    addAuthentication({ provider }) {
+        this.getEntitiesServicesLocator().registerAuthenticationContextProvider(provider);
+    }
+    registerEntity(entityName, repository) {
+        const collection = new EntityManagerServiceCollection(entityName, this.getEntitiesServicesLocator());
+        const services = this.getEntityServicesLocator(entityName);
+        collection.locator.registerEntityManager(entityName, new EntityManager(services));
+        collection.locator.registerEntityActions(entityName, new EntityActions(services));
+        collection.locator.registerRepository(entityName, repository);
+        const replicaManager = new EntityReplicaManager(services);
+        collection.locator.registerReplicaSyncManager(entityName, replicaManager);
+        collection.locator.registerReplicaDeleteManager(entityName, replicaManager);
+        collection.locator.registerReplicaConfiguration(entityName, new ReplicasConfiguration());
+        const connectorsManager = new EntityConnectorsManager(services);
+        collection.locator.registerConnectorSyncManager(entityName, connectorsManager);
+        collection.locator.registerConnectorDeleteManager(entityName, connectorsManager);
+        collection.locator.registerConnectorsConfiguration(entityName, new ConnectorsConfiguration());
+        collection.locator.registerEventsManager(entityName, new EntityEventsManager(entityName, services));
+        return collection;
+    }
+}
+class EntityManagerServiceCollection {
+    constructor(entityName, locator) {
+        this.entityName = entityName;
+        this.locator = locator;
+        this.replicas = new ReplicasConfiguration();
+        this.connectors = new ConnectorsConfiguration();
+        this.resolver = new EntityServiceLocator(locator, entityName);
+    }
+    getServiceLocator() {
+        return this.resolver;
+    }
+    mapCrudOperations({ queryBuilder, settings, }) {
+        this.mapGet();
+        this.mapCount();
+        this.mapExists();
+        this.mapSearch({
+            queryBuilder,
+        });
+        this.mapCreate();
+        this.mapUpdate();
+        this.mapDelete();
+        this.mapImportExport(settings.importExport);
+        return this;
+    }
+    mapGet() {
+        this.locator.registerGetQuery(this.entityName, new EntityGetQuery(this.resolver));
+        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));
+        this.locator.registerQueryBuilder(this.entityName, queryBuilder);
+        return this;
+    }
+    mapCreate() {
+        this.locator.registerCreateCommand(this.entityName, new EntityCreateCommand(this.resolver));
+        this.locator.registerCreateAction(this.entityName, new EntityCreateAction(this.resolver));
+        return this;
+    }
+    mapImportExport(settings) {
+        this.locator.registerExportCommand(this.entityName, new EntitiesExportCommand(this.resolver, settings));
+        this.locator.registerExportAction(this.entityName, new EntitiesExportAction(this.resolver));
+        this.locator.registerImportCommand(this.entityName, new EntitiesImportCommand(this.resolver, settings));
+        this.locator.registerImportAction(this.entityName, new EntitiesImportAction(this.resolver));
+        this.locator.registerSampleDownloadCommand(this.entityName, new EntitiesSampleDownloadCommand(this.resolver, settings));
+        this.locator.registerSampleDownloadAction(this.entityName, new EntitiesSampleDownloadAction(this.resolver));
+        return this;
+    }
+    mapUpdate() {
+        this.locator.registerUpsertCommand(this.entityName, new EntityUpsertCommand(this.resolver));
+        this.locator.registerUpsertAction(this.entityName, new EntityUpsertAction(this.resolver));
+        this.locator.registerUpdateCommand(this.entityName, new EntityUpdateCommand(this.resolver));
+        this.locator.registerUpdateAction(this.entityName, new EntityUpdateAction(this.resolver));
+        return this;
+    }
+    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.registerDeleteItemsAction(this.entityName, new EntitiesDeleteAction(this.resolver));
+        return this;
+    }
+    addAdapter(adapter) {
+        this.locator.registerAdapter(this.entityName, adapter);
+        return this;
+    }
+    addSerializer(serializer) {
+        this.locator.registerSerializer(this.entityName, serializer);
+        return this;
+    }
+    addConverter(converter) {
+        this.locator.registerConverter(this.entityName, converter);
+        return this;
+    }
+    addAuthorization({ middleware, }) {
+        this.locator.registerAuthorizationMiddleware(this.entityName, middleware);
+        return this;
+    }
+    withReplica({ name, options, repository, }) {
+        this.replicas.configureReplica(name, options, repository);
+        return this;
+    }
+    withSynchronization({ name, options, connector, mapper, }) {
+        this.connectors.configureConnector(name, options, connector, mapper);
+        return this;
+    }
+}
+const createContainer = () => new EntityManagerServiceRoot();
+
+const toEntitiesImportInput = (request) => ({
+    format: request.format,
+    file: {
+        content: request.file.buffer,
+        contentType: request.file.mimetype,
+        fileName: request.file.originalname,
+    },
+});
+
+const PLATFORM_EVENT_NAMESPACE = "platform";
+const PlatformEvents = {
+    Messaging: {
+        EmailSent: `${PLATFORM_EVENT_NAMESPACE}:messaging.emailSent`,
+    },
+};
+
+class NestEntityAuthorizationMiddleware {
+}
+
+class NestEntityActions {
+    // todo: resolve entity name from decorator
+    constructor(entityName, registry) {
+        this.services = registry.resolveEntityServicesCollection(entityName);
+    }
+    get manager() {
+        if (!this.actionsInstance) {
+            this.actionsInstance =
+                this.services.resolveEntityActions();
+        }
+        return this.actionsInstance;
+    }
+}
+
+class NestEntityManager {
+    // todo: resolve entity name from decorator
+    constructor(entityName, registry) {
+        this.services = registry.resolveEntityServicesCollection(entityName);
+    }
+    get manager() {
+        if (!this.managerInstance) {
+            this.managerInstance =
+                this.services.resolveEntityManager();
+        }
+        return this.managerInstance;
+    }
+}
+
+class NestEntitySerializer extends EntitySerializer {
+    constructor(entityName, registry) {
+        super(entityName);
+        // this.services = registry.resolveEntityServicesCollection(entityName)
+    }
+}
+
+const EntityManagerSymbols = {
+    AppInitializer: Symbol.for("WP:APP_INITIALIZER"),
+    EventsTracker: Symbol.for("WP:EVENTS_TRACKER"),
+    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"),
+    EntitySerializer: Symbol.for("WP:ENTITY_SERIALIZER"),
+    EntityManager: Symbol.for("WP:ENTITY_MANAGER"),
+    EntityQueryBuilder: Symbol.for("WP:ENTITY_QUERY_BUILDER"),
+    EntitySeeder: Symbol.for("WP:ENTITY_SEEDER"),
+    EmailProvider: Symbol.for("WP:EMAIL_PROVIDER"),
+    EmailTemplate: Symbol.for("WP:EMAIL_TEMPLATE"),
+    BucketProvider: Symbol.for("WP:BUCKET_PROVIDER"),
+    PipelineTemplate: Symbol.for("WP:PIPELINE_TEMPLATE"),
+};
+
+const WpEntityAuthMiddleware = (entityName, props = {}) => common.applyDecorators(common.Injectable(), common.SetMetadata(EntityManagerSymbols.EntityAuthMiddleware, {
+    entityName,
+    ...props,
+}));
+
+const WpBucketProvider = (providerId) => common.applyDecorators(common.Injectable(), common.SetMetadata(EntityManagerSymbols.BucketProvider, {
+    providerId,
+}));
+
+const WpEntityActions = (entityName, props = {}) => common.applyDecorators(common.Injectable(), common.SetMetadata(EntityManagerSymbols.EntityActions, {
+    entityName,
+    ...props,
+}));
+
+const WpEntityAdapter = (entityName, props = {}) => common.applyDecorators(common.Injectable(), common.SetMetadata(EntityManagerSymbols.EntityAdapter, {
+    entityName,
+    ...props,
+}));
+
+const WpEntityConnector = (entityName, props = {}) => common.applyDecorators(common.Injectable(), common.SetMetadata(EntityManagerSymbols.EntityConnector, {
+    entityName,
+    ...props,
+}));
+
+const WpEntityConverter = (entityName, props = {}) => common.applyDecorators(common.Injectable(), common.SetMetadata(EntityManagerSymbols.EntityConverter, {
+    entityName,
+    ...props,
+}));
+
+const WpEmailTemplate = (templateId) => common.applyDecorators(common.Injectable(), common.SetMetadata(EntityManagerSymbols.EmailTemplate, {
+    templateId,
+}));
+const WpEmailProvider = (providerId) => common.applyDecorators(common.Injectable(), common.SetMetadata(EntityManagerSymbols.EmailProvider, {
+    providerId,
+}));
+
+const WpEntity = (name, props = {}) => common.applyDecorators(common.SetMetadata(EntityManagerSymbols.Entity, {
+    name,
+    ...props,
+}));
+
+const WpAppInitializer = (props = {}) => common.applyDecorators(common.Injectable(), common.SetMetadata(EntityManagerSymbols.AppInitializer, props));
+
+const WpEntityRepository = (entityName, props = {}) => common.applyDecorators(common.Injectable(), common.SetMetadata(EntityManagerSymbols.EntityRepository, {
+    entityName,
+    ...props,
+}));
+
+const WpEntityManager = (entityName, props = {}) => common.applyDecorators(common.Injectable(), common.SetMetadata(EntityManagerSymbols.EntityManager, {
+    entityName,
+    ...props,
+}));
+
+const WpEntityQueryBuilder = (entityName, props = {}) => common.applyDecorators(common.Injectable(), common.SetMetadata(EntityManagerSymbols.EntityQueryBuilder, {
+    entityName,
+    ...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,
+}));
+
+const WpEntitySerializer = (entityName, props = {}) => common.applyDecorators(common.Injectable(), common.SetMetadata(EntityManagerSymbols.EntitySerializer, {
+    entityName,
+    ...props,
+}));
+
+const WpEventsTracker = (props = {}) => common.applyDecorators(common.Injectable(), common.SetMetadata(EntityManagerSymbols.EventsTracker, {
+    ...props,
+}));
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+function __metadata(metadataKey, metadataValue) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+  var e = new Error(message);
+  return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+class NumericFacetItem {
+}
+__decorate([
+    swagger.ApiProperty(),
+    __metadata("design:type", Number)
+], NumericFacetItem.prototype, "value", void 0);
+__decorate([
+    swagger.ApiProperty({ required: false }),
+    __metadata("design:type", String)
+], NumericFacetItem.prototype, "name", void 0);
+__decorate([
+    swagger.ApiProperty({ required: false }),
+    __metadata("design:type", Number)
+], NumericFacetItem.prototype, "count", void 0);
+class NumericFacet {
+}
+__decorate([
+    swagger.ApiProperty({ type: [NumericFacetItem] }),
+    __metadata("design:type", Array)
+], NumericFacet.prototype, "items", void 0);
+class BooleanFacetItem {
+}
+__decorate([
+    swagger.ApiProperty(),
+    __metadata("design:type", Boolean)
+], BooleanFacetItem.prototype, "value", void 0);
+__decorate([
+    swagger.ApiProperty({ required: false }),
+    __metadata("design:type", String)
+], BooleanFacetItem.prototype, "name", void 0);
+__decorate([
+    swagger.ApiProperty({ required: false }),
+    __metadata("design:type", Number)
+], BooleanFacetItem.prototype, "count", void 0);
+class BooleanFacet {
+}
+__decorate([
+    swagger.ApiProperty({ type: [BooleanFacetItem] }),
+    __metadata("design:type", Array)
+], BooleanFacet.prototype, "items", void 0);
+class StringFacetItem {
+}
+__decorate([
+    swagger.ApiProperty(),
+    __metadata("design:type", String)
+], StringFacetItem.prototype, "value", void 0);
+__decorate([
+    swagger.ApiProperty({ required: false }),
+    __metadata("design:type", String)
+], StringFacetItem.prototype, "name", void 0);
+__decorate([
+    swagger.ApiProperty({ required: false }),
+    __metadata("design:type", Number)
+], StringFacetItem.prototype, "count", void 0);
+class StringFacet {
+}
+__decorate([
+    swagger.ApiProperty({ type: [StringFacetItem] }),
+    __metadata("design:type", Array)
+], StringFacet.prototype, "items", void 0);
+
+const AuthenticationExtensionSymbols = {
+    UserService: Symbol.for("WP.EXT:AUTHENTICATION.USER_SERVICE"),
+    RolesService: Symbol.for("WP.EXT:AUTHENTICATION.ROLES_SERVICE"),
+    UserRolesService: Symbol.for("WP.EXT:AUTHENTICATION.USER_ROLES_SERVICE"),
+};
+const AuthenticationGuardsSymbols = {
+    Authenticated: "guard:authenticated",
+    Public: "guard:public",
+    Roles: "guard:roles",
+    MemberOf: "guard:memberOf",
+};
+
+const Public = () => common.SetMetadata(AuthenticationGuardsSymbols.Public, true);
+const Authenticated = () => common.SetMetadata(AuthenticationGuardsSymbols.Authenticated, true);
+const Roles = (...roles) => common.SetMetadata(AuthenticationGuardsSymbols.Roles, roles);
+const MemberOf = (...groups) => common.SetMetadata(AuthenticationGuardsSymbols.MemberOf, groups);
+const buildRolesGuard = ({ mainRole, inheritedRoles, }, options) => Roles(mainRole.uid, ...(options?.inheritRoles && inheritedRoles
+    ? inheritedRoles.map((role) => role.uid)
+    : []));
+
+const WpRolesService = () => common.applyDecorators(common.Injectable(), common.SetMetadata(AuthenticationExtensionSymbols.RolesService, true));
+
+const WpUserService = () => common.applyDecorators(common.Injectable(), common.SetMetadata(AuthenticationExtensionSymbols.UserService, true));
+
+const WpUserRolesService = () => common.applyDecorators(common.Injectable(), common.SetMetadata(AuthenticationExtensionSymbols.UserRolesService, true));
+
+const AuthenticationEmailTemplates = {
+    Registration: "registration",
+    PasswordReset: "passwordReset",
+    EmailVerify: "emailVerify",
+};
+
+class AuthenticationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "AuthenticationError";
     }
 }
-class EntityManagerServiceCollection {
-    constructor(entityName, locator) {
-        this.entityName = entityName;
-        this.locator = locator;
-        this.replicas = new ReplicasConfiguration();
-        this.connectors = new ConnectorsConfiguration();
-        this.resolver = new EntityServiceLocator(locator, entityName);
+class InvalidCredentialsError extends AuthenticationError {
+    constructor(message) {
+        super(message);
+        this.name = "InvalidCredentialsError";
     }
-    getServiceLocator() {
-        return this.resolver;
+}
+class OperationTokenMismatchError extends AuthenticationError {
+    constructor(message) {
+        super(message);
+        this.name = "OperationTokenMismatchError";
     }
-    mapCrudOperations({ queryBuilder, settings, }) {
-        this.mapGet();
-        this.mapCount();
-        this.mapExists();
-        this.mapSearch({
-            queryBuilder,
-        });
-        this.mapCreate();
-        this.mapUpdate();
-        this.mapDelete();
-        this.mapImportExport(settings.importExport);
-        return this;
+}
+
+const AUTHENTICATION_EVENTS_NAMESPACE = "authentication";
+const AuthenticationEvents = {
+    UserLogin: `${AUTHENTICATION_EVENTS_NAMESPACE}:user.login`,
+    UserRegistrationStarted: `${AUTHENTICATION_EVENTS_NAMESPACE}:user.registrationStarted`,
+    UserRegistrationCompleted: `${AUTHENTICATION_EVENTS_NAMESPACE}:user.registrationCompleted`,
+    UserPasswordResetStarted: `${AUTHENTICATION_EVENTS_NAMESPACE}:user.passwordResetStarted`,
+    UserPasswordResetCompleted: `${AUTHENTICATION_EVENTS_NAMESPACE}:user.passwordResetCompleted`,
+};
+
+exports.AuthGuard = class AuthGuard {
+    constructor(reflector) {
+        this.reflector = reflector;
     }
-    mapGet() {
-        this.locator.registerGetQuery(this.entityName, new EntityGetQuery(this.resolver));
-        this.locator.registerGetAction(this.entityName, new EntityGetAction(this.resolver));
-        return this;
+    canActivate(context) {
+        const isPublic = this.getIsPublic(context);
+        if (isPublic) {
+            return true;
+        }
+        const auth = this.getCurrentAuth(context);
+        const allowedRoles = this.getAllowedRoles(context);
+        if (allowedRoles) {
+            return this.isRoleMatching(allowedRoles, auth?.roles ?? []);
+        }
+        const isForAllAuthenticated = this.getIsForAllAuthenticated(context);
+        if (isForAllAuthenticated) {
+            return !!auth?.user;
+        }
+        return false;
     }
-    mapCount() {
-        this.locator.registerCountQuery(this.entityName, new EntitiesCountQuery(this.resolver));
-        this.locator.registerCountAction(this.entityName, new EntitiesCountAction(this.resolver));
-        return this;
+    isRoleMatching(allowedRoles, userRoles) {
+        return userRoles.some((role) => allowedRoles.includes(role.uid));
     }
-    mapExists() {
-        this.locator.registerExistsQuery(this.entityName, new EntityExistsQuery(this.resolver));
-        this.locator.registerExistsAction(this.entityName, new EntityExistsAction(this.resolver));
-        return this;
+    getIsForAllAuthenticated(context) {
+        return this.getMetadata(AuthenticationGuardsSymbols.Authenticated, context);
     }
-    mapSearch({ queryBuilder, }) {
-        this.locator.registerSearchQuery(this.entityName, new EntitiesSearchQuery(this.resolver));
-        this.locator.registerSearchAction(this.entityName, new EntitiesSearchAction(this.resolver));
-        this.locator.registerQueryBuilder(this.entityName, queryBuilder);
-        return this;
+    getIsPublic(context) {
+        return this.getMetadata(AuthenticationGuardsSymbols.Public, context);
     }
-    mapCreate() {
-        this.locator.registerCreateCommand(this.entityName, new EntityCreateCommand(this.resolver));
-        this.locator.registerCreateAction(this.entityName, new EntityCreateAction(this.resolver));
-        return this;
+    getAllowedRoles(context) {
+        return this.getMetadata(AuthenticationGuardsSymbols.Roles, context);
     }
-    mapImportExport(settings) {
-        this.locator.registerExportCommand(this.entityName, new EntitiesExportCommand(this.resolver, settings));
-        this.locator.registerExportAction(this.entityName, new EntitiesExportAction(this.resolver));
-        this.locator.registerImportCommand(this.entityName, new EntitiesImportCommand(this.resolver, settings));
-        this.locator.registerImportAction(this.entityName, new EntitiesImportAction(this.resolver));
-        this.locator.registerSampleDownloadCommand(this.entityName, new EntitiesSampleDownloadCommand(this.resolver, settings));
-        this.locator.registerSampleDownloadAction(this.entityName, new EntitiesSampleDownloadAction(this.resolver));
-        return this;
+    getCurrentAuth(context) {
+        const request = context.switchToHttp()?.getRequest();
+        return request?.auth?.user
+            ? {
+                user: request.auth.user,
+                roles: request.auth.roles,
+            }
+            : undefined;
     }
-    mapUpdate() {
-        this.locator.registerUpsertCommand(this.entityName, new EntityUpsertCommand(this.resolver));
-        this.locator.registerUpsertAction(this.entityName, new EntityUpsertAction(this.resolver));
-        this.locator.registerUpdateCommand(this.entityName, new EntityUpdateCommand(this.resolver));
-        this.locator.registerUpdateAction(this.entityName, new EntityUpdateAction(this.resolver));
-        return this;
+    getMetadata(symbol, context) {
+        return this.reflector.getAllAndOverride(symbol, [
+            context.getHandler(),
+            context.getClass(),
+        ]);
     }
-    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.registerDeleteItemsAction(this.entityName, new EntitiesDeleteAction(this.resolver));
-        return this;
+};
+exports.AuthGuard = __decorate([
+    common.Injectable(),
+    __metadata("design:paramtypes", [core.Reflector])
+], exports.AuthGuard);
+
+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) {
+        return this.getSession().get(key);
     }
-    addAdapter(adapter) {
-        this.locator.registerAdapter(this.entityName, adapter);
-        return this;
+    setValue(key, value) {
+        this.getSession().set(key, value);
     }
-    addSerializer(serializer) {
-        this.locator.registerSerializer(this.entityName, serializer);
-        return this;
+    clearValue(key) {
+        this.getSession().set(key, undefined);
     }
-    addConverter(converter) {
-        this.locator.registerConverter(this.entityName, converter);
-        return this;
+    getRequest() {
+        return this.getSession().request;
     }
-    addAuthorization({ middleware, }) {
-        this.locator.registerAuthorizationMiddleware(this.entityName, middleware);
-        return this;
+    getSession() {
+        const store = sessionStorage.getStore();
+        if (!store) {
+            throw new Error("No active context found");
+        }
+        return store;
     }
-    withReplica({ name, options, repository, }) {
-        this.replicas.configureReplica(name, options, repository);
-        return this;
+};
+exports.AppSessionService = __decorate([
+    common.Injectable()
+], exports.AppSessionService);
+
+exports.AppHashingService = class AppHashingService {
+    async hash(value, salt) {
+        return await bcrypt.hash(value, salt);
     }
-    withSynchronization({ name, options, connector, mapper, }) {
-        this.connectors.configureConnector(name, options, connector, mapper);
-        return this;
+    async compare(hash, value, salt) {
+        return (await this.hash(value, salt)) === hash;
     }
-}
-const createContainer = () => new EntityManagerServiceRoot();
+};
+exports.AppHashingService = __decorate([
+    common.Injectable()
+], exports.AppHashingService);
 
 exports.EntityManagerRegistry = class EntityManagerRegistry {
     constructor() {
@@ -27352,8 +27361,10 @@ exports.WpSendgridEmailTemplate = WpSendgridEmailTemplate;
 exports.WpUserRolesService = WpUserRolesService;
 exports.WpUserService = WpUserService;
 exports.buildRolesGuard = buildRolesGuard;
+exports.createContainer = createContainer;
 exports.createExpressFileResponse = createExpressFileResponse;
 exports.getLocalizedText = getLocalizedText;
 exports.newUuid = newUuid;
 exports.renderHandlebarsTemplate = renderHandlebarsTemplate;
+exports.toEntitiesImportInput = toEntitiesImportInput;
 //# sourceMappingURL=index.js.map