@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('node:crypto');
var function_constant = require('../../constant/decorator/api/function.constant.js');
require('../../constant/filter/operator-registry.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');
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');
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');
require('../../enum/filter/operand.enum.js');
require('../../enum/filter/operation.enum.js');
require('../../enum/filter/order-direction.enum.js');
require('../../constant/interface/api/property/default-string-format.constant.js');
var exception_utility = require('../../utility/error/exception.utility.js');
require('typeorm');
require('reflect-metadata');
require('../../constant/utility/dto/constant.js');
require('../metadata-storage.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$1 = require('./function/transaction/runtime.class.js');
var serviceBase_class = require('./service-base.class.js');
var executor_class = require('./subscriber/executor.class.js');
var common = require('@nestjs/common');
require('@nestjs/swagger');
var get_utility = require('../../utility/api/controller/get-list/query/plan/get.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 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');
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();
        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 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, 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]);
            return await this.executeGeneratedTransaction(options, routeConfig, async () => await this.executeGeneratedUpdateOperation(options, targets, authorizationDecision, routeConfig, markAfterBoundary));
        }
        switch (method) {
            case type_enum.EApiRouteType.CREATE: {
                await this.executeGeneratedRequestPipeline(options, targets, [target_enum.EApiControllerRequestTarget.BODY]);
                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 ?? {}));
                    return await options.controller.service.get({
                        relationLoadStrategy: routeConfig.relations?.response?.load?.relationLoadStrategy,
                        relations: routeConfig.relations?.response?.load?.include,
                        where: scopeMergeWhere_utility.AuthorizationScopeMergeWhere({ [primaryKey.key]: createResponse[primaryKey.key] }, authorizationDecision?.scope?.where),
                    });
                });
            }
            case type_enum.EApiRouteType.DELETE: {
                await this.executeGeneratedRequestPipeline(options, targets, [target_enum.EApiControllerRequestTarget.PARAMETERS]);
                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, authorizationDecision?.scope?.where);
                    markAfterBoundary();
                    await options.controller.service.delete(scopedCriteria ?? requestCriteria);
                });
                return undefined;
            }
            case type_enum.EApiRouteType.GET: {
                await this.executeGeneratedRequestPipeline(options, targets, [target_enum.EApiControllerRequestTarget.PARAMETERS]);
                return await this.executeGeneratedTransaction(options, routeConfig, async () => {
                    const primaryKey = this.resolvePrimaryKey(targets.parameters, options.entityMetadata);
                    const requestProperties = {
                        relationLoadStrategy: routeConfig.relations?.response?.load?.relationLoadStrategy,
                        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 type_enum.EApiRouteType.GET_LIST: {
                await this.executeGeneratedRequestPipeline(options, targets, [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.ApiControllerGetListQueryPlanGet(Object.getPrototypeOf(options.controller), options.methodName);
                const runtimeQuery = queryPlan ? runtime_class.ApiControllerGetListQueryRuntime.parse(query, queryPlan) : undefined;
                return await this.executeGeneratedTransaction(options, routeConfig, async () => {
                    const { limit, orderBy, orderDirection, page, ...getListQuery } = query;
                    const filter = runtimeQuery?.ast ? runtime_class.ApiControllerGetListQueryRuntime.compileWhere(runtimeQuery.ast) : filter_utility.ApiControllerGetListTransformFilter(runtimeQuery?.filterQuery ?? getListQuery, options.entityMetadata, routeConfig.security?.authentication?.guard);
                    const scopedFilter = scopeMergeWhere_utility.AuthorizationScopeMergeWhere(filter, authorizationDecision?.scope?.where);
                    const effectiveLimit = runtimeQuery?.limit ?? limit;
                    const effectiveOrderBy = runtimeQuery?.orderBy ?? orderBy;
                    const effectiveOrderDirection = runtimeQuery?.orderDirection ?? orderDirection;
                    const effectivePage = runtimeQuery?.page ?? page;
                    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 };
                    }
                    markAfterBoundary();
                    return await options.controller.service.getList(requestProperties);
                });
            }
        }
    }
    static async executeGeneratedRequestPipeline(options, targets, targetOrder) {
        const routeConfig = options.properties.routes[options.method] ?? {};
        const requestTargets = routeConfig.request;
        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(requestTargets?.[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(requestTargets?.[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(requestTargets?.[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 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$1.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();
    }
    static async executeGeneratedUpdateOperation(options, targets, authorizationDecision, routeConfig, markAfterBoundary) {
        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 ?? {}));
        const responseLoad = routeConfig.relations?.response?.load;
        if (!responseLoad || !this.hasResponseRelationInclude(responseLoad.include)) {
            return updateResponse;
        }
        return await options.controller.service.get({
            relationLoadStrategy: responseLoad.relationLoadStrategy,
            relations: responseLoad.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};
        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 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