nest-prisma_doc-gen 1.0.18 → 1.0.20

package/dist/entities/dto-generator.js

@@ -1,30 +1,23 @@
-import { DocGenFile } from "../file.js";
 import { Helper } from "../utils/helpers.js";
 import { Static } from "../static.js";
 import { DocGenField } from "./field.js";
+import { config } from "../utils/loader.js";
 export class DocGenDto {
     name;
-    file;
+    // file: DocGenFile;
     fields = [];
-    imports = new Set([
-        `${Static.AUTO_GENERATED_COMMENT}`,
-        `import { ApiProperty, IntersectionType } from '@nestjs/swagger'`,
-        `import { DefaultIdDtoDG } from '../generic.dto'`,
-    ]);
+    imports = new Set([`${Static.AUTO_GENERATED_COMMENT}`, `import { ApiProperty } from '@nestjs/swagger'`]);
     classValidators = new Set();
     enums = new Set();
     constructor(model) {
         this.name = model.name;
+        this.classValidators.add("IsString");
+        this.classValidators.add("IsNotEmpty");
         for (const field of model.fields) {
             if (field.isUpdatedAt || field.isId || field.name === "createdAt" || field.kind === "object")
                 continue;
             this.fields.push(new DocGenField(field, "dto"));
         }
-        this.file = new DocGenFile({
-            dir: "/dto",
-            fileName: `${Helper.toKebab(this.name)}.dto.ts`,
-            data: this.build(),
-        });
     }
     build() {
         const sanitizedFields = this.fields
@@ -46,16 +39,19 @@ export class DocGenDto {
             this.classValidators.add("IsEnum");
             this.imports.add(`import { ${Array.from(this.enums)} } from '@prisma/client';`);
         }
-        this.imports.add(`import { ${Array.from(this.classValidators)} } from 'src/_core/validators';`);
+        this.imports.add(`import { ${Array.from(this.classValidators)} } from '${config.validatorPath}';`);
         return [
             `${Array.from(this.imports).join("\n")}`,
-            `export class ${this.name}DtoDG {
+            `class ${this.name}Dto {
         ${sanitizedFields}
       }`,
-            `export class ${this.name}WithIdDtoDG extends IntersectionType(
-        ${this.name}DtoDG,
-        DefaultIdDtoDG,
-      ) {}`,
+            `class ${this.name}Id {
+        @ApiProperty({ type: 'string', example: 'cmfxu4njg000008l52v7t8qze', required: true })
+        @IsString()
+        @IsNotEmpty()
+        ${this.name.toLocaleLowerCase()}Id!: string;
+      }
+      `,
         ].join("\n\n");
     }
 }

package/dist/entities/field.js

@@ -79,7 +79,7 @@ export class DocGenField {
         }
         else if (this.kind === "object") {
             this.isResponse = true;
-            this.type = `${this.scalarType}ResDG`;
+            this.type = `${this.scalarType}Res`;
         }
         else if (this.kind === "scalar") {
             this.type = Helper.prismaScalarToTs(this.scalarType);

package/dist/entities/generic.js

@@ -1,13 +1,14 @@
 import { DocGenFile } from "../file.js";
+import { config } from "../utils/loader.js";
 export class DocGenGeneric {
     file;
     constructor() {
         const imports = `
       import { ApiProperty } from '@nestjs/swagger';
-      import { IsString, IsNotEmpty } from 'src/_core/validators';
+      import { IsString, IsNotEmpty } from '${config.validatorPath}';
     `;
         const validatorProps = `
-      export class DefaultIdDtoDG {
+      export class DefaultIdDto {
         @ApiProperty({ type: 'string', example: 'cmfxu4njg000008l52v7t8qze', required: true })
         @IsString()
         @IsNotEmpty()

package/dist/entities/model.js

@@ -1,18 +1,35 @@
+import { DocGenFile } from "../file.js";
+import { Helper } from "../utils/helpers.js";
 import { DocGenDto } from "./dto-generator.js";
 import { DocGenResponse } from "./response-generator.js";
 export class DocGenModel {
     name;
-    responses;
-    dtos;
+    response;
+    dto;
     fields;
+    exports;
+    file;
     constructor(model) {
         this.name = model.name;
         this.fields = model.fields;
-        this.responses = new DocGenResponse(model);
-        this.dtos = new DocGenDto(model);
+        this.response = new DocGenResponse(model);
+        this.dto = new DocGenDto(model);
+        this.exports = [`export * from './types/${Helper.toKebab(this.name)}'`];
+        const intaaa = `
+      export namespace ${this.name} {
+        export type Dto = ${this.name}Dto;
+        export type Res = ${this.name}Res;
+        export type Id = ${this.name}Id;
+      }
+    `;
+        const data = [this.dto.build(), this.response.build(), intaaa].join("");
+        this.file = new DocGenFile({
+            dir: "/types",
+            fileName: `${Helper.toKebab(this.name)}.ts`,
+            data,
+        });
     }
     save() {
-        this.responses.file.save();
-        this.dtos.file.save();
+        this.file.save();
     }
 }

package/dist/entities/response-generator.js

@@ -1,12 +1,8 @@
-import { DocGenFile } from "../file.js";
-import { Helper } from "../utils/helpers.js";
-import { Static } from "../static.js";
 import { DocGenField } from "./field.js";
 export class DocGenResponse {
     name;
-    file;
+    // file: DocGenFile;
     fields = [];
-    imports = new Set([`${Static.AUTO_GENERATED_COMMENT}`, `import { ApiProperty } from '@nestjs/swagger'`]);
     enums = new Set();
     constructor(model) {
         this.name = model.name;
@@ -15,31 +11,18 @@ export class DocGenResponse {
                 continue;
             this.fields.push(new DocGenField(field, "res"));
         }
-        this.file = new DocGenFile({
-            dir: "/res",
-            fileName: `${Helper.toKebab(this.name)}.res.ts`,
-            data: this.build(),
-        });
     }
     build() {
         const sanitizedFields = this.fields
             .map((field) => {
-            if (field.isResponse) {
-                this.imports.add(`import { ${field.type} } from './${Helper.toKebab(field.scalarType)}.res'`);
-                this.imports.add(`import { generateExample } from 'src/utils/functions/reflect'`);
-            }
-            else if (field.isEnum) {
+            if (field.isEnum) {
                 this.enums.add(field.type);
             }
             return field.build();
         })
             .join("\n\n");
-        if (this.enums.size > 0) {
-            this.imports.add(`import { ${Array.from(this.enums)} } from '@prisma/client';`);
-        }
         return [
-            `${Array.from(this.imports).join("\n")}`,
-            `export class ${this.name}ResDG {
+            `class ${this.name}Res {
         ${sanitizedFields}
       }`,
         ].join("\n\n");

package/dist/file.js

@@ -2,6 +2,7 @@ import { promises as fs } from "node:fs";
 import * as path from "node:path";
 import * as prettier from "prettier";
 const ROOT = process.cwd();
+console.log(ROOT);
 const OUT_DIR = path.join(ROOT, "src/types/docgen");
 export class DocGenFile {
     outDir;

package/dist/main.js

@@ -5,6 +5,8 @@ import { DocFields } from "./field.type.js";
 import prismaPkg from "@prisma/internals";
 import { PrismaUtils } from "./utils/prisma-utils.js";
 import { DocGenGeneric } from "./entities/generic.js";
+import { DocGenFile } from "./file.js";
+import { Helper } from "./utils/helpers.js";
 const { getDMMF } = prismaPkg;
 const ROOT = process.cwd();
 const PRISMA_DIR = path.join(ROOT, "src");
@@ -15,18 +17,11 @@ export class DocGen {
     fields;
     models;
     generic = new DocGenGeneric();
+    indexFile;
+    fieldFile;
     async init() {
         const prismaDataModel = await PrismaUtils.readPrismaFolderDatamodel(PRISMA_DIR);
         const { datamodel } = await getDMMF({ datamodel: prismaDataModel });
-        // this.enums = new DocEnums(
-        //   datamodel.enums.map(({ dbName, name, values }) => {
-        //     return new DocGenEnum({
-        //       dbName: dbName ?? "",
-        //       name,
-        //       values: values as EnumValue[],
-        //     });
-        //   })
-        // );
         const fieldSet = new Set();
         for (const model of datamodel.models) {
             for (const field of model.fields) {
@@ -42,9 +37,65 @@ export class DocGen {
     build() {
         this.generic.build();
         this.fields.file.save();
+        const indexFileData = [`export * from './fields.types'`];
+        const fields = [];
+        const enumsSet = new Set();
+        const classValidatorsSet = new Set();
         for (const model of this.models) {
+            indexFileData.push(...model.exports);
+            fields.push(...model.dto.fields);
+            for (const e of model.dto.enums) {
+                enumsSet.add(e);
+            }
+            for (const classValidator of model.dto.classValidators) {
+                classValidatorsSet.add(classValidator);
+            }
             model.save();
         }
+        indexFileData.push("export * as DG from 'src/types/docgen/index';");
+        const fieldMap = new Map();
+        for (const field of fields) {
+            if (fieldMap.has(field.name))
+                continue;
+            fieldMap.set(field.name, field);
+        }
+        const imports = new Set([`import { ApiProperty } from '@nestjs/swagger'`]);
+        const validators = `import { ${Array.from(classValidatorsSet)} } from 'src/_nest/validators';`;
+        const exportTypes = [];
+        const fieldClasses = Array.from(fieldMap)
+            .map(([_, field]) => {
+            field.isRequired = true;
+            const name = Helper.capitalizeFirstSafe(field.name);
+            exportTypes.push(`
+          export type ${name} = ${name}Dto
+        `);
+            return `
+          class ${name}Dto {
+            ${field.build()}
+          }
+        `;
+        })
+            .join("\n");
+        imports.add(`import { ${Array.from(enumsSet)} } from '@prisma/client';`);
+        imports.add(validators);
+        const teste = `
+      export namespace Input {
+        ${exportTypes.join(";")}
+      }
+    `;
+        const fieldFileContent = [Array.from(imports).join("\n"), fieldClasses, teste];
+        this.fieldFile = new DocGenFile({
+            fileName: "fields.types.ts",
+            dir: "",
+            data: fieldFileContent.join("\n"),
+        });
+        this.indexFile = new DocGenFile({
+            fileName: "index.ts",
+            dir: "",
+            data: indexFileData.join("\n"),
+        });
+        this.indexFile.save();
+        this.fieldFile.save();
     }
 }
 const generator = new DocGen();

package/dist/rules.js

@@ -2,9 +2,11 @@ export class DocGenRules {
     ignore;
     examples;
     validators;
+    validatorPath;
     constructor(params) {
-        const { examples, ignore, validators } = params;
+        const { examples, ignore, validators, validatorPath } = params;
         this.ignore = ignore;
+        this.validatorPath = validatorPath;
         if (!validators.length) {
             console.warn("[doc-gen] Nenhum validator encontrado. Verifique seu docgen.config.ts*");
         }

package/dist/schemas/config.schema.json

@@ -13,15 +13,18 @@
         },
         "fields": {
           "type": "array",
-          "items": {
-            "type": "string"
-          },
+          "items": { "type": "string" },
           "description": "Lista de nomes de campos onde o exemplo será aplicado."
         }
       },
       "required": ["fields", "example"]
     },
 
+    "ValidatorPath": {
+      "type": "string",
+      "description": "Caminho (path) para o arquivo/pasta de validators usado pelo gerador."
+    },
+
     "ValidatorBuilder": {
       "additionalProperties": false,
       "type": "object",
@@ -33,9 +36,7 @@
         },
         "fields": {
           "type": "array",
-          "items": {
-            "type": "string"
-          },
+          "items": { "type": "string" },
           "description": "Campos que recebem este validador."
         }
       },
@@ -53,27 +54,24 @@
         },
         "ignore": {
           "type": "array",
-          "items": {
-            "type": "string"
-          },
+          "items": { "type": "string" },
           "description": "Campos a serem ignorados durante a geração automática de DTOs."
         },
+        "validatorPath": {
+          "$ref": "#/definitions/ValidatorPath"
+        },
         "examples": {
           "type": "array",
-          "items": {
-            "$ref": "#/definitions/ApiExampleBuilder"
-          },
+          "items": { "$ref": "#/definitions/ApiExampleBuilder" },
           "description": "Lista de exemplos a serem aplicados a campos específicos."
         },
         "validators": {
           "type": "array",
-          "items": {
-            "$ref": "#/definitions/ValidatorBuilder"
-          },
+          "items": { "$ref": "#/definitions/ValidatorBuilder" },
           "description": "Lista de validadores associados a campos específicos."
         }
       },
-      "required": ["ignore", "examples", "validators"]
+      "required": ["ignore", "validatorPath", "examples", "validators"]
     }
   }
 }

package/dist/utils/helpers.js

@@ -72,7 +72,7 @@ export class Helper {
         return undefined;
     }
     static toKebab(s) {
-        return s.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+        return s.replaceAll(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
     }
     importsForModel(model) {
         const needsEnum = model.fields.some((field) => field.kind === "enum");
@@ -135,4 +135,12 @@ export class Helper {
     isDate(field) {
         return field.kind === "scalar" && field.type === "DateTime";
     }
+    // Mais segura (remove espaços do começo e lida melhor com alguns caracteres)
+    static capitalizeFirstSafe(str) {
+        const s = str.trimStart();
+        if (!s)
+            return s;
+        const [first, ...rest] = Array.from(s); // lida melhor com unicode
+        return first.toUpperCase() + rest.join("");
+    }
 }

package/dist/utils/loader.js

@@ -14,11 +14,13 @@ export class DocGenConfig {
     ignore;
     examples;
     validators;
+    validatorPath;
     constructor(configs) {
-        const { examples, ignore, validators } = configs;
+        const { examples, ignore, validators, validatorPath } = configs;
         this.ignore = ignore;
         this.examples = examples;
         this.validators = validators;
+        this.validatorPath = validatorPath;
     }
     static async readJson(filePath) {
         const content = await fs.readFile(filePath, "utf8");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nest-prisma_doc-gen",
-  "version": "1.0.18",
+  "version": "1.0.20",
   "description": "Auto generates ApiProperties from schema.prisma",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",