@elsikora/nestjs-crud-automator 1.24.0-dev.1 → 2.0.0-dev.1

package/dist/cjs/class/api/authorization/simulator.class.js.map

@@ -1 +1 @@
-{"version":3,"file":"simulator.class.js","sources":["../../../../../../src/class/api/authorization/simulator.class.ts"],"sourcesContent":[null],"names":["ApiAuthorizationSimulator","__decorate","Injectable","ApiAuthorizationRuntime"],"mappings":";;;;;;AAUaA,iCAAyB,GAA/B,MAAM,yBAAyB,CAAA;AACD,IAAA,OAAA;AAApC,IAAA,WAAA,CAAoC,OAAgC,EAAA;QAAhC,IAAA,CAAA,OAAO,GAAP,OAAO;IAA4B;IAEhE,MAAM,QAAQ,CAA2B,OAAsR,EAAA;AACrU,QAAA,OAAO,MAAM,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC;YAClC,MAAM,EAAE,OAAO,CAAC,MAAM;YACtB,aAAa,EAAE,OAAO,CAAC,aAAa;YACpC,MAAM,EAAE,OAAO,CAAC,MAAM;YACtB,SAAS,EAAE,OAAO,CAAC,SAAS;AAC5B,YAAA,eAAe,EAAE,OAAO,CAAC,eAAe,IAAI,EAAE;YAC9C,QAAQ,EAAE,OAAO,CAAC,QAAQ;YAC1B,kBAAkB,EAAE,OAAO,CAAC,kBAAkB;AAC9C,SAAA,CAAC;IACH;;AAbYA,iCAAyB,GAAAC,oBAAA,CAAA;AADrC,IAAAC,iBAAU,EAAE;+CAEiCC,qCAAuB,CAAA;AADxD,CAAA,EAAAH,iCAAyB,CAcrC;;"}
+{"version":3,"file":"simulator.class.js","sources":["../../../../../../src/class/api/authorization/simulator.class.ts"],"sourcesContent":[null],"names":["ApiAuthorizationSimulator","__decorate","Injectable","ApiAuthorizationRuntime"],"mappings":";;;;;;AAWaA,iCAAyB,GAA/B,MAAM,yBAAyB,CAAA;AACD,IAAA,OAAA;AAApC,IAAA,WAAA,CAAoC,OAAgC,EAAA;QAAhC,IAAA,CAAA,OAAO,GAAP,OAAO;IAA4B;IAEhE,MAAM,QAAQ,CAA2B,OAAiT,EAAA;AAChW,QAAA,OAAO,MAAM,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC;YAClC,MAAM,EAAE,OAAO,CAAC,MAAM;YACtB,aAAa,EAAE,OAAO,CAAC,aAAa;YACpC,MAAM,EAAE,OAAO,CAAC,MAAM;YACtB,SAAS,EAAE,OAAO,CAAC,SAAS;AAC5B,YAAA,eAAe,EAAE,OAAO,CAAC,eAAe,IAAI,EAAE;YAC9C,QAAQ,EAAE,OAAO,CAAC,QAAQ;YAC1B,kBAAkB,EAAE,OAAO,CAAC,kBAAkB;YAC9C,SAAS,EAAE,OAAO,CAAC,SAAS;AAC5B,SAAA,CAAC;IACH;;AAdYA,iCAAyB,GAAAC,oBAAA,CAAA;AADrC,IAAAC,iBAAU,EAAE;+CAEiCC,qCAAuB,CAAA;AADxD,CAAA,EAAAH,iCAAyB,CAerC;;"}

package/dist/cjs/class/api/function/context-storage.class.d.ts

@@ -0,0 +1,7 @@
+import type { IApiBaseEntity } from '../../../interface/api-base-entity.interface';
+import type { IApiFunctionContext } from '../../../interface/class/api/function/index';
+export declare class ApiFunctionContextStorage {
+    private static readonly STORAGE;
+    static get<E extends IApiBaseEntity>(): IApiFunctionContext<E> | undefined;
+    static run<E extends IApiBaseEntity, R>(context: IApiFunctionContext<E>, callback: () => Promise<R>): Promise<R>;
+}

package/dist/cjs/class/api/function/context-storage.class.js

@@ -0,0 +1,16 @@
+'use strict';
+
+var node_async_hooks = require('node:async_hooks');
+
+class ApiFunctionContextStorage {
+    static STORAGE = new node_async_hooks.AsyncLocalStorage();
+    static get() {
+        return ApiFunctionContextStorage.STORAGE.getStore();
+    }
+    static run(context, callback) {
+        return ApiFunctionContextStorage.STORAGE.run(context, callback);
+    }
+}
+
+exports.ApiFunctionContextStorage = ApiFunctionContextStorage;
+//# sourceMappingURL=context-storage.class.js.map

package/dist/cjs/class/api/function/context-storage.class.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-storage.class.js","sources":["../../../../../../src/class/api/function/context-storage.class.ts"],"sourcesContent":[null],"names":["NodeAsyncLocalStorage"],"mappings":";;;;MAOa,yBAAyB,CAAA;AAC7B,IAAA,OAAgB,OAAO,GAA2D,IAAIA,kCAAqB,EAAuC;AAEnJ,IAAA,OAAO,GAAG,GAAA;AAChB,QAAA,OAAO,yBAAyB,CAAC,OAAO,CAAC,QAAQ,EAAwC;IAC1F;AAEO,IAAA,OAAO,GAAG,CAA8B,OAA+B,EAAE,QAA0B,EAAA;QACzG,OAAO,yBAAyB,CAAC,OAAO,CAAC,GAAG,CAAC,OAAyD,EAAE,QAAQ,CAAC;IAClH;;;;;"}

package/dist/cjs/class/api/function/custom-runtime.class.d.ts

@@ -0,0 +1,19 @@
+import type { IApiBaseEntity } from '../../../interface/api-base-entity.interface';
+import type { IApiFunctionCustomProperties } from '../../../interface/decorator/api/function/index';
+import type { Repository } from "typeorm";
+import { EApiFunctionTransactionMode } from '../../../enum/decorator/api/index';
+export declare class ApiFunctionCustomRuntime {
+    static execute<E extends IApiBaseEntity>(options: {
+        functionArguments: Array<unknown>;
+        originalMethod: (...arguments_: Array<unknown>) => Promise<unknown>;
+        properties: IApiFunctionCustomProperties<E>;
+        target: {
+            repository: Repository<E>;
+        };
+        transactionMode: EApiFunctionTransactionMode;
+    }): Promise<unknown>;
+    private static createContext;
+    private static executeErrorSubscribers;
+    private static executeWithEventManager;
+    private static resolveEventManager;
+}

package/dist/cjs/class/api/function/custom-runtime.class.js

@@ -0,0 +1,118 @@
+'use strict';
+
+var contextStorage_class = require('./context-storage.class.js');
+var executor_class = require('../subscriber/executor.class.js');
+require('../../../enum/decorator/api/action.enum.js');
+require('../../../enum/decorator/api/authentication-type.enum.js');
+require('../../../enum/decorator/api/controller/load-relations-strategy.enum.js');
+require('../../../enum/decorator/api/controller/relation-reference-shape.enum.js');
+require('../../../enum/decorator/api/controller/request/target.enum.js');
+require('../../../enum/decorator/api/controller/request/transformer-type.enum.js');
+require('../../../enum/decorator/api/controller/response-target.enum.js');
+require('../../../enum/decorator/api/dto-type.enum.js');
+var functionTransactionMode_enum = require('../../../enum/decorator/api/function-transaction-mode.enum.js');
+var functionType_enum = require('../../../enum/decorator/api/function-type.enum.js');
+var onType_enum = require('../../../enum/decorator/api/on-type.enum.js');
+require('../../../enum/decorator/api/property/data-type.enum.js');
+require('../../../enum/decorator/api/property/date/identifier.enum.js');
+require('../../../enum/decorator/api/property/date/type.enum.js');
+require('../../../enum/decorator/api/property/desribe-type.enum.js');
+require('../../../enum/decorator/api/property/number-type.enum.js');
+require('../../../enum/decorator/api/property/string-type.enum.js');
+require('../../../enum/decorator/api/route-type.enum.js');
+var exception_utility = require('../../../utility/error/exception.utility.js');
+
+class ApiFunctionCustomRuntime {
+    static async execute(options) {
+        const activeContext = contextStorage_class.ApiFunctionContextStorage.get();
+        let eventManager;
+        try {
+            eventManager = ApiFunctionCustomRuntime.resolveEventManager(options.transactionMode, activeContext);
+        }
+        catch (error) {
+            await ApiFunctionCustomRuntime.executeErrorSubscribers(options, undefined, onType_enum.EApiSubscriberOnType.BEFORE_ERROR, error);
+            throw error;
+        }
+        if (options.transactionMode === functionTransactionMode_enum.EApiFunctionTransactionMode.REQUIRED && !eventManager) {
+            return await options.target.repository.manager.transaction(async (transactionManager) => await ApiFunctionCustomRuntime.executeWithEventManager({ ...options, eventManager: transactionManager }));
+        }
+        return await ApiFunctionCustomRuntime.executeWithEventManager({ ...options, eventManager });
+    }
+    static createContext(options) {
+        const repository = options.eventManager?.getRepository(options.properties.entity) ?? options.target.repository;
+        return {
+            entity: options.properties.entity,
+            eventManager: options.eventManager,
+            getRepository: (repositoryEntity) => options.eventManager?.getRepository(repositoryEntity) ?? options.target.repository.manager.getRepository(repositoryEntity),
+            operations: {
+                create: async (properties) => await options.target.create(properties),
+                delete: async (criteria) => {
+                    await options.target.delete(criteria);
+                },
+                get: async (properties) => await options.target.get(properties),
+                getList: async (properties) => await options.target.getList(properties),
+                getMany: async (properties) => await options.target.getMany(properties),
+                getRepository: (repositoryEntity) => options.eventManager?.getRepository(repositoryEntity) ?? options.target.repository.manager.getRepository(repositoryEntity),
+                update: async (criteria, properties) => await options.target.update(criteria, properties),
+            },
+            repository,
+        };
+    }
+    static async executeErrorSubscribers(options, eventManager, onType, error) {
+        const entityInstance = new options.properties.entity();
+        const errorExecutionContext = {
+            action: options.properties.action,
+            DATA: { eventManager, repository: options.target.repository },
+            ENTITY: entityInstance,
+            FUNCTION_TYPE: functionType_enum.EApiFunctionType.CUSTOM,
+        };
+        await executor_class.ApiSubscriberExecutor.executeFunctionErrorSubscribers(options.target.constructor, entityInstance, functionType_enum.EApiFunctionType.CUSTOM, onType, errorExecutionContext, error, options.properties.action);
+    }
+    static async executeWithEventManager(options) {
+        const entityInstance = new options.properties.entity();
+        const context = ApiFunctionCustomRuntime.createContext(options);
+        const executionContext = {
+            action: options.properties.action,
+            DATA: { eventManager: options.eventManager, repository: options.target.repository },
+            ENTITY: entityInstance,
+            FUNCTION_TYPE: functionType_enum.EApiFunctionType.CUSTOM,
+            result: options.functionArguments,
+        };
+        let finalArguments;
+        try {
+            const beforeResult = await executor_class.ApiSubscriberExecutor.executeFunctionSubscribers(options.target.constructor, entityInstance, functionType_enum.EApiFunctionType.CUSTOM, onType_enum.EApiSubscriberOnType.BEFORE, executionContext, options.properties.action);
+            finalArguments = beforeResult ?? options.functionArguments;
+        }
+        catch (error) {
+            await ApiFunctionCustomRuntime.executeErrorSubscribers(options, options.eventManager, onType_enum.EApiSubscriberOnType.BEFORE_ERROR, error);
+            throw error;
+        }
+        try {
+            const result = await contextStorage_class.ApiFunctionContextStorage.run(context, async () => await options.originalMethod.apply(options.target, finalArguments));
+            const afterExecutionContext = {
+                action: options.properties.action,
+                DATA: { eventManager: options.eventManager, repository: options.target.repository },
+                ENTITY: entityInstance,
+                FUNCTION_TYPE: functionType_enum.EApiFunctionType.CUSTOM,
+                result,
+            };
+            return (await executor_class.ApiSubscriberExecutor.executeFunctionSubscribers(options.target.constructor, entityInstance, functionType_enum.EApiFunctionType.CUSTOM, onType_enum.EApiSubscriberOnType.AFTER, afterExecutionContext, options.properties.action)) ?? result;
+        }
+        catch (error) {
+            await ApiFunctionCustomRuntime.executeErrorSubscribers(options, options.eventManager, onType_enum.EApiSubscriberOnType.AFTER_ERROR, error);
+            throw error;
+        }
+    }
+    static resolveEventManager(transactionMode, activeContext) {
+        if (transactionMode === functionTransactionMode_enum.EApiFunctionTransactionMode.NONE && activeContext?.eventManager) {
+            throw exception_utility.ErrorException("ApiFunctionCustom transaction mode NONE cannot run inside an active transaction");
+        }
+        if (transactionMode === functionTransactionMode_enum.EApiFunctionTransactionMode.MANDATORY && !activeContext?.eventManager) {
+            throw exception_utility.ErrorException("ApiFunctionCustom transaction mode MANDATORY requires an active transaction");
+        }
+        return transactionMode === functionTransactionMode_enum.EApiFunctionTransactionMode.NONE ? undefined : activeContext?.eventManager;
+    }
+}
+
+exports.ApiFunctionCustomRuntime = ApiFunctionCustomRuntime;
+//# sourceMappingURL=custom-runtime.class.js.map

package/dist/cjs/class/api/function/custom-runtime.class.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"custom-runtime.class.js","sources":["../../../../../../src/class/api/function/custom-runtime.class.ts"],"sourcesContent":[null],"names":["ApiFunctionContextStorage","EApiSubscriberOnType","EApiFunctionTransactionMode","EApiFunctionType","ApiSubscriberExecutor","ErrorException"],"mappings":"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"}

package/dist/cjs/class/api/function/index.d.ts

@@ -0,0 +1 @@
+export { ApiFunctionTransactionScope } from './transaction-scope.class';

package/dist/cjs/class/api/function/transaction-scope.class.d.ts

@@ -0,0 +1,6 @@
+import type { DataSource, EntityManager } from "typeorm";
+export declare class ApiFunctionTransactionScope {
+    static runWithDataSource<R>(dataSource: DataSource, callback: () => Promise<R>): Promise<R>;
+    static runWithEntityManager<R>(entityManager: EntityManager, callback: () => Promise<R>): Promise<R>;
+    private static createMissingServiceContextError;
+}

package/dist/cjs/class/api/function/transaction-scope.class.js

@@ -0,0 +1,34 @@
+'use strict';
+
+var contextStorage_class = require('./context-storage.class.js');
+
+class ApiFunctionTransactionScope {
+    static async runWithDataSource(dataSource, callback) {
+        return await dataSource.transaction(async (entityManager) => await ApiFunctionTransactionScope.runWithEntityManager(entityManager, callback));
+    }
+    static async runWithEntityManager(entityManager, callback) {
+        const entity = Object;
+        const context = {
+            entity,
+            eventManager: entityManager,
+            getRepository: (repositoryEntity) => entityManager.getRepository(repositoryEntity),
+            operations: {
+                create: () => Promise.reject(ApiFunctionTransactionScope.createMissingServiceContextError()),
+                delete: () => Promise.reject(ApiFunctionTransactionScope.createMissingServiceContextError()),
+                get: () => Promise.reject(ApiFunctionTransactionScope.createMissingServiceContextError()),
+                getList: () => Promise.reject(ApiFunctionTransactionScope.createMissingServiceContextError()),
+                getMany: () => Promise.reject(ApiFunctionTransactionScope.createMissingServiceContextError()),
+                getRepository: (repositoryEntity) => entityManager.getRepository(repositoryEntity),
+                update: () => Promise.reject(ApiFunctionTransactionScope.createMissingServiceContextError()),
+            },
+            repository: entityManager.getRepository(entity),
+        };
+        return await contextStorage_class.ApiFunctionContextStorage.run(context, callback);
+    }
+    static createMissingServiceContextError() {
+        return new Error("ApiFunctionTransactionScope operations require a decorated service context");
+    }
+}
+
+exports.ApiFunctionTransactionScope = ApiFunctionTransactionScope;
+//# sourceMappingURL=transaction-scope.class.js.map

package/dist/cjs/class/api/function/transaction-scope.class.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction-scope.class.js","sources":["../../../../../../src/class/api/function/transaction-scope.class.ts"],"sourcesContent":[null],"names":["ApiFunctionContextStorage"],"mappings":";;;;MAMa,2BAA2B,CAAA;AAChC,IAAA,aAAa,iBAAiB,CAAI,UAAsB,EAAE,QAA0B,EAAA;QAC1F,OAAO,MAAM,UAAU,CAAC,WAAW,CAAC,OAAO,aAA4B,KAAiB,MAAM,2BAA2B,CAAC,oBAAoB,CAAC,aAAa,EAAE,QAAQ,CAAC,CAAC;IACzK;AAEO,IAAA,aAAa,oBAAoB,CAAI,aAA4B,EAAE,QAA0B,EAAA;QACnG,MAAM,MAAM,GAA6B,MAA6C;AAEtF,QAAA,MAAM,OAAO,GAAwC;YACpD,MAAM;AACN,YAAA,YAAY,EAAE,aAAa;YAC3B,aAAa,EAAE,CAA2B,gBAA6B,KAAoB,aAAa,CAAC,aAAa,CAAC,gBAAgB,CAAC;AACxI,YAAA,UAAU,EAAE;AACX,gBAAA,MAAM,EAAE,MAA+B,OAAO,CAAC,MAAM,CAAC,2BAA2B,CAAC,gCAAgC,EAAE,CAAC;AACrH,gBAAA,MAAM,EAAE,MAAqB,OAAO,CAAC,MAAM,CAAC,2BAA2B,CAAC,gCAAgC,EAAE,CAAC;AAC3G,gBAAA,GAAG,EAAE,MAA+B,OAAO,CAAC,MAAM,CAAC,2BAA2B,CAAC,gCAAgC,EAAE,CAAC;AAClH,gBAAA,OAAO,EAAE,MAAsB,OAAO,CAAC,MAAM,CAAC,2BAA2B,CAAC,gCAAgC,EAAE,CAAC;AAC7G,gBAAA,OAAO,EAAE,MAAsC,OAAO,CAAC,MAAM,CAAC,2BAA2B,CAAC,gCAAgC,EAAE,CAAC;gBAC7H,aAAa,EAAE,CAA2B,gBAA6B,KAAoB,aAAa,CAAC,aAAa,CAAC,gBAAgB,CAAC;AACxI,gBAAA,MAAM,EAAE,MAA+B,OAAO,CAAC,MAAM,CAAC,2BAA2B,CAAC,gCAAgC,EAAE,CAAC;AACrH,aAAA;AACD,YAAA,UAAU,EAAE,aAAa,CAAC,aAAa,CAAC,MAAM,CAAC;SAC/C;QAED,OAAO,MAAMA,8CAAyB,CAAC,GAAG,CAAC,OAAO,EAAE,QAAQ,CAAC;IAC9D;AAEQ,IAAA,OAAO,gCAAgC,GAAA;AAC9C,QAAA,OAAO,IAAI,KAAK,CAAC,4EAA4E,CAAC;IAC/F;AACA;;;;"}

package/dist/cjs/class/api/index.d.ts

@@ -1,2 +1,4 @@
+export * from './function/index';
+export { ApiRouteRuntime } from './route-runtime.class';
 export * from './service-base.class';
 export * from './subscriber/index';

package/dist/cjs/class/api/route-runtime.class.d.ts

@@ -0,0 +1,21 @@
+import type { IApiBaseEntity } from '../../interface/api-base-entity.interface';
+import type { IApiRouteRuntimeCustomExecutionOptions, IApiRouteRuntimeGeneratedExecutionOptions } from '../../interface/class/api/route/index';
+import type { IApiRouteMetadata, IApiRouteRuntimeProperties } from '../../interface/decorator/api/index';
+import type { TApiControllerMethod } from '../../type/class/controller-method.type';
+import { EApiRouteType } from '../../enum/decorator/api/index';
+export declare class ApiRouteRuntime {
+    static executeCustom<E extends IApiBaseEntity, R>(options: IApiRouteRuntimeCustomExecutionOptions<E, R>): Promise<R>;
+    static executeCustomRequestRelations<E extends IApiBaseEntity>(controller: TApiControllerMethod<E>, metadata: IApiRouteMetadata<E>, runtimeProperties: IApiRouteRuntimeProperties<E>, body: Partial<E> | undefined): Promise<void>;
+    static executeCustomResponseRelations<E extends IApiBaseEntity, R>(controller: TApiControllerMethod<E>, runtimeProperties: IApiRouteRuntimeProperties<E>, response: R): Promise<R>;
+    static executeGenerated<E extends IApiBaseEntity, R extends EApiRouteType>(options: IApiRouteRuntimeGeneratedExecutionOptions<E, R>): Promise<unknown>;
+    private static executeCustomErrorSubscribers;
+    private static executeCustomResponse;
+    private static executeGeneratedErrorSubscribers;
+    private static executeGeneratedOperation;
+    private static executeGeneratedRequestPipeline;
+    private static executeGeneratedResponse;
+    private static executeGeneratedUpdateOperation;
+    private static executeRequestTargets;
+    private static loadCustomResponseRelations;
+    private static resolvePrimaryKey;
+}

package/dist/cjs/class/api/route-runtime.class.js

@@ -0,0 +1,335 @@
+'use strict';
+
+var serviceBase_class = require('./service-base.class.js');
+var executor_class = require('./subscriber/executor.class.js');
+var function_constant = require('../../constant/decorator/api/function.constant.js');
+require('../../enum/decorator/api/action.enum.js');
+require('../../enum/decorator/api/authentication-type.enum.js');
+require('../../enum/decorator/api/controller/load-relations-strategy.enum.js');
+require('../../enum/decorator/api/controller/relation-reference-shape.enum.js');
+var target_enum = require('../../enum/decorator/api/controller/request/target.enum.js');
+require('../../enum/decorator/api/controller/request/transformer-type.enum.js');
+require('../../enum/decorator/api/controller/response-target.enum.js');
+var dtoType_enum = require('../../enum/decorator/api/dto-type.enum.js');
+require('../../enum/decorator/api/function-transaction-mode.enum.js');
+require('../../enum/decorator/api/function-type.enum.js');
+var onType_enum = require('../../enum/decorator/api/on-type.enum.js');
+require('../../enum/decorator/api/property/data-type.enum.js');
+require('../../enum/decorator/api/property/date/identifier.enum.js');
+require('../../enum/decorator/api/property/date/type.enum.js');
+require('../../enum/decorator/api/property/desribe-type.enum.js');
+require('../../enum/decorator/api/property/number-type.enum.js');
+require('../../enum/decorator/api/property/string-type.enum.js');
+var routeType_enum = require('../../enum/decorator/api/route-type.enum.js');
+var filter_utility = require('../../utility/api/controller/get-list/transform/filter.utility.js');
+var dto_utility = require('../../utility/api/controller/get/dto.utility.js');
+var primaryColumn_utility = require('../../utility/api/controller/get/primary-column.utility.js');
+var handleRequestRelations_utility = require('../../utility/api/controller/handle-request-relations.utility.js');
+var serializeRouteResponse_utility = require('../../utility/api/controller/serialize-route-response.utility.js');
+var transformData_utility = require('../../utility/api/controller/transform-data.utility.js');
+var validateRequest_utility = require('../../utility/api/controller/validate-request.utility.js');
+var projectRelation_utility = require('../../utility/api/route/response/project-relation.utility.js');
+var serialize_utility = require('../../utility/api/route/response/serialize.utility.js');
+var applyResult_utility = require('../../utility/authorization/decision/apply-result.utility.js');
+var attachResource_utility = require('../../utility/authorization/decision/attach-resource.utility.js');
+var resolveFromRequest_utility = require('../../utility/authorization/decision/resolve-from-request.utility.js');
+var scopeMergeWhere_utility = require('../../utility/authorization/scope-merge-where.utility.js');
+var exception_utility = require('../../utility/error/exception.utility.js');
+
+class ApiRouteRuntime {
+    static async executeCustom(options) {
+        const action = options.metadata.resource.action;
+        const entityInstance = new options.metadata.resource.entity();
+        const request = options.executionContext.switchToHttp().getRequest();
+        const headers = {};
+        for (const [key, value] of Object.entries(request.headers ?? {})) {
+            if (typeof value === "string") {
+                headers[key] = value;
+            }
+            else if (Array.isArray(value) && typeof value[0] === "string") {
+                headers[key] = value[0];
+            }
+        }
+        const contextData = {
+            authenticationRequest: request,
+            headers,
+            ip: request.ip ?? "",
+            metadata: options.metadata,
+            runtimeProperties: options.runtimeProperties,
+        };
+        const beforeContext = {
+            action,
+            DATA: contextData,
+            ENTITY: entityInstance,
+            result: {
+                body: request.body,
+                parameters: request.params,
+                query: request.query,
+            },
+            ROUTE_TYPE: options.metadata.route.type,
+        };
+        try {
+            const beforeResult = await executor_class.ApiSubscriberExecutor.executeRouteSubscribers(options.executionContext.getClass(), entityInstance, options.metadata.route.type, onType_enum.EApiSubscriberOnType.BEFORE, beforeContext, action);
+            if (beforeResult) {
+                request.body = beforeResult.body;
+                request.params = beforeResult.parameters;
+                request.query = beforeResult.query;
+            }
+            await this.executeRequestTargets(options.metadata, options.runtimeProperties, request, contextData);
+        }
+        catch (error) {
+            await this.executeCustomErrorSubscribers(options, entityInstance, contextData, onType_enum.EApiSubscriberOnType.BEFORE_ERROR, error);
+            throw error;
+        }
+        try {
+            const result = await options.operation();
+            const transformedResult = await this.executeCustomResponse(options, entityInstance, contextData, result);
+            return transformedResult;
+        }
+        catch (error) {
+            await this.executeCustomErrorSubscribers(options, entityInstance, contextData, onType_enum.EApiSubscriberOnType.AFTER_ERROR, error);
+            throw error;
+        }
+    }
+    static async executeCustomRequestRelations(controller, metadata, runtimeProperties, body) {
+        if (!body) {
+            return;
+        }
+        await handleRequestRelations_utility.ApiControllerHandleRequestRelations(controller, { entity: metadata.resource.entity}, runtimeProperties.relations?.request, body);
+    }
+    static async executeCustomResponseRelations(controller, runtimeProperties, response) {
+        if (!runtimeProperties.relations?.response?.load?.include) {
+            return response;
+        }
+        if (!(controller.service instanceof serviceBase_class.ApiServiceBase)) {
+            throw exception_utility.ErrorException("ApiRouteCustom response relation loading requires a controller service extending ApiServiceBase");
+        }
+        if (Array.isArray(response)) {
+            return (await Promise.all(response.map(async (item) => await this.loadCustomResponseRelations(controller.service, runtimeProperties, item))));
+        }
+        if (response !== null && typeof response === "object" && "items" in response && Array.isArray(response.items)) {
+            const responseObject = response;
+            responseObject.items = await Promise.all(responseObject.items.map(async (item) => await this.loadCustomResponseRelations(controller.service, runtimeProperties, item)));
+            return response;
+        }
+        return (await this.loadCustomResponseRelations(controller.service, runtimeProperties, response));
+    }
+    static async executeGenerated(options) {
+        const entityInstance = new options.properties.entity();
+        let authorizationDecision = resolveFromRequest_utility.AuthorizationDecisionResolveFromRequest(options.targets.authenticationRequest);
+        const beforeContext = {
+            DATA: { authorizationDecision, entityMetadata: options.entityMetadata, method: options.method, methodName: options.methodName, properties: options.properties },
+            ENTITY: entityInstance,
+            result: options.targets,
+            ROUTE_TYPE: options.method,
+        };
+        let beforeResult;
+        try {
+            beforeResult = await executor_class.ApiSubscriberExecutor.executeRouteSubscribers(options.controller.constructor, entityInstance, options.method, onType_enum.EApiSubscriberOnType.BEFORE, beforeContext);
+        }
+        catch (error) {
+            await this.executeGeneratedErrorSubscribers(options, options.targets, entityInstance, beforeContext.DATA, authorizationDecision, onType_enum.EApiSubscriberOnType.BEFORE_ERROR, error);
+            throw error;
+        }
+        const targets = beforeResult ?? options.targets;
+        if (beforeResult) {
+            authorizationDecision = resolveFromRequest_utility.AuthorizationDecisionResolveFromRequest(targets.authenticationRequest);
+        }
+        let errorBoundary = onType_enum.EApiSubscriberOnType.BEFORE_ERROR;
+        try {
+            const result = await this.executeGeneratedOperation(options, targets, authorizationDecision, () => {
+                errorBoundary = onType_enum.EApiSubscriberOnType.AFTER_ERROR;
+            });
+            return await this.executeGeneratedResponse(options, targets, entityInstance, beforeContext.DATA, authorizationDecision, result);
+        }
+        catch (error) {
+            await this.executeGeneratedErrorSubscribers(options, targets, entityInstance, beforeContext.DATA, authorizationDecision, errorBoundary, error);
+            throw error;
+        }
+    }
+    static async executeCustomErrorSubscribers(options, entityInstance, contextData, onType, error) {
+        const action = options.metadata.resource.action;
+        const errorContext = {
+            action,
+            DATA: contextData,
+            ENTITY: entityInstance,
+            ROUTE_TYPE: options.metadata.route.type,
+        };
+        await executor_class.ApiSubscriberExecutor.executeRouteErrorSubscribers(options.executionContext.getClass(), entityInstance, options.metadata.route.type, onType, errorContext, error, action);
+    }
+    static async executeCustomResponse(options, entityInstance, contextData, result) {
+        const action = options.metadata.resource.action;
+        const responseTarget = { response: projectRelation_utility.ApiRouteProjectRelationResponse(options.runtimeProperties.relations?.response, result) };
+        let authorizationDecision = resolveFromRequest_utility.AuthorizationDecisionResolveFromRequest(contextData.authenticationRequest);
+        const controllerProperties = {
+            entity: options.metadata.resource.entity};
+        authorizationDecision = attachResource_utility.AuthorizationDecisionAttachResource(authorizationDecision, responseTarget.response);
+        transformData_utility.ApiControllerTransformData(options.runtimeProperties.response, controllerProperties, responseTarget, contextData);
+        const afterContext = {
+            action,
+            DATA: contextData,
+            ENTITY: entityInstance,
+            result: responseTarget.response,
+            ROUTE_TYPE: options.metadata.route.type,
+        };
+        const afterResult = await executor_class.ApiSubscriberExecutor.executeRouteSubscribers(options.executionContext.getClass(), entityInstance, options.metadata.route.type, onType_enum.EApiSubscriberOnType.AFTER, afterContext, action);
+        const finalResult = afterResult ?? responseTarget.response;
+        const transformedResult = (await applyResult_utility.AuthorizationDecisionApplyResult(attachResource_utility.AuthorizationDecisionAttachResource(authorizationDecision, finalResult), finalResult));
+        return serialize_utility.ApiRouteSerializeResponse(options.metadata, transformedResult);
+    }
+    static async executeGeneratedErrorSubscribers(options, targets, entityInstance, baseData, authorizationDecision, onType, error) {
+        const errorContext = {
+            DATA: { ...baseData, authenticationRequest: targets.authenticationRequest, authorizationDecision, body: targets.body, headers: targets.headers, ip: targets.ip, parameters: targets.parameters, query: targets.query },
+            ENTITY: entityInstance,
+            ROUTE_TYPE: options.method,
+        };
+        await executor_class.ApiSubscriberExecutor.executeRouteErrorSubscribers(options.controller.constructor, entityInstance, options.method, onType, errorContext, error);
+    }
+    static async executeGeneratedOperation(options, targets, authorizationDecision, markAfterBoundary) {
+        const routeConfig = options.properties.routes[options.method] ?? {};
+        switch (options.method) {
+            case routeType_enum.EApiRouteType.CREATE: {
+                await this.executeGeneratedRequestPipeline(options, targets, [target_enum.EApiControllerRequestTarget.BODY]);
+                await handleRequestRelations_utility.ApiControllerHandleRequestRelations(options.controller, options.properties, routeConfig.relations?.request, targets.body ?? {});
+                const primaryKey = this.resolvePrimaryKey(targets.body, options.entityMetadata);
+                markAfterBoundary();
+                const createResponse = await options.controller.service.create((targets.body ?? {}));
+                return await options.controller.service.get({
+                    relations: routeConfig.relations?.response?.load?.include,
+                    where: scopeMergeWhere_utility.AuthorizationScopeMergeWhere({ [primaryKey.key]: createResponse[primaryKey.key] }, authorizationDecision?.scope?.where),
+                });
+            }
+            case routeType_enum.EApiRouteType.DELETE: {
+                await this.executeGeneratedRequestPipeline(options, targets, [target_enum.EApiControllerRequestTarget.PARAMETERS]);
+                const primaryKey = this.resolvePrimaryKey(targets.parameters, options.entityMetadata);
+                const requestCriteria = { [primaryKey.key]: primaryKey.value };
+                const scopedCriteria = scopeMergeWhere_utility.AuthorizationScopeMergeWhere(requestCriteria, authorizationDecision?.scope?.where);
+                markAfterBoundary();
+                await options.controller.service.delete(scopedCriteria ?? requestCriteria);
+                return undefined;
+            }
+            case routeType_enum.EApiRouteType.GET: {
+                await this.executeGeneratedRequestPipeline(options, targets, [target_enum.EApiControllerRequestTarget.PARAMETERS]);
+                const primaryKey = this.resolvePrimaryKey(targets.parameters, options.entityMetadata);
+                const requestProperties = {
+                    relations: routeConfig.relations?.response?.load?.include,
+                    where: scopeMergeWhere_utility.AuthorizationScopeMergeWhere({ [primaryKey.key]: primaryKey.value }, authorizationDecision?.scope?.where),
+                };
+                markAfterBoundary();
+                return await options.controller.service.get(requestProperties);
+            }
+            case routeType_enum.EApiRouteType.GET_LIST: {
+                await this.executeGeneratedRequestPipeline(options, targets, [target_enum.EApiControllerRequestTarget.QUERY]);
+                if (!targets.query) {
+                    throw exception_utility.ErrorException("Query target is required for GET_LIST routes");
+                }
+                const query = targets.query;
+                const { limit, orderBy, orderDirection, page, ...getListQuery } = query;
+                const filter = filter_utility.ApiControllerGetListTransformFilter(getListQuery, options.entityMetadata);
+                const scopedFilter = scopeMergeWhere_utility.AuthorizationScopeMergeWhere(filter, authorizationDecision?.scope?.where);
+                const requestProperties = {
+                    relations: routeConfig.relations?.response?.load?.include,
+                    skip: query.limit * (query.page - 1),
+                    take: query.limit,
+                    where: scopedFilter ?? filter,
+                };
+                if (orderBy) {
+                    requestProperties.order = { [orderBy]: orderDirection ?? function_constant.FUNCTION_API_DECORATOR_CONSTANT.DEFAULT_FILTER_ORDER_BY_DIRECTION };
+                }
+                markAfterBoundary();
+                return await options.controller.service.getList(requestProperties);
+            }
+            case routeType_enum.EApiRouteType.PARTIAL_UPDATE: {
+                return await this.executeGeneratedUpdateOperation(options, targets, authorizationDecision, routeConfig, markAfterBoundary);
+            }
+            case routeType_enum.EApiRouteType.UPDATE: {
+                return await this.executeGeneratedUpdateOperation(options, targets, authorizationDecision, routeConfig, markAfterBoundary);
+            }
+        }
+    }
+    static async executeGeneratedRequestPipeline(options, targets, targetOrder) {
+        const routeConfig = options.properties.routes[options.method] ?? {};
+        for (const target of targetOrder) {
+            if (target === target_enum.EApiControllerRequestTarget.PARAMETERS) {
+                transformData_utility.ApiControllerTransformData(routeConfig.request, options.properties, { parameters: targets.parameters }, { authenticationRequest: targets.authenticationRequest, headers: targets.headers, ip: targets.ip });
+                await validateRequest_utility.ApiControllerValidateRequest(routeConfig.request?.[target], options.properties, targets.parameters ?? {});
+            }
+            if (target === target_enum.EApiControllerRequestTarget.QUERY) {
+                transformData_utility.ApiControllerTransformData(routeConfig.request, options.properties, { query: targets.query }, { authenticationRequest: targets.authenticationRequest, headers: targets.headers, ip: targets.ip });
+                await validateRequest_utility.ApiControllerValidateRequest(routeConfig.request?.[target], options.properties, (targets.query ?? {}));
+            }
+            if (target === target_enum.EApiControllerRequestTarget.BODY) {
+                transformData_utility.ApiControllerTransformData(routeConfig.request, options.properties, { body: targets.body }, { authenticationRequest: targets.authenticationRequest, headers: targets.headers, ip: targets.ip });
+                await validateRequest_utility.ApiControllerValidateRequest(routeConfig.request?.[target], options.properties, (targets.body ?? {}));
+            }
+        }
+    }
+    static async executeGeneratedResponse(options, targets, entityInstance, baseData, authorizationDecision, result) {
+        const routeConfig = options.properties.routes[options.method] ?? {};
+        const responseTarget = { response: result };
+        authorizationDecision = attachResource_utility.AuthorizationDecisionAttachResource(authorizationDecision, responseTarget.response);
+        transformData_utility.ApiControllerTransformData(routeConfig.response, options.properties, responseTarget, { authenticationRequest: targets.authenticationRequest, headers: targets.headers, ip: targets.ip });
+        const afterContext = {
+            DATA: { ...baseData, authenticationRequest: targets.authenticationRequest, authorizationDecision, body: targets.body, headers: targets.headers, ip: targets.ip, parameters: targets.parameters, query: targets.query },
+            ENTITY: responseTarget.response,
+            result: responseTarget.response,
+            ROUTE_TYPE: options.method,
+        };
+        const afterResult = await executor_class.ApiSubscriberExecutor.executeRouteSubscribers(options.controller.constructor, (responseTarget.response ?? entityInstance), options.method, onType_enum.EApiSubscriberOnType.AFTER, afterContext);
+        const finalResponse = afterResult ?? responseTarget.response;
+        const transformedResponse = await applyResult_utility.AuthorizationDecisionApplyResult(attachResource_utility.AuthorizationDecisionAttachResource(authorizationDecision, finalResponse), finalResponse);
+        const dto = dto_utility.ApiControllerGetDto(options.properties, options.entityMetadata, options.method, dtoType_enum.EApiDtoType.RESPONSE, routeConfig);
+        return serializeRouteResponse_utility.ApiControllerSerializeRouteResponse(routeConfig, dto, projectRelation_utility.ApiRouteProjectRelationResponse(routeConfig.relations?.response, transformedResponse));
+    }
+    static async executeGeneratedUpdateOperation(options, targets, authorizationDecision, routeConfig, markAfterBoundary) {
+        await this.executeGeneratedRequestPipeline(options, targets, [target_enum.EApiControllerRequestTarget.PARAMETERS, target_enum.EApiControllerRequestTarget.BODY]);
+        await handleRequestRelations_utility.ApiControllerHandleRequestRelations(options.controller, options.properties, routeConfig.relations?.request, targets.body ?? {});
+        const primaryKey = this.resolvePrimaryKey(targets.parameters, options.entityMetadata);
+        const requestCriteria = { [primaryKey.key]: primaryKey.value };
+        const scopedCriteria = scopeMergeWhere_utility.AuthorizationScopeMergeWhere(requestCriteria, authorizationDecision?.scope?.where);
+        markAfterBoundary();
+        const updateResponse = await options.controller.service.update(scopedCriteria ?? requestCriteria, (targets.body ?? {}));
+        if (!routeConfig.relations?.response?.load?.include) {
+            return updateResponse;
+        }
+        return await options.controller.service.get({
+            relations: routeConfig.relations.response.load.include,
+            where: scopeMergeWhere_utility.AuthorizationScopeMergeWhere({ [primaryKey.key]: updateResponse[primaryKey.key] }, authorizationDecision?.scope?.where),
+        });
+    }
+    static async executeRequestTargets(metadata, runtimeProperties, request, contextData) {
+        const controllerProperties = {
+            entity: metadata.resource.entity};
+        transformData_utility.ApiControllerTransformData(runtimeProperties.request, controllerProperties, { parameters: request.params }, contextData);
+        await validateRequest_utility.ApiControllerValidateRequest(runtimeProperties.request?.[target_enum.EApiControllerRequestTarget.PARAMETERS], controllerProperties, request.params ?? {});
+        transformData_utility.ApiControllerTransformData(runtimeProperties.request, controllerProperties, { query: request.query }, contextData);
+        await validateRequest_utility.ApiControllerValidateRequest(runtimeProperties.request?.[target_enum.EApiControllerRequestTarget.QUERY], controllerProperties, (request.query ?? {}));
+        transformData_utility.ApiControllerTransformData(runtimeProperties.request, controllerProperties, { body: request.body }, contextData);
+        await validateRequest_utility.ApiControllerValidateRequest(runtimeProperties.request?.[target_enum.EApiControllerRequestTarget.BODY], controllerProperties, request.body ?? {});
+    }
+    static async loadCustomResponseRelations(service, runtimeProperties, response) {
+        if (response === null || typeof response !== "object" || !("id" in response)) {
+            return response;
+        }
+        const responseId = response.id;
+        if (responseId === undefined || responseId === null) {
+            return response;
+        }
+        return await service.get({
+            relations: runtimeProperties.relations?.response?.load?.include,
+            where: {
+                id: responseId,
+            },
+        });
+    }
+    static resolvePrimaryKey(source, entityMetadata) {
+        const primaryKey = primaryColumn_utility.ApiControllerGetPrimaryColumn(source ?? {}, entityMetadata);
+        if (!primaryKey) {
+            throw exception_utility.ErrorException("Primary key not found in entity columns");
+        }
+        return primaryKey;
+    }
+}
+
+exports.ApiRouteRuntime = ApiRouteRuntime;
+//# sourceMappingURL=route-runtime.class.js.map