@gadmin2n/prisma-nest-generator 0.0.20

package/dist/generator/helpers.d.ts

@@ -0,0 +1,32 @@
+import type { DMMF } from '@prisma/generator-helper';
+import type { TemplateHelpers } from './template-helpers';
+import type { ImportStatementParams, Model, ParsedField } from './types';
+export declare const uniq: <T = any>(input: T[]) => T[];
+export declare const concatIntoArray: <T = any>(source: T[], target: T[]) => void;
+export declare const makeImportsFromPrismaClient: (fields: ParsedField[]) => ImportStatementParams | null;
+export declare const mapDMMFToParsedField: (field: DMMF.Field, overrides?: Partial<DMMF.Field>) => ParsedField;
+export declare const getRelationScalars: (fields: DMMF.Field[]) => Record<string, string[]>;
+interface GetRelationConnectInputFieldsParam {
+    field: DMMF.Field;
+    allModels: DMMF.Model[];
+}
+export declare const getRelationConnectInputFields: ({ field, allModels, }: GetRelationConnectInputFieldsParam) => Set<DMMF.Field>;
+export declare const getRelativePath: (from: string, to: string) => string;
+interface GenerateRelationInputParam {
+    field: DMMF.Field;
+    model: Model;
+    allModels: Model[];
+    templateHelpers: TemplateHelpers;
+    preAndSuffixClassName: TemplateHelpers['createDtoName'] | TemplateHelpers['updateDtoName'];
+    canCreateAnnotation: RegExp;
+    canConnectAnnotation: RegExp;
+}
+export declare const generateRelationInput: ({ field, model, allModels, templateHelpers: t, preAndSuffixClassName, canCreateAnnotation, canConnectAnnotation, }: GenerateRelationInputParam) => {
+    type: string;
+    imports: ImportStatementParams[];
+    generatedClasses: string[];
+    apiExtraModels: string[];
+};
+export declare const mergeImportStatements: (first: ImportStatementParams, second: ImportStatementParams) => ImportStatementParams;
+export declare const zipImportStatementParams: (items: ImportStatementParams[]) => ImportStatementParams[];
+export {};

package/dist/generator/helpers.js

@@ -0,0 +1,167 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zipImportStatementParams = exports.mergeImportStatements = exports.generateRelationInput = exports.getRelativePath = exports.getRelationConnectInputFields = exports.getRelationScalars = exports.mapDMMFToParsedField = exports.makeImportsFromPrismaClient = exports.concatIntoArray = exports.uniq = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const slash_1 = __importDefault(require("slash"));
+const field_classifiers_1 = require("./field-classifiers");
+const template_helpers_1 = require("./template-helpers");
+const uniq = (input) => Array.from(new Set(input));
+exports.uniq = uniq;
+const concatIntoArray = (source, target) => source.forEach((item) => target.push(item));
+exports.concatIntoArray = concatIntoArray;
+const makeImportsFromPrismaClient = (fields) => {
+    const enumsToImport = (0, exports.uniq)(fields.filter(({ kind }) => kind === 'enum').map(({ type }) => type));
+    const importPrisma = fields
+        .filter(({ kind }) => kind === 'scalar')
+        .some(({ type }) => (0, template_helpers_1.scalarToTS)(type).includes('Prisma'));
+    if (!(enumsToImport.length || importPrisma)) {
+        return null;
+    }
+    return {
+        from: '@prisma/client',
+        destruct: importPrisma ? ['Prisma', ...enumsToImport] : enumsToImport,
+    };
+};
+exports.makeImportsFromPrismaClient = makeImportsFromPrismaClient;
+const mapDMMFToParsedField = (field, overrides = {}) => ({
+    ...field,
+    ...overrides,
+});
+exports.mapDMMFToParsedField = mapDMMFToParsedField;
+const getRelationScalars = (fields) => {
+    const scalars = fields.flatMap(({ relationFromFields = [] }) => relationFromFields);
+    return scalars.reduce((result, scalar) => ({
+        ...result,
+        [scalar]: fields
+            .filter(({ relationFromFields = [] }) => relationFromFields.includes(scalar))
+            .map(({ name }) => name),
+    }), {});
+};
+exports.getRelationScalars = getRelationScalars;
+const getRelationConnectInputFields = ({ field, allModels, }) => {
+    const { name, type, relationToFields = [] } = field;
+    if (!(0, field_classifiers_1.isRelation)(field)) {
+        throw new Error(`Can not resolve RelationConnectInputFields for field '${name}'. Not a relation field.`);
+    }
+    const relatedModel = allModels.find(({ name: modelName }) => modelName === type);
+    if (!relatedModel) {
+        throw new Error(`Can not resolve RelationConnectInputFields for field '${name}'. Related model '${type}' unknown.`);
+    }
+    if (!relationToFields.length) {
+        throw new Error(`Can not resolve RelationConnectInputFields for field '${name}'. Foreign keys are unknown.`);
+    }
+    const foreignKeyFields = relationToFields.map((relationToFieldName) => {
+        const relatedField = relatedModel.fields.find((relatedModelField) => relatedModelField.name === relationToFieldName);
+        if (!relatedField)
+            throw new Error(`Can not find foreign key field '${relationToFieldName}' on model '${relatedModel.name}'`);
+        return relatedField;
+    });
+    const idFields = relatedModel.fields.filter((relatedModelField) => (0, field_classifiers_1.isId)(relatedModelField));
+    const uniqueFields = relatedModel.fields.filter((relatedModelField) => (0, field_classifiers_1.isUnique)(relatedModelField));
+    const foreignFields = new Set([
+        ...foreignKeyFields,
+        ...idFields,
+        ...uniqueFields,
+    ]);
+    return foreignFields;
+};
+exports.getRelationConnectInputFields = getRelationConnectInputFields;
+const getRelativePath = (from, to) => {
+    const result = (0, slash_1.default)(node_path_1.default.relative(from, to));
+    return result || '.';
+};
+exports.getRelativePath = getRelativePath;
+const generateRelationInput = ({ field, model, allModels, templateHelpers: t, preAndSuffixClassName, canCreateAnnotation, canConnectAnnotation, }) => {
+    const relationInputClassProps = [];
+    const imports = [];
+    const apiExtraModels = [];
+    const generatedClasses = [];
+    if (true || (0, field_classifiers_1.isAnnotatedWith)(field, canCreateAnnotation)) {
+        const preAndPostfixedName = t.createDtoName(field.type);
+        apiExtraModels.push(preAndPostfixedName);
+        const modelToImportFrom = allModels.find(({ name }) => name === field.type);
+        if (!modelToImportFrom)
+            throw new Error(`related model '${field.type}' for '${model.name}.${field.name}' not found`);
+        imports.push({
+            from: (0, slash_1.default)(`${(0, exports.getRelativePath)(model.output.dto, modelToImportFrom.output.dto)}${node_path_1.default.sep}${t.createDtoFilename(field.type)}`),
+            destruct: [preAndPostfixedName],
+        });
+        relationInputClassProps.push({
+            name: 'create',
+            type: preAndPostfixedName,
+        });
+    }
+    if (true || (0, field_classifiers_1.isAnnotatedWith)(field, canConnectAnnotation)) {
+        const preAndPostfixedName = t.connectDtoName(field.type);
+        apiExtraModels.push(preAndPostfixedName);
+        const modelToImportFrom = allModels.find(({ name }) => name === field.type);
+        if (!modelToImportFrom)
+            throw new Error(`related model '${field.type}' for '${model.name}.${field.name}' not found`);
+        imports.push({
+            from: (0, slash_1.default)(`${(0, exports.getRelativePath)(model.output.dto, modelToImportFrom.output.dto)}${node_path_1.default.sep}${t.connectDtoFilename(field.type)}`),
+            destruct: [preAndPostfixedName],
+        });
+        relationInputClassProps.push({
+            name: 'connect',
+            type: preAndPostfixedName,
+        });
+    }
+    if (!relationInputClassProps.length) {
+        throw new Error(`Can not find relation input props for '${model.name}.${field.name}'`);
+    }
+    const originalInputClassName = `${t.transformClassNameCase(model.name)}${t.transformClassNameCase(field.name)}RelationInput`;
+    const preAndPostfixedInputClassName = preAndSuffixClassName(originalInputClassName);
+    generatedClasses.push(`class ${preAndPostfixedInputClassName} {
+    ${t.fieldsToDtoProps(relationInputClassProps.map((inputField) => ({
+        ...inputField,
+        kind: 'relation-input',
+        isRequired: relationInputClassProps.length === 1,
+        isList: field.isList,
+    })), true)}
+  }`);
+    apiExtraModels.push(preAndPostfixedInputClassName);
+    return {
+        type: preAndPostfixedInputClassName,
+        imports,
+        generatedClasses,
+        apiExtraModels,
+    };
+};
+exports.generateRelationInput = generateRelationInput;
+const mergeImportStatements = (first, second) => {
+    if (first.from !== second.from) {
+        throw new Error(`Can not merge import statements; 'from' parameter is different`);
+    }
+    if (first.default && second.default) {
+        throw new Error(`Can not merge import statements; both statements have set the 'default' preoperty`);
+    }
+    const firstDestruct = first.destruct || [];
+    const secondDestruct = second.destruct || [];
+    const destructStrings = (0, exports.uniq)([...firstDestruct, ...secondDestruct].filter((destructItem) => typeof destructItem === 'string'));
+    const destructObject = [...firstDestruct, ...secondDestruct].reduce((result, destructItem) => {
+        if (typeof destructItem === 'string')
+            return result;
+        return { ...result, ...destructItem };
+    }, {});
+    return {
+        ...first,
+        ...second,
+        destruct: [...destructStrings, destructObject],
+    };
+};
+exports.mergeImportStatements = mergeImportStatements;
+const zipImportStatementParams = (items) => {
+    const itemsByFrom = items.reduce((result, item) => {
+        const { from } = item;
+        const { [from]: existingItem } = result;
+        if (!existingItem) {
+            return { ...result, [from]: item };
+        }
+        return { ...result, [from]: (0, exports.mergeImportStatements)(existingItem, item) };
+    }, {});
+    return Object.values(itemsByFrom);
+};
+exports.zipImportStatementParams = zipImportStatementParams;

package/dist/generator/index.d.ts

@@ -0,0 +1,17 @@
+import type { DMMF } from '@prisma/generator-helper';
+import { NamingStyle, WriteableFileSpecs } from './types';
+interface RunParam {
+    output: string;
+    dmmf: DMMF.Document;
+    exportRelationModifierClasses: boolean;
+    outputToNestJsResourceStructure: boolean;
+    connectDtoPrefix: string;
+    createDtoPrefix: string;
+    updateDtoPrefix: string;
+    dtoSuffix: string;
+    entityPrefix: string;
+    entitySuffix: string;
+    fileNamingStyle: NamingStyle;
+}
+export declare const run: ({ output, dmmf, ...options }: RunParam) => WriteableFileSpecs[];
+export {};

package/dist/generator/index.js

@@ -0,0 +1,187 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const case_1 = require("case");
+const sdk_1 = require("@prisma/sdk");
+const template_helpers_1 = require("./template-helpers");
+const compute_model_params_1 = require("./compute-model-params");
+const generate_modules_index_1 = require("./generate-modules-index");
+const generate_connect_dto_1 = require("./generate-connect-dto");
+const generate_create_dto_1 = require("./generate-create-dto");
+const generate_update_dto_1 = require("./generate-update-dto");
+const generate_entity_1 = require("./generate-entity");
+const generate_module_1 = require("./generate-module");
+const generate_service_1 = require("./generate-service");
+const generate_service_spec_1 = require("./generate-service-spec");
+const generate_controller_1 = require("./generate-controller");
+const generate_controller_spec_1 = require("./generate-controller-spec");
+const generate_types_dto_1 = require("./generate-types-dto");
+const generate_form_validator_class_1 = require("./generate-form-validator-class");
+const annotations_1 = require("./annotations");
+const field_classifiers_1 = require("./field-classifiers");
+const helpers_1 = require("./helpers");
+const run = ({ output, dmmf, ...options }) => {
+    const { exportRelationModifierClasses, outputToNestJsResourceStructure, fileNamingStyle = 'camel', ...preAndSuffixes } = options;
+    const transformers = {
+        camel: case_1.camel,
+        kebab: case_1.kebab,
+        pascal: case_1.pascal,
+        snake: case_1.snake,
+    };
+    const transformFileNameCase = transformers[fileNamingStyle];
+    const templateHelpers = (0, template_helpers_1.makeHelpers)({
+        transformFileNameCase,
+        transformClassNameCase: case_1.pascal,
+        ...preAndSuffixes,
+    });
+    const allModels = dmmf.datamodel.models;
+    const filteredModels = allModels
+        .filter((model) => !(0, field_classifiers_1.isAnnotatedWith)(model, annotations_1.DTO_IGNORE_NEST_CODE))
+        .map((model) => ({
+        ...model,
+        output: {
+            dto: outputToNestJsResourceStructure
+                ? node_path_1.default.join(output, transformFileNameCase(model.name), 'dto')
+                : output,
+            entity: outputToNestJsResourceStructure
+                ? node_path_1.default.join(output, transformFileNameCase(model.name), 'entities')
+                : output,
+        },
+    }));
+    const moduleIndexFile = {
+        fileName: node_path_1.default.join(output, 'modules.index.ts'),
+        content: (0, generate_modules_index_1.generateModulesIndex)({
+            allModels: filteredModels,
+            templateHelpers,
+        }),
+    };
+    const modelFiles = filteredModels.map((model) => {
+        sdk_1.logger.info(`Processing Model ${model.name}`);
+        const modelParams = (0, compute_model_params_1.computeModelParams)({
+            model,
+            allModels: filteredModels,
+            templateHelpers,
+        });
+        const connectDto = {
+            fileName: node_path_1.default.join(model.output.dto, templateHelpers.connectDtoFilename(model.name, true)),
+            content: (0, generate_connect_dto_1.generateConnectDto)({
+                ...modelParams.connect,
+                templateHelpers,
+            }),
+        };
+        const createDto = {
+            fileName: node_path_1.default.join(model.output.dto, templateHelpers.createDtoFilename(model.name, true)),
+            content: (0, generate_create_dto_1.generateCreateDto)({
+                ...modelParams.create,
+                exportRelationModifierClasses,
+                templateHelpers,
+            }),
+        };
+        const formValidatorClass = {
+            fileName: node_path_1.default.join(model.output.dto, `${transformFileNameCase(model.name)}.form.validator.ts`),
+            content: (0, generate_form_validator_class_1.generateFormValidatorClass)({
+                ...modelParams.create,
+                exportRelationModifierClasses,
+                templateHelpers,
+            }),
+        };
+        modelParams.update.imports.push({
+            from: '@nestjs/swagger',
+            destruct: ['PartialType'],
+        });
+        modelParams.update.imports.push({
+            from: `./create-${transformFileNameCase(model.name)}.dto`,
+            destruct: [templateHelpers.createDtoName(model.name)],
+        });
+        modelParams.update.imports = (0, helpers_1.zipImportStatementParams)(modelParams.update.imports);
+        const updateDto = {
+            fileName: node_path_1.default.join(model.output.dto, templateHelpers.updateDtoFilename(model.name, true)),
+            content: (0, generate_update_dto_1.generateUpdateDto)({
+                ...modelParams.update,
+                exportRelationModifierClasses,
+                templateHelpers,
+            }),
+        };
+        modelParams.entity.imports.push({
+            from: '@nestjs/swagger',
+            destruct: ['ApiProperty'],
+        });
+        modelParams.entity.imports.push({
+            from: 'class-transformer',
+            destruct: ['Transform'],
+        });
+        modelParams.entity.imports.push({
+            from: '@prisma/client',
+            destruct: [model.name, 'Prisma'],
+        });
+        modelParams.entity.imports = (0, helpers_1.zipImportStatementParams)(modelParams.entity.imports);
+        const entity = {
+            fileName: node_path_1.default.join(model.output.entity, templateHelpers.entityFilename(model.name, true)),
+            content: (0, generate_entity_1.generateEntity)({
+                ...modelParams.entity,
+                templateHelpers,
+            }),
+        };
+        const modelTypes = {
+            fileName: node_path_1.default.join(model.output.dto, `${transformFileNameCase(model.name)}-types.dto.ts`),
+            content: (0, generate_types_dto_1.generateTypesDto)({
+                ...modelParams.entity,
+                templateHelpers,
+            }),
+        };
+        const module = {
+            fileName: node_path_1.default.join(model.output.entity, '..', `${transformFileNameCase(model.name)}.module.ts`),
+            content: (0, generate_module_1.generateModule)({
+                model,
+                templateHelpers,
+            }),
+        };
+        const service = {
+            fileName: node_path_1.default.join(model.output.entity, '..', `${transformFileNameCase(model.name)}.service.ts`),
+            content: (0, generate_service_1.generateService)({
+                model,
+                templateHelpers,
+            }),
+        };
+        const serviceSpec = {
+            fileName: node_path_1.default.join(model.output.entity, '..', `${transformFileNameCase(model.name)}.service.spec.ts`),
+            content: (0, generate_service_spec_1.generateServiceSpec)({
+                model,
+                templateHelpers,
+            }),
+        };
+        const controller = {
+            fileName: node_path_1.default.join(model.output.entity, '..', `${transformFileNameCase(model.name)}.controller.ts`),
+            content: (0, generate_controller_1.generateController)({
+                model,
+                templateHelpers,
+            }),
+        };
+        const controllerSpec = {
+            fileName: node_path_1.default.join(model.output.entity, '..', `${transformFileNameCase(model.name)}.controller.spec.ts`),
+            content: (0, generate_controller_spec_1.generateControllerSpec)({
+                model,
+                templateHelpers,
+            }),
+        };
+        return [
+            connectDto,
+            createDto,
+            updateDto,
+            entity,
+            modelTypes,
+            module,
+            service,
+            serviceSpec,
+            controller,
+            controllerSpec,
+            formValidatorClass,
+        ];
+    });
+    return [...modelFiles, [moduleIndexFile]].flat();
+};
+exports.run = run;

package/dist/generator/template-helpers.d.ts

@@ -0,0 +1,56 @@
+import { ImportStatementParams, ParsedField } from './types';
+export declare const scalarToTS: (scalar: string, useInputTypes?: boolean) => string;
+export declare const echo: (input: string) => string;
+export declare const when: (condition: any, thenTemplate: string, elseTemplate?: string) => string;
+export declare const unless: (condition: any, thenTemplate: string, elseTemplate?: string) => string;
+export declare const each: <T = any>(arr: T[], fn: (item: T) => string, joinWith?: string) => string;
+export declare const importStatement: (input: ImportStatementParams) => string;
+export declare const importStatements: (items: ImportStatementParams[]) => string;
+interface MakeHelpersParam {
+    connectDtoPrefix: string;
+    createDtoPrefix: string;
+    updateDtoPrefix: string;
+    dtoSuffix: string;
+    entityPrefix: string;
+    entitySuffix: string;
+    transformClassNameCase?: (item: string) => string;
+    transformFileNameCase?: (item: string) => string;
+}
+export declare const makeHelpers: ({ connectDtoPrefix, createDtoPrefix, updateDtoPrefix, dtoSuffix, entityPrefix, entitySuffix, transformClassNameCase, transformFileNameCase, }: MakeHelpersParam) => {
+    config: {
+        connectDtoPrefix: string;
+        createDtoPrefix: string;
+        updateDtoPrefix: string;
+        dtoSuffix: string;
+        entityPrefix: string;
+        entitySuffix: string;
+    };
+    apiExtraModels: (names: string[]) => string;
+    entityName: (name: string) => string;
+    connectDtoName: (name: string) => string;
+    createDtoName: (name: string) => string;
+    updateDtoName: (name: string) => string;
+    connectDtoFilename: (name: string, withExtension?: boolean) => string;
+    createDtoFilename: (name: string, withExtension?: boolean) => string;
+    updateDtoFilename: (name: string, withExtension?: boolean) => string;
+    entityFilename: (name: string, withExtension?: boolean) => string;
+    each: <T = any>(arr: T[], fn: (item: T) => string, joinWith?: string) => string;
+    echo: (input: string) => string;
+    fieldsToDtoProps: (fields: ParsedField[], useInputTypes?: boolean, forceOptional?: boolean) => string;
+    fieldToDtoProp: (field: ParsedField, useInputTypes?: boolean, forceOptional?: boolean) => string;
+    fieldToEntityProp: (field: ParsedField) => string;
+    fieldsToEntityProps: (fields: ParsedField[]) => string;
+    fieldToTypesProp: (field: ParsedField) => string;
+    fieldsToTypesProps: (fields: ParsedField[]) => string;
+    fieldType: (field: ParsedField, toInputType?: boolean, forEntity?: boolean) => string;
+    for: <T = any>(arr: T[], fn: (item: T) => string, joinWith?: string) => string;
+    if: (condition: any, thenTemplate: string, elseTemplate?: string) => string;
+    importStatement: (input: ImportStatementParams) => string;
+    importStatements: (items: ImportStatementParams[]) => string;
+    transformClassNameCase: (item: string) => string;
+    transformFileNameCase: (item: string) => string;
+    unless: (condition: any, thenTemplate: string, elseTemplate?: string) => string;
+    when: (condition: any, thenTemplate: string, elseTemplate?: string) => string;
+};
+export declare type TemplateHelpers = ReturnType<typeof makeHelpers>;
+export {};

package/dist/generator/template-helpers.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeHelpers = exports.importStatements = exports.importStatement = exports.each = exports.unless = exports.when = exports.echo = exports.scalarToTS = void 0;
+const PrismaScalarToTypeScript = {
+    String: 'string',
+    Boolean: 'boolean',
+    Int: 'number',
+    BigInt: 'bigint',
+    Float: 'number',
+    Decimal: 'number',
+    DateTime: 'Date',
+    Json: 'Prisma.JsonValue',
+    Bytes: 'Buffer',
+};
+const TSScalarToValidator = {
+    String: '@IsString()',
+    Boolean: '@IsBoolean()',
+    Int: '@IsNumber()',
+    BigInt: '@IsNumber()',
+    Float: '@IsNumber()',
+    Decimal: '@IsNumber()',
+    DateTime: '@IsDate()',
+    Json: '@IsJSON()',
+    Bytes: '',
+};
+const knownPrismaScalarTypes = Object.keys(PrismaScalarToTypeScript);
+const scalarToTS = (scalar, useInputTypes = false) => {
+    if (!knownPrismaScalarTypes.includes(scalar)) {
+        throw new Error(`Unrecognized scalar type: ${scalar}`);
+    }
+    if (useInputTypes && scalar === 'Json') {
+        return 'Prisma.InputJsonValue';
+    }
+    return PrismaScalarToTypeScript[scalar];
+};
+exports.scalarToTS = scalarToTS;
+const echo = (input) => input;
+exports.echo = echo;
+const when = (condition, thenTemplate, elseTemplate = '') => condition ? thenTemplate : elseTemplate;
+exports.when = when;
+const unless = (condition, thenTemplate, elseTemplate = '') => (!condition ? thenTemplate : elseTemplate);
+exports.unless = unless;
+const each = (arr, fn, joinWith = '') => arr.map(fn).join(joinWith);
+exports.each = each;
+const importStatement = (input) => {
+    const { from, destruct = [], default: defaultExport } = input;
+    const fragments = ['import'];
+    if (defaultExport) {
+        if (typeof defaultExport === 'string') {
+            fragments.push(defaultExport);
+        }
+        else {
+            fragments.push(`* as ${defaultExport['*']}`);
+        }
+    }
+    if (destruct.length) {
+        if (defaultExport) {
+            fragments.push(',');
+        }
+        fragments.push(`{${destruct.flatMap((item) => {
+            if (typeof item === 'string')
+                return item;
+            return Object.entries(item).map(([key, value]) => `${key} as ${value}`);
+        })}}`);
+    }
+    fragments.push(`from '${from}'`);
+    return fragments.join(' ');
+};
+exports.importStatement = importStatement;
+const importStatements = (items) => `${(0, exports.each)(items, exports.importStatement, '\n')}`;
+exports.importStatements = importStatements;
+const VALIDATOR_REGEX = /^@Dto\S+\n?/gm;
+const makeHelpers = ({ connectDtoPrefix, createDtoPrefix, updateDtoPrefix, dtoSuffix, entityPrefix, entitySuffix, transformClassNameCase = exports.echo, transformFileNameCase = exports.echo, }) => {
+    const className = (name, prefix = '', suffix = '') => `${prefix}${transformClassNameCase(name)}${suffix}`;
+    const fileName = (name, prefix = '', suffix = '', withExtension = false) => `${prefix}${transformFileNameCase(name)}${suffix}${(0, exports.when)(withExtension, '.ts')}`;
+    const entityName = (name) => className(name, entityPrefix, entitySuffix);
+    const connectDtoName = (name) => className(name, connectDtoPrefix, dtoSuffix);
+    const createDtoName = (name) => className(name, createDtoPrefix, dtoSuffix);
+    const updateDtoName = (name) => className(name, updateDtoPrefix, dtoSuffix);
+    const connectDtoFilename = (name, withExtension = false) => fileName(name, 'connect-', '.dto', withExtension);
+    const createDtoFilename = (name, withExtension = false) => fileName(name, 'create-', '.dto', withExtension);
+    const updateDtoFilename = (name, withExtension = false) => fileName(name, 'update-', '.dto', withExtension);
+    const entityFilename = (name, withExtension = false) => fileName(name, undefined, '.entity', withExtension);
+    const fieldType = (field, toInputType = false, forEntity = false) => `${field.kind === 'scalar'
+        ? (0, exports.scalarToTS)(field.type, toInputType)
+        : field.kind === 'enum' || field.kind === 'relation-input'
+            ? field.type
+            : forEntity
+                ? entityName(field.type)
+                : field.type}${(0, exports.when)(field.isList, '[]')}`;
+    const fieldToDtoProp = (field, useInputTypes = false, forceOptional = false) => {
+        var _a, _b;
+        return `${(0, exports.when)(field.kind === 'enum', `@ApiProperty({ enum: ${fieldType(field, useInputTypes)}})\n`)}${((_a = field.documentation) === null || _a === void 0 ? void 0 : _a.replace(VALIDATOR_REGEX, '').replace(/^@FormItem[\S ]+\n?/gm, '')) || ''}${(0, exports.when)(!field.isRequired || forceOptional || field.hasDefaultValue, '@IsOptional()\n')}${(0, exports.when)((_b = field.documentation) === null || _b === void 0 ? void 0 : _b.replace(VALIDATOR_REGEX, '').match(/^@FormItem[\S ]*\(JSON/gm), '@IsJSON()\n')}${(0, exports.when)(field.kind === 'scalar', `${TSScalarToValidator[field.type]}\n`)}${(0, exports.when)(field.isList, '@ValidateNested()\n')}${field.name}${(0, exports.when)(!field.isRequired || forceOptional || field.hasDefaultValue, '?')}: ${fieldType(field, useInputTypes)};`;
+    };
+    const fieldsToDtoProps = (fields, useInputTypes = false, forceOptional = false) => `${(0, exports.each)(fields, (field) => fieldToDtoProp(field, useInputTypes, forceOptional), '\n')}`;
+    const fieldToEntityProp = (field) => `${field.name}${(0, exports.unless)(field.isRequired, '?')}: ${fieldType(field, false, true)} ${(0, exports.when)(field.isNullable, ' | null')};`;
+    const fieldsToEntityProps = (fields) => `${(0, exports.each)(fields, (field) => fieldToEntityProp(field), '\n')}`;
+    const fieldToTypesProp = (field) => `@IsOptional()\n${field.name}?: object;`;
+    const fieldsToTypesProps = (fields) => `${(0, exports.each)(fields, (field) => fieldToTypesProp(field), '\n\n')}`;
+    const apiExtraModels = (names) => `@ApiExtraModels(${names})`;
+    return {
+        config: {
+            connectDtoPrefix,
+            createDtoPrefix,
+            updateDtoPrefix,
+            dtoSuffix,
+            entityPrefix,
+            entitySuffix,
+        },
+        apiExtraModels,
+        entityName,
+        connectDtoName,
+        createDtoName,
+        updateDtoName,
+        connectDtoFilename,
+        createDtoFilename,
+        updateDtoFilename,
+        entityFilename,
+        each: exports.each,
+        echo: exports.echo,
+        fieldsToDtoProps,
+        fieldToDtoProp,
+        fieldToEntityProp,
+        fieldsToEntityProps,
+        fieldToTypesProp,
+        fieldsToTypesProps,
+        fieldType,
+        for: exports.each,
+        if: exports.when,
+        importStatement: exports.importStatement,
+        importStatements: exports.importStatements,
+        transformClassNameCase,
+        transformFileNameCase,
+        unless: exports.unless,
+        when: exports.when,
+    };
+};
+exports.makeHelpers = makeHelpers;

package/dist/generator/types.d.ts

@@ -0,0 +1,56 @@
+import { DMMF } from '@prisma/generator-helper';
+export interface Model extends DMMF.Model {
+    output: {
+        dto: string;
+        entity: string;
+    };
+}
+export interface ParsedField {
+    kind: DMMF.FieldKind | 'relation-input';
+    name: string;
+    type: string;
+    documentation?: string;
+    isRequired: boolean;
+    isList: boolean;
+    isNullable?: boolean;
+}
+export interface ExtraModel {
+    originalName: string;
+    preAndPostfixedName: string;
+    isLocal?: boolean;
+}
+export interface ImportStatementParams {
+    from: string;
+    default?: string | {
+        '*': string;
+    };
+    destruct?: (string | Record<string, string>)[];
+}
+export interface DtoParams {
+    model: DMMF.Model;
+    fields: ParsedField[];
+    imports: ImportStatementParams[];
+}
+export declare type ConnectDtoParams = Omit<DtoParams, 'imports'>;
+export interface CreateDtoParams extends DtoParams {
+    extraClasses: string[];
+    apiExtraModels: string[];
+}
+export interface UpdateDtoParams extends DtoParams {
+    extraClasses: string[];
+    apiExtraModels: string[];
+}
+export interface EntityParams extends DtoParams {
+    apiExtraModels: string[];
+}
+export interface ModelParams {
+    connect: ConnectDtoParams;
+    create: CreateDtoParams;
+    update: UpdateDtoParams;
+    entity: EntityParams;
+}
+export declare type WriteableFileSpecs = {
+    fileName: string;
+    content: string;
+};
+export declare type NamingStyle = 'snake' | 'camel' | 'pascal' | 'kebab';

package/dist/generator/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import type { GeneratorOptions } from '@prisma/generator-helper';
+export declare const stringToBoolean: (input: string, defaultValue?: boolean) => boolean;
+export declare const generate: (options: GeneratorOptions) => Promise<void[]>;