@weverson_na/prisma-generator-nestjs-dto/dist/generators/compute-model-params/compute-create-dto-params-new.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.computeCreateDtoParams = exports.CreateDtoParamsComputer = void 0;
const annotations_1 = require("../annotations");
const field_classifiers_1 = require("../field-classifiers");
const base_model_params_computer_1 = require("./base-model-params-computer");
const array_helper_1 = require("../helpers/array-helper");
const import_statement_merger_1 = require("../helpers/import-statement-merger");
const prisma_client_import_helper_1 = require("../helpers/prisma-client-import-helper");
const relation_field_helper_1 = require("../helpers/relation-field-helper");
const template_utilities_1 = require("../template-helpers/template-utilities");
const helpers_1 = require("../helpers");
const decorator_strategy_1 = require("../decorator-strategy");
class CreateDtoParamsComputer extends base_model_params_computer_1.BaseModelParamsComputer {
    constructor(templateHelpers) {
        super(templateHelpers);
        this.helpers = new helpers_1.Helpers(new decorator_strategy_1.DecoratorStrategy());
    }
    computeParams(model, allModels, addExposePropertyDecorator) {
        let hasEnum = false;
        const imports = [];
        const apiExtraModels = [];
        const extraClasses = [];
        const relationScalarFields = relation_field_helper_1.RelationFieldHelper.getRelationScalars(model.fields);
        const relationScalarFieldNames = Object.keys(relationScalarFields);
        const fields = model.fields.reduce((result, field) => {
            const { name } = field;
            const overrides = {};
            if ((0, field_classifiers_1.isReadOnly)(field))
                return result;
            if ((0, field_classifiers_1.isRelation)(field)) {
                if (!(0, field_classifiers_1.isAnnotatedWithOneOf)(field, annotations_1.DTO_RELATION_MODIFIERS_ON_CREATE)) {
                    return result;
                }
                const relationInputType = this.helpers.generateRelationInput({
                    field,
                    model,
                    allModels,
                    templateHelpers: this.templateHelpers,
                    preAndSuffixClassName: (name) => this.templateHelpers.createDtoName(name),
                    canCreateAnnotation: annotations_1.DTO_RELATION_CAN_CRAEATE_ON_CREATE,
                    canConnectAnnotation: annotations_1.DTO_RELATION_CAN_CONNECT_ON_CREATE,
                    addExposePropertyDecorator,
                });
                const isDtoRelationRequired = (0, field_classifiers_1.isAnnotatedWith)(field, annotations_1.DTO_RELATION_REQUIRED);
                if (isDtoRelationRequired)
                    overrides.isRequired = true;
                if (field.isList)
                    overrides.isRequired = false;
                overrides.type = relationInputType.type;
                overrides.isList = false;
                array_helper_1.ArrayHelper.concatIntoArray(relationInputType.imports, imports);
                array_helper_1.ArrayHelper.concatIntoArray(relationInputType.generatedClasses, extraClasses);
                array_helper_1.ArrayHelper.concatIntoArray(relationInputType.apiExtraModels, apiExtraModels);
            }
            if (relationScalarFieldNames.includes(name))
                return result;
            const isDtoOptional = (0, field_classifiers_1.isAnnotatedWith)(field, annotations_1.DTO_CREATE_OPTIONAL);
            if (!isDtoOptional) {
                if ((0, field_classifiers_1.isIdWithDefaultValue)(field))
                    return result;
                if ((0, field_classifiers_1.isUpdatedAt)(field))
                    return result;
                if ((0, field_classifiers_1.isRequiredWithDefaultValue)(field))
                    return result;
            }
            if (isDtoOptional) {
                overrides.isRequired = false;
            }
            if (field.kind === 'enum')
                hasEnum = true;
            return [...result, helpers_1.Helpers.mapDMMFToParsedField(field, overrides)];
        }, []);
        const hasApiPropertyDoc = template_utilities_1.TemplateUtilities.hasSomeApiPropertyDoc(fields);
        if (apiExtraModels.length || hasEnum || hasApiPropertyDoc) {
            const destruct = [];
            if (apiExtraModels.length)
                destruct.push('ApiExtraModels');
            if (hasEnum)
                destruct.push('ApiProperty');
            if (hasApiPropertyDoc) {
                destruct.push('ApiProperty');
            }
            imports.unshift({ from: '@nestjs/swagger', destruct });
        }
        const importPrismaClient = prisma_client_import_helper_1.PrismaClientImportHelper.makeImportsFromPrismaClient(fields);
        if (importPrismaClient)
            imports.unshift(importPrismaClient);
        return {
            model,
            fields,
            imports: import_statement_merger_1.ImportStatementMerger.zipImportStatementParams(imports),
            extraClasses,
            apiExtraModels,
        };
    }
}
exports.CreateDtoParamsComputer = CreateDtoParamsComputer;
const computeCreateDtoParams = (params) => {
    const { model, allModels, templateHelpers, addExposePropertyDecorator } = params;
    const computer = new CreateDtoParamsComputer(templateHelpers);
    return computer.computeParams(model, allModels, addExposePropertyDecorator);
};
exports.computeCreateDtoParams = computeCreateDtoParams;