@elsikora/nestjs-crud-automator/dist/cjs/class/api/route-runtime.class.js

A library for automating the creation of CRUD operations in NestJS.

'use strict';

require('./controller/generated/get-many-contract.class.js');
var readScopeStorage_class = require('./controller/generated/read-scope-storage.class.js');
var securitySnapshot_class = require('./controller/generated/security-snapshot.class.js');
var functionCapability_class = require('./controller/generated/function-capability.class.js');
var dataSourceContract_class = require('./controller/get-list/cursor/data-source-contract.class.js');
var runtime_class$1 = require('./controller/get-list/cursor/runtime.class.js');
require('./controller/get-list/query/plan-compiler.class.js');
var runtime_class = require('./controller/get-list/query/runtime.class.js');
var contextStorage_class = require('./function/context-storage.class.js');
var runtime_class$2 = require('./function/transaction/runtime.class.js');
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/get-list/query/filter/missing-behavior.enum.js');
var paginationMode_enum = require('../../enum/decorator/api/controller/get-list/query/pagination-mode.enum.js');
require('../../enum/decorator/api/controller/get-list/query/unlisted-fields.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/context-storage-kind.enum.js');
require('../../enum/decorator/api/function/subscriber-transaction-expectation.enum.js');
require('../../enum/decorator/api/function/transaction/event-status.enum.js');
require('../../enum/decorator/api/function/transaction/failure-stage.enum.js');
var mode_enum = require('../../enum/decorator/api/function/transaction/mode.enum.js');
require('../../enum/decorator/api/function/transaction/outcome.enum.js');
var ownerKind_enum = require('../../enum/decorator/api/function/transaction/owner-kind.enum.js');
require('../../enum/decorator/api/function/transaction/trace-type.enum.js');
var type_enum$1 = 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/subscriber-authorization-expectation.enum.js');
var type_enum = require('../../enum/decorator/api/route/type.enum.js');
var common = require('@nestjs/common');
require('../../constant/filter/operator-registry.constant.js');
require('../../enum/filter/operand.enum.js');
require('../../enum/filter/operation.enum.js');
require('../../enum/filter/order-direction.enum.js');
require('@nestjs/swagger');
var exception_utility = require('../../utility/error/exception.utility.js');
var get_utility$1 = require('../../utility/api/controller/get-list/query/plan/get.utility.js');
var getPaginationMode_utility = require('../../utility/api/controller/get-list/query/get-pagination-mode.utility.js');
var resolveCursorOrderFields_utility = require('../../utility/api/controller/get-list/query/resolve-cursor-order-fields.utility.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 get_utility$2 = require('../../utility/api/controller/identity/plan/get.utility.js');
var get_utility = require('../../utility/api/controller/read/plan/get.utility.js');
var scope_utility = require('../../utility/api/controller/read/scope.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');
require('@nestjs/common/constants.js');
require('@nestjs/common/enums/route-paramtypes.enum.js');
require('@nestjs/swagger/dist/constants.js');
var createValidationFailure_utility = require('../../utility/api/route/discriminator/create-validation-failure.utility.js');
var isDtoProperties_utility = require('../../utility/api/route/discriminator/is-dto-properties.utility.js');
var preparePayload_utility = require('../../utility/api/route/discriminator/prepare-payload.utility.js');
var resolveDto_utility = require('../../utility/api/route/discriminator/resolve-dto.utility.js');
require('../metadata-storage.class.js');
require('typeorm');
var projectRelation_utility = require('../../utility/api/route/response/project-relation.utility.js');
var serialize_utility = require('../../utility/api/route/response/serialize.utility.js');
var validationFlattenErrors_utility = require('../../utility/api/route/validation-flatten-errors.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 classTransformer = require('class-transformer');
var classValidator = require('class-validator');

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 (!this.hasResponseRelationInclude(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))));
        }
        const responseValue = response;
        if (responseValue !== null && typeof responseValue === "object" && "items" in responseValue && Array.isArray(responseValue.items)) {
            const responseObject = responseValue;
            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();
        const authorizationDecision = securitySnapshot_class.ApiControllerGeneratedSecuritySnapshot.create(resolveFromRequest_utility.AuthorizationDecisionResolveFromRequest(options.targets.authenticationRequest));
        const beforeContext = {
            DATA: { authorizationDecision: securitySnapshot_class.ApiControllerGeneratedSecuritySnapshot.createSubscriberView(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;
        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 executeDiscriminatedRequestBodyDto(runtimeProperties, request) {
        const bodyDto = runtimeProperties.dto?.[dtoType_enum.EApiDtoType.BODY];
        if (!isDtoProperties_utility.ApiRouteIsDiscriminatedDtoProperties(bodyDto)) {
            return;
        }
        let selectedDto;
        try {
            selectedDto = resolveDto_utility.ApiRouteResolveDiscriminatedDto(bodyDto, request.body, "ApiRouteCustom body");
        }
        catch {
            const validationError = createValidationFailure_utility.ApiRouteCreateDiscriminatedDtoValidationFailure(bodyDto, request.body);
            const validationMessages = validationFlattenErrors_utility.ApiRouteValidationFlattenErrors([validationError]);
            throw new common.BadRequestException(validationMessages);
        }
        const transformedBody = classTransformer.plainToInstance(selectedDto, preparePayload_utility.ApiRoutePrepareDiscriminatedDtoPayload(bodyDto, request.body), bodyDto.transformOptions);
        const validationErrors = await classValidator.validate(transformedBody, bodyDto.validatorOptions);
        if (validationErrors.length > 0) {
            const validationMessages = validationFlattenErrors_utility.ApiRouteValidationFlattenErrors(validationErrors);
            throw new common.BadRequestException(validationMessages);
        }
        request.body = transformedBody;
    }
    static async executeGeneratedErrorSubscribers(options, targets, entityInstance, baseData, authorizationDecision, onType, error) {
        const errorContext = {
            DATA: { ...baseData, authenticationRequest: targets.authenticationRequest, authorizationDecision: securitySnapshot_class.ApiControllerGeneratedSecuritySnapshot.createSubscriberView(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] ?? {};
        const method = options.method;
        if (method === type_enum.EApiRouteType.PARTIAL_UPDATE || method === type_enum.EApiRouteType.UPDATE) {
            await this.executeGeneratedRequestPipeline(options, targets, [target_enum.EApiControllerRequestTarget.PARAMETERS, target_enum.EApiControllerRequestTarget.BODY]);
            const service = options.controller.service;
            const updateFunction = functionCapability_class.ApiControllerGeneratedFunctionCapability.resolve(service, type_enum$1.EApiFunctionType.UPDATE, type_enum$1.EApiFunctionType.UPDATE, options.properties.entity);
            const responseLoad = routeConfig.relations?.response?.load;
            const getFunction = responseLoad && this.hasResponseRelationInclude(responseLoad.include) ? functionCapability_class.ApiControllerGeneratedFunctionCapability.resolve(service, type_enum$1.EApiFunctionType.GET, type_enum$1.EApiFunctionType.GET, options.properties.entity) : undefined;
            return await this.executeGeneratedTransaction(options, routeConfig, async () => await this.executeGeneratedUpdateOperation(options, targets, authorizationDecision, routeConfig, markAfterBoundary, service, updateFunction, getFunction));
        }
        switch (method) {
            case type_enum.EApiRouteType.CREATE: {
                await this.executeGeneratedRequestPipeline(options, targets, [target_enum.EApiControllerRequestTarget.BODY]);
                const service = options.controller.service;
                const getFunction = functionCapability_class.ApiControllerGeneratedFunctionCapability.resolve(service, type_enum$1.EApiFunctionType.GET, type_enum$1.EApiFunctionType.GET, options.properties.entity);
                return await this.executeGeneratedTransaction(options, routeConfig, async () => {
                    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 ?? {}));
                    const requestProperties = {
                        relationLoadStrategy: routeConfig.relations?.response?.load?.relationLoadStrategy,
                        relations: routeConfig.relations?.response?.load?.include,
                        where: scopeMergeWhere_utility.AuthorizationScopeMergeWhere({ [primaryKey.key]: createResponse[primaryKey.key] }, securitySnapshot_class.ApiControllerGeneratedSecuritySnapshot.createMutableScopeWhere(authorizationDecision)),
                    };
                    return await readScopeStorage_class.ApiControllerGeneratedReadScopeStorage.run(type_enum$1.EApiFunctionType.GET, requestProperties, requestProperties.where, async () => await Reflect.apply(getFunction, service, [requestProperties]));
                });
            }
            case type_enum.EApiRouteType.DELETE: {
                await this.executeGeneratedRequestPipeline(options, targets, [target_enum.EApiControllerRequestTarget.PARAMETERS]);
                const service = options.controller.service;
                const deleteFunction = functionCapability_class.ApiControllerGeneratedFunctionCapability.resolve(service, type_enum$1.EApiFunctionType.DELETE, type_enum$1.EApiFunctionType.DELETE, options.properties.entity);
                await this.executeGeneratedTransaction(options, routeConfig, async () => {
                    const primaryKey = this.resolvePrimaryKey(targets.parameters, options.entityMetadata);
                    const requestCriteria = { [primaryKey.key]: primaryKey.value };
                    const scopedCriteria = scopeMergeWhere_utility.AuthorizationScopeMergeWhere(requestCriteria, securitySnapshot_class.ApiControllerGeneratedSecuritySnapshot.createMutableScopeWhere(authorizationDecision));
                    const deleteCriteria = scopedCriteria ?? requestCriteria;
                    markAfterBoundary();
                    await readScopeStorage_class.ApiControllerGeneratedReadScopeStorage.run(type_enum$1.EApiFunctionType.DELETE, deleteCriteria, deleteCriteria, async () => {
                        await Reflect.apply(deleteFunction, service, [deleteCriteria]);
                    });
                });
                return undefined;
            }
            case type_enum.EApiRouteType.GET: {
                await this.executeGeneratedRequestPipeline(options, targets, [target_enum.EApiControllerRequestTarget.PARAMETERS]);
                const service = options.controller.service;
                const getFunction = functionCapability_class.ApiControllerGeneratedFunctionCapability.resolve(service, type_enum$1.EApiFunctionType.GET, type_enum$1.EApiFunctionType.GET, options.properties.entity);
                return await this.executeGeneratedTransaction(options, routeConfig, async () => {
                    const readPlan = get_utility.ApiControllerReadPlanGet(Object.getPrototypeOf(options.controller), options.methodName);
                    const identityPlan = this.resolveIdentityPlan(options.controller, options.methodName);
                    const primaryKey = this.resolveReadIdentity(targets.parameters, options.entityMetadata, identityPlan);
                    const identityWhere = { [primaryKey.key]: primaryKey.value };
                    const routeScopedWhere = readPlan ? scopeMergeWhere_utility.AuthorizationScopeMergeWhere(identityWhere, scope_utility.ApiControllerReadScopeWhere(targets.parameters, readPlan)) : identityWhere;
                    const requestProperties = {
                        relationLoadStrategy: routeConfig.relations?.response?.load?.relationLoadStrategy,
                        relations: routeConfig.relations?.response?.load?.include,
                        where: scopeMergeWhere_utility.AuthorizationScopeMergeWhere(routeScopedWhere, securitySnapshot_class.ApiControllerGeneratedSecuritySnapshot.createMutableScopeWhere(authorizationDecision)),
                    };
                    markAfterBoundary();
                    return await readScopeStorage_class.ApiControllerGeneratedReadScopeStorage.run(type_enum$1.EApiFunctionType.GET, requestProperties, requestProperties.where, async () => await Reflect.apply(getFunction, service, [requestProperties]));
                });
            }
            case type_enum.EApiRouteType.GET_LIST: {
                const readPlan = get_utility.ApiControllerReadPlanGet(Object.getPrototypeOf(options.controller), options.methodName);
                await this.executeGeneratedRequestPipeline(options, targets, readPlan ? [target_enum.EApiControllerRequestTarget.PARAMETERS, target_enum.EApiControllerRequestTarget.QUERY] : [target_enum.EApiControllerRequestTarget.QUERY]);
                const query = targets.query;
                if (!query) {
                    throw exception_utility.ErrorException("Query target is required for GET_LIST routes");
                }
                const queryPlan = get_utility$1.ApiControllerGetListQueryPlanGet(Object.getPrototypeOf(options.controller), options.methodName);
                let cursorPlan;
                if (queryPlan && getPaginationMode_utility.ApiControllerGetListQueryGetPaginationMode(queryPlan) === paginationMode_enum.EApiControllerGetListQueryPaginationMode.CURSOR) {
                    const compiledPlan = queryPlan;
                    if (!compiledPlan.order?.serverFields) {
                        throw exception_utility.ErrorException("CURSOR GET_LIST compiled query plan is unavailable");
                    }
                    cursorPlan = queryPlan;
                }
                const cursorRuntimeQuery = cursorPlan ? runtime_class.ApiControllerGetListQueryRuntime.parse(query, cursorPlan) : undefined;
                const pageRuntimeQuery = !cursorPlan && queryPlan ? runtime_class.ApiControllerGetListQueryRuntime.parse(query, queryPlan) : undefined;
                const runtimeQuery = cursorRuntimeQuery ?? pageRuntimeQuery;
                const service = options.controller.service;
                const getManyFunction = cursorRuntimeQuery ? functionCapability_class.ApiControllerGeneratedFunctionCapability.resolve(service, type_enum$1.EApiFunctionType.GET_MANY, type_enum$1.EApiFunctionType.GET_MANY, options.properties.entity) : undefined;
                const getListFunction = cursorRuntimeQuery ? undefined : functionCapability_class.ApiControllerGeneratedFunctionCapability.resolve(service, type_enum$1.EApiFunctionType.GET_LIST, type_enum$1.EApiFunctionType.GET_LIST, options.properties.entity);
                return await this.executeGeneratedTransaction(options, routeConfig, async (eventManager) => {
                    const generatedQuery = query;
                    const { limit, orderBy, orderDirection, page, ...getListQuery } = generatedQuery;
                    const filter = runtimeQuery?.ast ? runtime_class.ApiControllerGetListQueryRuntime.compileWhere(runtimeQuery.ast) : filter_utility.ApiControllerGetListTransformFilter(runtimeQuery?.filterQuery ?? getListQuery, options.entityMetadata, routeConfig.security?.authentication?.guard);
                    const routeScopedFilter = readPlan ? scopeMergeWhere_utility.AuthorizationScopeMergeWhere(filter, scope_utility.ApiControllerReadScopeWhere(targets.parameters, readPlan)) : filter;
                    const scopedFilter = scopeMergeWhere_utility.AuthorizationScopeMergeWhere(routeScopedFilter, securitySnapshot_class.ApiControllerGeneratedSecuritySnapshot.createMutableScopeWhere(authorizationDecision));
                    const effectiveLimit = runtimeQuery?.limit ?? limit;
                    const effectiveOrderBy = runtimeQuery?.orderBy ?? orderBy;
                    const effectiveOrderDirection = runtimeQuery?.orderDirection ?? orderDirection;
                    const effectivePage = pageRuntimeQuery?.page ?? page;
                    if (cursorRuntimeQuery) {
                        if (!cursorPlan || !cursorRuntimeQuery.ast || !cursorRuntimeQuery.order?.length) {
                            throw exception_utility.ErrorException("Compiled CURSOR GET_LIST query plan is incomplete");
                        }
                        const baseProperties = {
                            relationLoadStrategy: routeConfig.relations?.response?.load?.relationLoadStrategy,
                            relations: routeConfig.relations?.response?.load?.include,
                            where: scopedFilter ?? filter,
                        };
                        const routePath = options.properties.path ?? (options.properties.entity.name ? options.properties.entity.name.toLowerCase() : "UnknownResource");
                        const contextHash = runtime_class$1.ApiControllerGetListCursorRuntime.createContextHash(routePath, targets.parameters, cursorPlan, cursorRuntimeQuery.ast, cursorRuntimeQuery.order, readPlan?.signature);
                        let direction;
                        if (cursorRuntimeQuery.after) {
                            direction = "after";
                        }
                        else if (cursorRuntimeQuery.before) {
                            direction = "before";
                        }
                        const cursor = cursorRuntimeQuery.after ?? cursorRuntimeQuery.before;
                        if (!getManyFunction) {
                            throw exception_utility.ErrorException("Generated CURSOR GET_LIST function capability is not available");
                        }
                        const serviceRepository = service.repository;
                        if (!serviceRepository) {
                            throw exception_utility.ErrorException("Repository is not available in this context");
                        }
                        const activeRepository = eventManager ? eventManager.getRepository(serviceRepository.target) : serviceRepository;
                        const validateStorageValue = dataSourceContract_class.ApiControllerGetListCursorDataSourceContract.createValueValidator(activeRepository, cursorPlan);
                        return await runtime_class$1.ApiControllerGetListCursorRuntime.execute({
                            baseProperties,
                            contextHash,
                            cursor,
                            direction,
                            limit: effectiveLimit,
                            onBeforeQuery: markAfterBoundary,
                            order: cursorRuntimeQuery.order,
                            plan: cursorPlan,
                            run: async (properties) => await readScopeStorage_class.ApiControllerGeneratedReadScopeStorage.run(type_enum$1.EApiFunctionType.GET_MANY, properties, properties.where, async () => await Reflect.apply(getManyFunction, service, [properties])),
                            validateStorageValue,
                        });
                    }
                    if (effectivePage === undefined) {
                        throw exception_utility.ErrorException("Compiled PAGE GET_LIST query plan is incomplete");
                    }
                    const requestProperties = {
                        relationLoadStrategy: routeConfig.relations?.response?.load?.relationLoadStrategy,
                        relations: routeConfig.relations?.response?.load?.include,
                        skip: effectiveLimit * (effectivePage - 1),
                        take: effectiveLimit,
                        where: scopedFilter ?? filter,
                    };
                    if (effectiveOrderBy) {
                        requestProperties.order = { [effectiveOrderBy]: effectiveOrderDirection ?? function_constant.FUNCTION_API_DECORATOR_CONSTANT.DEFAULT_FILTER_ORDER_BY_DIRECTION };
                    }
                    if (runtimeQuery?.order?.length) {
                        requestProperties.order = Object.fromEntries(runtimeQuery.order.map((entry) => [entry.field, entry.direction]));
                    }
                    if (!getListFunction) {
                        throw exception_utility.ErrorException("Generated PAGE GET_LIST function capability is not available");
                    }
                    markAfterBoundary();
                    return await readScopeStorage_class.ApiControllerGeneratedReadScopeStorage.run(type_enum$1.EApiFunctionType.GET_LIST, requestProperties, requestProperties.where, async () => await Reflect.apply(getListFunction, service, [requestProperties]));
                });
            }
        }
    }
    static async executeGeneratedRequestPipeline(options, targets, targetOrder) {
        const routeConfig = options.properties.routes[options.method] ?? {};
        const requestTargets = routeConfig.request;
        const transformTargets = routeConfig.request;
        for (const target of targetOrder) {
            if (target === target_enum.EApiControllerRequestTarget.PARAMETERS) {
                transformData_utility.ApiControllerTransformData(transformTargets, options.properties, { parameters: targets.parameters }, { authenticationRequest: targets.authenticationRequest, headers: targets.headers, ip: targets.ip });
                await validateRequest_utility.ApiControllerValidateRequest(requestTargets?.[target_enum.EApiControllerRequestTarget.PARAMETERS], options.properties, targets.parameters ?? {});
            }
            if (target === target_enum.EApiControllerRequestTarget.QUERY) {
                transformData_utility.ApiControllerTransformData(transformTargets, options.properties, { query: targets.query }, { authenticationRequest: targets.authenticationRequest, headers: targets.headers, ip: targets.ip });
                await validateRequest_utility.ApiControllerValidateRequest(requestTargets?.[target_enum.EApiControllerRequestTarget.QUERY], options.properties, targets.query ?? {});
            }
            if (target === target_enum.EApiControllerRequestTarget.BODY) {
                transformData_utility.ApiControllerTransformData(transformTargets, options.properties, { body: targets.body }, { authenticationRequest: targets.authenticationRequest, headers: targets.headers, ip: targets.ip });
                await validateRequest_utility.ApiControllerValidateRequest(requestTargets?.[target_enum.EApiControllerRequestTarget.BODY], options.properties, (targets.body ?? {}));
            }
        }
    }
    static async executeGeneratedResponse(options, targets, entityInstance, baseData, authorizationDecision, result) {
        const routeConfig = options.properties.routes[options.method] ?? {};
        const queryPlan = options.method === type_enum.EApiRouteType.GET_LIST ? get_utility$1.ApiControllerGetListQueryPlanGet(Object.getPrototypeOf(options.controller), options.methodName) : undefined;
        let cursorOrderFields;
        let cursorResponseSignature;
        if (getPaginationMode_utility.ApiControllerGetListQueryGetPaginationMode(queryPlan) === paginationMode_enum.EApiControllerGetListQueryPaginationMode.CURSOR && queryPlan) {
            const protectedFields = resolveCursorOrderFields_utility.ApiControllerGetListQueryResolveCursorOrderFields(queryPlan.order);
            if (protectedFields.length === 0) {
                throw exception_utility.ErrorException("CURSOR GET_LIST response requires its effective order");
            }
            cursorOrderFields = protectedFields;
            cursorResponseSignature = runtime_class$1.ApiControllerGetListCursorRuntime.createResponseInvariantSignature(result, protectedFields);
        }
        const assertCursorResponseInvariant = (value) => {
            if (cursorOrderFields && cursorResponseSignature) {
                runtime_class$1.ApiControllerGetListCursorRuntime.assertResponseInvariant(value, cursorOrderFields, cursorResponseSignature);
            }
        };
        const responseTarget = { response: result };
        const responseResource = responseTarget.response;
        transformData_utility.ApiControllerTransformData(routeConfig.response, options.properties, responseTarget, { authenticationRequest: targets.authenticationRequest, headers: targets.headers, ip: targets.ip });
        assertCursorResponseInvariant(responseTarget.response);
        const afterContext = {
            DATA: { ...baseData, authenticationRequest: targets.authenticationRequest, authorizationDecision: securitySnapshot_class.ApiControllerGeneratedSecuritySnapshot.createSubscriberView(authorizationDecision, responseResource), 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;
        assertCursorResponseInvariant(finalResponse);
        const transformedResponse = await applyResult_utility.AuthorizationDecisionApplyResult(securitySnapshot_class.ApiControllerGeneratedSecuritySnapshot.withResource(authorizationDecision, finalResponse), finalResponse);
        assertCursorResponseInvariant(transformedResponse);
        const identityPlan = this.resolveIdentityPlan(options.controller, options.methodName);
        const dto = dto_utility.ApiControllerGetDtoWithReadPlan(options.properties, options.entityMetadata, options.method, dtoType_enum.EApiDtoType.RESPONSE, routeConfig, queryPlan, undefined, identityPlan);
        const projectedResponse = projectRelation_utility.ApiRouteProjectRelationResponse(routeConfig.relations?.response, transformedResponse);
        assertCursorResponseInvariant(projectedResponse);
        const serializedResponse = serializeRouteResponse_utility.ApiControllerSerializeRouteResponse(routeConfig, dto, projectedResponse);
        if (cursorOrderFields && cursorResponseSignature) {
            const wireResponse = classTransformer.instanceToPlain(serializedResponse);
            assertCursorResponseInvariant(wireResponse);
            return wireResponse;
        }
        return serializedResponse;
    }
    static async executeGeneratedTransaction(options, routeConfig, callback) {
        const mode = routeConfig.transaction?.mode ?? mode_enum.EApiFunctionTransactionMode.SUPPORTS;
        const activeEventManager = contextStorage_class.ApiFunctionContextStorage.getTransactionRegistry() ? contextStorage_class.ApiFunctionContextStorage.getEventManager() : undefined;
        if (mode === mode_enum.EApiFunctionTransactionMode.NONE && activeEventManager) {
            throw exception_utility.ErrorException("ApiRoute generated transaction mode NONE cannot run inside an active transaction");
        }
        if (mode === mode_enum.EApiFunctionTransactionMode.MANDATORY && !activeEventManager) {
            throw exception_utility.ErrorException("ApiRoute generated transaction mode MANDATORY requires an active transaction");
        }
        if (mode === mode_enum.EApiFunctionTransactionMode.REQUIRED && !activeEventManager) {
            const repository = options.controller.service.repository;
            if (!repository) {
                throw exception_utility.ErrorException("Repository is not available in this context");
            }
            return await runtime_class$2.ApiFunctionTransactionRuntime.execute({
                callback,
                dataSource: repository.manager.connection,
                owner: {
                    entityName: options.properties.entity.name ?? options.entityMetadata.tableName,
                    kind: ownerKind_enum.EApiFunctionTransactionOwnerKind.ROUTE,
                    methodName: options.methodName,
                    routeType: options.method,
                },
            });
        }
        return await callback(activeEventManager);
    }
    static async executeGeneratedUpdateOperation(options, targets, authorizationDecision, routeConfig, markAfterBoundary, service, updateFunction, getFunction) {
        const responseLoad = routeConfig.relations?.response?.load;
        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, securitySnapshot_class.ApiControllerGeneratedSecuritySnapshot.createMutableScopeWhere(authorizationDecision));
        const updateCriteria = scopedCriteria ?? requestCriteria;
        markAfterBoundary();
        const updateResponse = await readScopeStorage_class.ApiControllerGeneratedReadScopeStorage.run(type_enum$1.EApiFunctionType.UPDATE, updateCriteria, updateCriteria, async () => await Reflect.apply(updateFunction, service, [updateCriteria, (targets.body ?? {})]));
        if (!responseLoad || !getFunction) {
            return updateResponse;
        }
        const requestProperties = {
            relationLoadStrategy: responseLoad.relationLoadStrategy,
            relations: responseLoad.include,
            where: scopeMergeWhere_utility.AuthorizationScopeMergeWhere({ [primaryKey.key]: updateResponse[primaryKey.key] }, securitySnapshot_class.ApiControllerGeneratedSecuritySnapshot.createMutableScopeWhere(authorizationDecision)),
        };
        return await readScopeStorage_class.ApiControllerGeneratedReadScopeStorage.run(type_enum$1.EApiFunctionType.GET, requestProperties, requestProperties.where, async () => await Reflect.apply(getFunction, service, [requestProperties]));
    }
    static async executeRequestTargets(metadata, runtimeProperties, request, contextData) {
        const controllerProperties = {
            entity: metadata.resource.entity};
        const requestTargets = runtimeProperties.request;
        transformData_utility.ApiControllerTransformData(runtimeProperties.request, controllerProperties, { parameters: request.params }, contextData);
        await validateRequest_utility.ApiControllerValidateRequest(requestTargets?.[target_enum.EApiControllerRequestTarget.PARAMETERS], controllerProperties, request.params ?? {});
        transformData_utility.ApiControllerTransformData(runtimeProperties.request, controllerProperties, { query: request.query }, contextData);
        await validateRequest_utility.ApiControllerValidateRequest(requestTargets?.[target_enum.EApiControllerRequestTarget.QUERY], controllerProperties, request.query ?? {});
        transformData_utility.ApiControllerTransformData(runtimeProperties.request, controllerProperties, { body: request.body }, contextData);
        await validateRequest_utility.ApiControllerValidateRequest(requestTargets?.[target_enum.EApiControllerRequestTarget.BODY], controllerProperties, request.body ?? {});
        await this.executeDiscriminatedRequestBodyDto(runtimeProperties, request);
    }
    /**
     * Checks whether response relation loading has at least one configured include key.
     * @param {unknown} include - Response include map.
     * @returns {boolean} Whether response relation loading should run.
     */
    static hasResponseRelationInclude(include) {
        return include !== null && typeof include === "object" && Object.keys(include).length > 0;
    }
    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({
            relationLoadStrategy: runtimeProperties.relations?.response?.load?.relationLoadStrategy,
            relations: runtimeProperties.relations?.response?.load?.include,
            where: {
                id: responseId,
            },
        });
    }
    static resolveIdentityPlan(controller, methodName) {
        const handler = Reflect.get(controller, methodName);
        return typeof handler === "function" ? get_utility$2.ApiControllerIdentityPlanGet(handler) : undefined;
    }
    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;
    }
    static resolveReadIdentity(source, entityMetadata, identityPlan) {
        if (!identityPlan) {
            return this.resolvePrimaryKey(source, entityMetadata);
        }
        const parameters = source;
        if (!parameters || !Object.hasOwn(parameters, identityPlan.parameter)) {
            throw new common.BadRequestException("INVALID_PARAMETERS");
        }
        const value = parameters[identityPlan.parameter];
        if (value === undefined || value === null) {
            throw new common.BadRequestException("INVALID_PARAMETERS");
        }
        return {
            key: identityPlan.field,
            value: value,
        };
    }
}

exports.ApiRouteRuntime = ApiRouteRuntime;
//# sourceMappingURL=route-runtime.class.js.map