@weverson_na/prisma-generator-nestjs-dto/dist/generators/compute-model-params/shared/field-processor.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.FieldProcessor = void 0;
const helpers_1 = require("../../helpers/helpers");
const decorator_strategy_1 = require("../../decorators/decorator-strategy");
const field_classifiers_1 = require("../../field-classifiers");
class FieldProcessor {
    constructor(templateHelpers, customDecoratorConfigsPath) {
        this.templateHelpers = templateHelpers;
        this.customDecoratorConfigsPath = customDecoratorConfigsPath;
        this.helpers = new helpers_1.Helpers(new decorator_strategy_1.DecoratorStrategy(customDecoratorConfigsPath));
    }
    hasImport(imports, decoratorToVerify = 'Expose') {
        return imports.some(({ destruct }) => destruct === null || destruct === void 0 ? void 0 : destruct.some((d) => typeof d === 'string'
            ? d === decoratorToVerify
            : Object.values(d).includes(decoratorToVerify)));
    }
    addImport(imports, from, destruct) {
        var _a;
        const existingImport = imports.find((imp) => imp.from === from);
        if (existingImport) {
            (_a = existingImport.destruct) === null || _a === void 0 ? void 0 : _a.push(...destruct);
        }
        else {
            imports.push({ from, destruct });
        }
    }
    processFields(model, allModels, config, addExposePropertyDecorator) {
        let hasEnum = false;
        const imports = [];
        const apiExtraModels = [];
        const extraClasses = [];
        const relationScalarFields = helpers_1.Helpers.getRelationScalars(model.fields);
        const relationScalarFieldNames = Object.keys(relationScalarFields);
        const fields = model.fields.reduce((result, field) => {
            const { name } = field;
            const overrides = config.getFieldOverrides(field);
            if (config.fieldFilters.shouldSkipField(field)) {
                return result;
            }
            if (this.isRelationField(field)) {
                const relationResult = this.processRelationField(field, model, allModels, config, addExposePropertyDecorator, overrides);
                if (!relationResult)
                    return result;
                helpers_1.Helpers.concatIntoArray(relationResult.imports, imports);
                helpers_1.Helpers.concatIntoArray(relationResult.extraClasses, extraClasses);
                helpers_1.Helpers.concatIntoArray(relationResult.apiExtraModels, apiExtraModels);
                Object.assign(overrides, relationResult.overrides);
            }
            if (relationScalarFieldNames.includes(name)) {
                return result;
            }
            if (config.optionalAnnotation &&
                config.fieldFilters.shouldProcessOptional) {
                this.processOptionalField(field, config, overrides);
            }
            if (field.kind === 'enum') {
                hasEnum = true;
            }
            const decoratorImports = this.processCustomDecorators(field, this.customDecoratorConfigsPath);
            imports.push(...decoratorImports);
            if (addExposePropertyDecorator && !this.hasImport(imports)) {
                this.addImport(imports, 'class-transformer', ['Expose']);
            }
            return [...result, helpers_1.Helpers.mapDMMFToParsedField(field, overrides)];
        }, []);
        return {
            fields,
            imports,
            extraClasses,
            apiExtraModels,
            hasEnum,
        };
    }
    isRelationField(field) {
        return field.kind === 'object';
    }
    processRelationField(field, model, allModels, config, addExposePropertyDecorator, overrides) {
        if (!(0, field_classifiers_1.isAnnotatedWithOneOf)(field, config.relationModifiers)) {
            return null;
        }
        const relationInputType = this.helpers.generateRelationInput({
            field,
            model,
            allModels,
            templateHelpers: this.templateHelpers,
            preAndSuffixClassName: config.dtoNameGenerator,
            canCreateAnnotation: config.canCreateAnnotation,
            canConnectAnnotation: config.canConnectAnnotation,
            addExposePropertyDecorator,
        });
        return {
            imports: relationInputType.imports,
            extraClasses: relationInputType.generatedClasses,
            apiExtraModels: relationInputType.apiExtraModels,
            overrides: {
                ...overrides,
                type: relationInputType.type,
                isList: false,
            },
        };
    }
    processOptionalField(field, config, overrides) {
        if (!config.optionalAnnotation ||
            !config.fieldFilters.shouldProcessOptional) {
            return;
        }
        const isDtoOptional = (0, field_classifiers_1.isAnnotatedWith)(field, config.optionalAnnotation);
        if (isDtoOptional) {
            overrides.isRequired = false;
        }
        else if (config.fieldFilters.shouldProcessOptional(field)) {
            overrides.isRequired = config.fieldFilters.shouldProcessOptional(field);
        }
    }
    processCustomDecorators(field, customDecoratorConfigsPath) {
        const decoratorStrategy = new decorator_strategy_1.DecoratorStrategy(customDecoratorConfigsPath);
        const validDecorators = decoratorStrategy.getValidDecoratorAndImportsByDoc(field === null || field === void 0 ? void 0 : field.documentation);
        const decorators = decoratorStrategy.formatValidDecoratorResultToFromDestruct(validDecorators);
        return decorators;
    }
}
exports.FieldProcessor = FieldProcessor;