@weverson_na/prisma-generator-nestjs-dto/dist/generators/compute-model-params/compute-entity-params.js

Advanced Prisma Generator with Smart Merge v2: Creates DTO and Entity classes with AST-based preservation, intelligent import management, and modular architecture for NestJS

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.computeEntityParams = exports.EntityParamsComputer = void 0;
const base_model_params_computer_1 = require("./base-model-params-computer");
const entity_field_config_1 = require("./configs/entity-field-config");
const import_manager_1 = require("./shared/import-manager");
const helpers_1 = require("../helpers/helpers");
const decorator_strategy_1 = require("../decorators/decorator-strategy");
const annotations_1 = require("../annotations");
const field_classifiers_1 = require("../field-classifiers");
class EntityParamsComputer extends base_model_params_computer_1.BaseModelParamsComputer {
    constructor(templateHelpers, customDecoratorConfigsPath) {
        super(templateHelpers, customDecoratorConfigsPath);
        this.customDecoratorConfigsPath = customDecoratorConfigsPath;
        this.fieldConfig = new entity_field_config_1.EntityFieldConfig(templateHelpers);
    }
    getFieldConfig() {
        return this.fieldConfig;
    }
    computeParams(model, allModels, _addExposePropertyDecorator) {
        const imports = [];
        const apiExtraModels = [];
        const relationScalarFields = helpers_1.Helpers.getRelationScalars(model.fields);
        const relationScalarFieldNames = Object.keys(relationScalarFields);
        const fields = model.fields.reduce((result, field) => {
            const { name } = field;
            if (this.fieldConfig.fieldFilters.shouldSkipField(field)) {
                return result;
            }
            const overrides = this.fieldConfig.getFieldOverrides(field);
            if (field.kind === 'object') {
                this.processEntityRelation(field, model, allModels, imports, overrides);
            }
            if (relationScalarFieldNames.includes(name)) {
                this.processRelationScalarField(field, model, relationScalarFields, overrides);
            }
            const decoratorImports = this.processEntityDecorators(field, this.customDecoratorConfigsPath);
            imports.push(...decoratorImports);
            return [...result, helpers_1.Helpers.mapDMMFToParsedField(field, overrides)];
        }, []);
        const finalImports = import_manager_1.ImportManager.finalizeImports(imports, fields, {
            hasApiExtraModels: apiExtraModels.length > 0,
            hasEnum: false,
            hasApiPropertyDoc: false,
        });
        return {
            model,
            fields,
            imports: finalImports,
            apiExtraModels,
        };
    }
    processEntityRelation(field, model, allModels, imports, _overrides) {
        if (field.type !== model.name) {
            const modelToImportFrom = allModels.find((m) => m.name === field.type);
            if (!modelToImportFrom) {
                throw new Error(`related model '${field.type}' for '${model.name}.${field.name}' not found`);
            }
            const importName = this.templateHelpers.entityName(field.type);
            const relPath = helpers_1.Helpers.getRelativePath(model.output.entity, modelToImportFrom.output.entity);
            const importFrom = `${relPath}/${this.templateHelpers.entityFilename(field.type)}`;
            if (!imports.some((item) => Array.isArray(item.destruct) &&
                item.destruct.includes(importName) &&
                item.from === importFrom)) {
                imports.push({
                    destruct: [importName],
                    from: importFrom,
                });
            }
        }
    }
    processRelationScalarField(field, model, relationScalarFields, overrides) {
        const { [field.name]: relationNames } = relationScalarFields;
        const isAnyRelationRequired = relationNames.some((relationFieldName) => {
            const relationField = model.fields.find((anyField) => anyField.name === relationFieldName);
            if (!relationField)
                return false;
            return ((0, field_classifiers_1.isRequired)(relationField) ||
                (0, field_classifiers_1.isAnnotatedWith)(relationField, annotations_1.DTO_RELATION_REQUIRED));
        });
        overrides.isRequired = true;
        overrides.isNullable = !isAnyRelationRequired;
    }
    processEntityDecorators(field, customDecoratorConfigsPath) {
        const decoratorStrategy = new decorator_strategy_1.DecoratorStrategy(customDecoratorConfigsPath);
        const decorators = decoratorStrategy.formatValidDecoratorResultToFromDestruct(decoratorStrategy
            .getValidDecoratorAndImportsByDoc(field === null || field === void 0 ? void 0 : field.documentation)
            .filter((decorator) => decorator.decoratorName.includes('ApiProperty')));
        return decorators;
    }
}
exports.EntityParamsComputer = EntityParamsComputer;
const computeEntityParams = ({ model, allModels, templateHelpers, customDecoratorConfigsPath, }) => {
    const computer = new EntityParamsComputer(templateHelpers, customDecoratorConfigsPath);
    return computer.computeParams(model, allModels);
};
exports.computeEntityParams = computeEntityParams;