nest-prisma_doc-gen 1.0.3 → 1.0.4

package/dist/config.type.js

@@ -0,0 +1,16 @@
+export class ValidatorBuilder {
+    decorator;
+    fields;
+    constructor(decorator, fields) {
+        this.decorator = decorator;
+        this.fields = fields;
+    }
+}
+export class ApiExampleBuilder {
+    fields;
+    example;
+    constructor(fields, example) {
+        this.fields = fields;
+        this.example = example;
+    }
+}

package/dist/entities/dto-generator.js

@@ -1,5 +1,5 @@
 import { DocGenFile } from "../file.js";
-import { Helper } from "../helpers/helpers.js";
+import { Helper } from "../utils/helpers.js";
 import { Static } from "../static.js";
 import { DocGenField } from "./field.js";
 export class DocGenDto {
@@ -11,11 +11,11 @@ export class DocGenDto {
     enums = new Set();
     constructor(model) {
         this.name = model.name;
-        model.fields.forEach((field) => {
+        for (const field of model.fields) {
             if (field.isUpdatedAt || field.isId || field.name === "createdAt" || field.kind === "object")
-                return;
+                continue;
             this.fields.push(new DocGenField(field, "dto"));
-        });
+        }
         this.file = new DocGenFile({
             dir: "/dto",
             fileName: `${Helper.toKebab(this.name)}.dto.ts`,
@@ -25,7 +25,9 @@ export class DocGenDto {
     build() {
         const sanitizedFields = this.fields
             .map((field) => {
-            field.validators.forEach((v) => this.classValidators.add(v.name));
+            for (const { name } of field.validators) {
+                this.classValidators.add(name);
+            }
             if (field.isEntity) {
                 this.imports.add(`import { ${field.type} } from '../entities/${Helper.toKebab(field.scalarType)}.entity'`);
                 this.imports.add(`import { generateExample } from 'src/utils/functions/reflect'`);

package/dist/entities/entity-generator.js

@@ -1,5 +1,5 @@
 import { DocGenFile } from "../file.js";
-import { Helper } from "../helpers/helpers.js";
+import { Helper } from "../utils/helpers.js";
 import { Static } from "../static.js";
 import { DocGenField } from "./field.js";
 export class DocGenEntity {
@@ -10,11 +10,11 @@ export class DocGenEntity {
     enums = new Set();
     constructor(model) {
         this.name = model.name;
-        model.fields.forEach((field) => {
+        for (const field of model.fields) {
             if (field.kind === "object")
-                return;
+                continue;
             this.fields.push(new DocGenField(field, "entity"));
-        });
+        }
         this.file = new DocGenFile({
             dir: "/entity",
             fileName: `${Helper.toKebab(this.name)}.entity.ts`,

package/dist/entities/field.js

@@ -1,6 +1,5 @@
-import { Helper } from "../helpers/helpers.js";
-import { config } from "../helpers/loader.js";
-import { Static } from "../static.js";
+import { Helper } from "../utils/helpers.js";
+import { config } from "../utils/loader.js";
 import { Validator } from "./validator.js";
 const helpers = new Helper();
 const rules = config;
@@ -67,9 +66,9 @@ export class DocGenField {
         }
         const findedDecorators = rules.validators.get(this.name);
         if (findedDecorators) {
-            findedDecorators.forEach((name) => {
+            for (const name of findedDecorators) {
                 this.processValidator(name);
-            });
+            }
         }
     }
     setType() {
@@ -113,7 +112,7 @@ export class DocGenField {
             props.push(`example: ${this.scalarField.type}[0]`);
         }
         else if (this.scalarField.type === "Int") {
-            props.push(`example: ${Static.getRandomNumber()}`);
+            props.push(`example: 777`);
         }
         else if (this.scalarField.type === "String") {
             props.push(`example: 'ordinary string'`);

package/dist/index.js

@@ -1,2 +1 @@
 export { DocGenRules } from "./rules.js";
-export { DocGenConfig } from "./helpers/loader.js";

package/dist/main.js

@@ -3,7 +3,7 @@ import * as path from "node:path";
 import { DocEnums, DocGenEnum } from "./entities/enum.js";
 import { DocGenModel } from "./entities/model.js";
 import { DocFields } from "./field.type.js";
-import { Helper } from "./helpers/helpers.js";
+import { Helper } from "./utils/helpers.js";
 import prismaPkg from "@prisma/internals";
 const { getDMMF } = prismaPkg;
 const ROOT = process.cwd();
@@ -25,9 +25,11 @@ export class DocGen {
             });
         }));
         const fieldSet = new Set();
-        datamodel.models.forEach((model) => {
-            model.fields.forEach((field) => fieldSet.add(`'${field.name}'`));
-        });
+        for (const model of datamodel.models) {
+            for (const field of model.fields) {
+                fieldSet.add(`'${field.name}'`);
+            }
+        }
         this.fields = new DocFields(Array.from(fieldSet).toString());
         this.models = datamodel.models.map((model) => {
             return new DocGenModel(model);
@@ -37,9 +39,9 @@ export class DocGen {
     build() {
         this.fields.file.save();
         this.enums.file.save();
-        this.models.forEach((model) => {
+        for (const model of this.models) {
             model.save();
-        });
+        }
     }
 }
 const generator = new DocGen();

package/dist/rules.js

@@ -13,7 +13,7 @@ export class DocGenRules {
         this.examples = new Map(examples.flatMap((builder) => builder.fields.map((field) => [field, builder])));
         this.validators = new Map(uniqueFieldsToValidate.map((field) => [
             field,
-            validators.filter((validator) => validator.fields.includes(field)).map((validator) => validator.decorator.name),
+            validators.filter((validator) => validator.fields.includes(field)).map((validator) => validator.decorator),
         ]));
     }
 }

package/dist/schemas/config.schema.json

@@ -0,0 +1,79 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$ref": "#/definitions/Rules",
+  "definitions": {
+    "ApiExampleBuilder": {
+      "additionalProperties": false,
+      "type": "object",
+      "description": "Define um exemplo usado para popular campos de DTO durante a geração automática.",
+      "properties": {
+        "example": {
+          "type": ["string", "boolean", "number"],
+          "description": "Valor de exemplo a ser usado para os campos especificados."
+        },
+        "fields": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "description": "Lista de nomes de campos onde o exemplo será aplicado."
+        }
+      },
+      "required": ["fields", "example"]
+    },
+
+    "ValidatorBuilder": {
+      "additionalProperties": false,
+      "type": "object",
+      "description": "Define um validador a ser aplicado a determinados campos.",
+      "properties": {
+        "decorator": {
+          "type": "string",
+          "description": "Nome do decorator de validação (ex: IsEmail, IsStrongPassword)."
+        },
+        "fields": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "description": "Campos que recebem este validador."
+        }
+      },
+      "required": ["decorator", "fields"]
+    },
+
+    "Rules": {
+      "additionalProperties": false,
+      "type": "object",
+      "description": "Configuração principal do DocGen.",
+      "properties": {
+        "$schema": {
+          "type": "string",
+          "description": "Caminho para o schema de validação (usado pelo editor para autocomplete)."
+        },
+        "ignore": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "description": "Campos a serem ignorados durante a geração automática de DTOs."
+        },
+        "examples": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/ApiExampleBuilder"
+          },
+          "description": "Lista de exemplos a serem aplicados a campos específicos."
+        },
+        "validators": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/ValidatorBuilder"
+          },
+          "description": "Lista de validadores associados a campos específicos."
+        }
+      },
+      "required": ["ignore", "examples", "validators"]
+    }
+  }
+}

package/dist/static.js

@@ -1,25 +1,3 @@
 export class Static {
     static AUTO_GENERATED_COMMENT = "// AUTO-GERADO: NÃO EDITAR MANUALMENTE. SUJEITO A PAULADAS!";
-    static STATIC_NAMES = [
-        "Alessandro",
-        "Pablo",
-        "Cláudio",
-        "Thiago",
-        "Guilherme",
-        "Dalton",
-        "Kaio",
-        "Gustavo",
-        "Cadu",
-        "Neyanne",
-        "John",
-        "Matheus",
-        "Davi",
-    ];
-    static getRandomString(values) {
-        const idx = Math.floor(Math.random() * values.length);
-        return values[idx];
-    }
-    static getRandomNumber(min = 0, max = 1000) {
-        return Math.floor(Math.random() * (max - min)) + min;
-    }
 }

package/dist/testes.js

@@ -0,0 +1,21 @@
+// import { Ajv } from "ajv";
+// import schema from "./schemas/config.schema.json" with { type: "json" };
+export {};
+// const ajv = new Ajv();
+// const validate = ajv.compile(schema);
+// const data = {
+//   ignore: ["senha", "id"],
+//   examples: [
+//     { fields: ["name"], example: "João" },
+//     { fields: ["idade"], example: 30 },
+//   ],
+//   validators: [
+//     { decorator: "IsString", fields: ["name"] },
+//     { decorator: "IsInt", fields: ["idade"] },
+//   ],
+// };
+// if (validate(data)) {
+//   console.log("✅ JSON válido!");
+// } else {
+//   console.error("❌ Erros:", validate.errors);
+// }

package/dist/types.js

@@ -1,17 +1 @@
-export class ValidatorBuilder {
-    decorator;
-    fields;
-    constructor(decorator, fields) {
-        this.decorator = decorator;
-        this.fields = fields;
-    }
-}
-export class ApiExampleBuilder {
-    fields;
-    example;
-    constructor(fields, example) {
-        this.fields = fields;
-        this.example = example;
-    }
-}
-// field: Field, fieldType: FieldType
+export {};

package/dist/utils/config-loader.js

@@ -0,0 +1,33 @@
+// import * as fs from "node:fs/promises";
+// import * as path from "node:path";
+// import { fileURLToPath } from "node:url";
+// import Ajv from "ajv";
+// import addFormats from "ajv-formats";
+// import { DocGenRules } from "nest-prisma_doc-gen";
+export {};
+// // Caminho absoluto do diretório da lib (onde este arquivo está)
+// const __filename = fileURLToPath(import.meta.url);
+// const __dirname = path.dirname(__filename);
+// // Caminho para o schema dentro da lib
+// const SCHEMA_PATH = path.join(__dirname, "../schemas/config.schema.json");
+// // Caminho para o config do projeto (que será validado)
+// const CONFIG_PATH = path.join(process.cwd(), "doc-gen.config.json");
+// async function readJson(filePath: string) {
+//   const content = await fs.readFile(filePath, "utf8");
+//   return JSON.parse(content);
+// }
+// export async function loadDocGenConfig() {
+//   // Lê os dois arquivos
+//   const [schema, config] = (await Promise.all([readJson(SCHEMA_PATH), readJson(CONFIG_PATH)])) as [any, DocGenRules];
+//   // Configura o validador
+//   const ajv = new Ajv.Ajv({ allErrors: true, strict: false });
+//   addFormats.default(ajv);
+//   const validate = ajv.compile(schema);
+//   const valid = validate(config);
+//   if (!valid) {
+//     const errors = (validate.errors ?? []).map((e) => `${e.instancePath || "(root)"} ${e.message}`).join("\n - ");
+//     throw new Error(`❌ Config inválida em ${path.basename(CONFIG_PATH)}:\n - ${errors}`);
+//   }
+//   console.log("✅ Configuração válida!");
+//   return { config, path: CONFIG_PATH };
+// }

package/dist/utils/copy-schemas.js

@@ -0,0 +1,10 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const src = path.join(__dirname, "../schemas/config.schema.json");
+const destDir = path.join(__dirname, "../dist/schemas");
+fs.mkdirSync(destDir, { recursive: true });
+fs.copyFileSync(src, path.join(destDir, "config.schema.json"));
+console.log("✅ Copiado config.schema.json para dist/schemas/");

package/dist/utils/loader.js

@@ -0,0 +1,47 @@
+import { fileURLToPath } from "node:url";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { DocGenRules } from "../rules.js";
+import Ajv from "ajv";
+import addFormats from "ajv-formats";
+// Caminho absoluto do diretório da lib (onde este arquivo está)
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// Caminho para o schema dentro da lib
+const SCHEMA_PATH = path.join(__dirname, "../schemas/config.schema.json");
+const CONFIG_PATH = path.join(process.cwd(), "doc-gen.config.json");
+export class DocGenConfig {
+    ignore;
+    examples;
+    validators;
+    constructor(configs) {
+        const { examples, ignore, validators } = configs;
+        this.ignore = ignore;
+        this.examples = examples;
+        this.validators = validators;
+    }
+    static async readJson(filePath) {
+        const content = await fs.readFile(filePath, "utf8");
+        return JSON.parse(content);
+    }
+    static async load() {
+        // Lê os dois arquivos
+        const [schema, config] = (await Promise.all([this.readJson(SCHEMA_PATH), this.readJson(CONFIG_PATH)]));
+        // Configura o validador
+        const ajv = new Ajv.Ajv({ allErrors: true, strict: false });
+        addFormats.default(ajv);
+        const validate = ajv.compile(schema);
+        const valid = validate(config);
+        if (!valid) {
+            const errors = (validate.errors ?? []).map((e) => `${e.instancePath || "(root)"} ${e.message}`).join("\n - ");
+            throw new Error(`❌ Config inválida em ${path.basename(CONFIG_PATH)}:\n - ${errors}`);
+        }
+        console.log("✅ Configuração válida!");
+        return DocGenConfig.newWithConfigs(config);
+    }
+    /** Cria uma instância a partir de configurações */
+    static newWithConfigs(params) {
+        return new DocGenConfig(new DocGenRules(params));
+    }
+}
+export const config = await DocGenConfig.load();

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "nest-prisma_doc-gen",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "Auto generates ApiProperties from schema.prisma",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
   "scripts": {
-    "build": "tsc",
-    "generate": "node dist/tools/generate-dtos.js"
+    "build": "tsc && npm run copy-schemas",
+    "copy-schemas": "node scripts/copy-schemas.js"
   },
   "repository": {
     "type": "git",
@@ -28,15 +28,19 @@
   "author": "Alessandro Lepore",
   "license": "ISC",
   "dependencies": {
+    "@esbuild/win32-x64": "^0.25.11",
     "@prisma/internals": "^6.17.1",
-    "nest-prisma_doc-gen": "^1.0.1",
+    "ajv": "^8.17.1",
+    "ajv-formats": "^3.0.1",
     "prettier": "^3.6.2",
-    "ts-node": "^10.9.2",
-    "tsx": "^4.19.1"
+    "ts-node": "^10.9.2"
   },
   "devDependencies": {
     "@types/node": "^24.7.2",
-    "tsx": "^4.20.6",
     "typescript": "^5.6.3"
-  }
+  },
+  "files": [
+    "dist",
+    "src/schemas/config.schema.json"
+  ]
 }

package/dist/entities/dto-generator.d.ts

@@ -1,13 +0,0 @@
-import { DocGenFile } from "../file.js";
-import { Model } from "../types.js";
-import { DocGenField } from "./field.js";
-export declare class DocGenDto {
-    name: string;
-    file: DocGenFile;
-    fields: DocGenField[];
-    imports: Set<string>;
-    classValidators: Set<string>;
-    enums: Set<string>;
-    constructor(model: Model);
-    build(): string;
-}

package/dist/entities/entity-generator.d.ts

@@ -1,12 +0,0 @@
-import { DocGenFile } from "../file.js";
-import { Model } from "../types.js";
-import { DocGenField } from "./field.js";
-export declare class DocGenEntity {
-    name: string;
-    file: DocGenFile;
-    fields: DocGenField[];
-    imports: Set<string>;
-    enums: Set<string>;
-    constructor(model: Model);
-    build(): string;
-}

package/dist/entities/enum.d.ts

@@ -1,22 +0,0 @@
-import { DocGenFile } from "../file.js";
-import { DbName } from "../types.js";
-export type EnumValue = {
-    name: string;
-    dbName: DbName;
-};
-export declare class DocGenEnum {
-    name: string;
-    values: EnumValue[];
-    dbName: DbName;
-    constructor(params: {
-        name: string;
-        values: EnumValue[];
-        dbName: DbName;
-    });
-}
-export declare class DocEnums {
-    enums: DocGenEnum[];
-    file: DocGenFile;
-    constructor(enums: DocGenEnum[]);
-    build(): string;
-}

package/dist/entities/field.d.ts

@@ -1,24 +0,0 @@
-import { FieldDefault, Scalar, FieldKind, FieldType, Field } from "../types.js";
-export declare class DocGenField {
-    name: string;
-    isList: boolean;
-    default?: FieldDefault | string;
-    scalarType: Scalar;
-    kind: FieldKind;
-    type: string;
-    fieldType: FieldType;
-    isEnum: boolean;
-    isEntity: boolean;
-    isUpdatedAt: boolean;
-    isRequired: boolean;
-    validators: Set<string>;
-    readonly scalarField: Field;
-    constructor(field: Field, fieldType: FieldType);
-    private init;
-    private setValidators;
-    private setType;
-    private buildApiExample;
-    private sanitizeValidators;
-    private buildInfos;
-    build(): string;
-}

package/dist/entities/model.d.ts

@@ -1,11 +0,0 @@
-import { Field, Model } from "../types.js";
-import { DocGenDto } from "./dto-generator.js";
-import { DocGenEntity } from "./entity-generator.js";
-export declare class DocGenModel {
-    name: string;
-    entitie: DocGenEntity;
-    createDtos: DocGenDto;
-    fields: Field[];
-    constructor(model: Model);
-    save(): void;
-}

package/dist/field.type.d.ts

@@ -1,7 +0,0 @@
-import { DocGenFile } from "./file.js";
-export declare class DocFields {
-    fields: string;
-    file: DocGenFile;
-    constructor(fields: string);
-    build(): string;
-}

package/dist/file.d.ts

@@ -1,11 +0,0 @@
-export declare class DocGenFile {
-    outDir: string;
-    data: string;
-    constructor(params: {
-        fileName: string;
-        dir: string;
-        data: string;
-        customDir?: string;
-    });
-    save(): Promise<void>;
-}

package/dist/helpers/helpers.d.ts

@@ -1,14 +0,0 @@
-import { Scalar, Field, DocGenModel } from "../types.js";
-export declare class Helper {
-    static prismaScalarToTs(s: Scalar): string;
-    static validatorForScalar(s: Scalar): string;
-    static swaggerType(field: Field): string | undefined;
-    static toKebab(s: string): string;
-    importsForModel(model: DocGenModel): {
-        enums: boolean;
-        hasDate: boolean;
-    };
-    static readPrismaFolderDatamodel(dir: string): Promise<string>;
-    findTypeForField(field: Field): string;
-    isDate(field: Field): boolean;
-}

package/dist/helpers/loader.d.ts

@@ -1,4 +0,0 @@
-import "tsx/esm";
-import { DocGenRules } from "../index.js";
-export declare let rules: DocGenRules;
-export declare function loadDocGenConfig(): Promise<any>;

package/dist/helpers/loader.js

@@ -1,50 +0,0 @@
-import "tsx/esm";
-import { pathToFileURL } from "node:url";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { DocGenRules } from "../rules.js";
-export class DocGenConfig {
-    ignore;
-    examples;
-    validators;
-    constructor(configs) {
-        const { examples, ignore, validators } = configs;
-        this.ignore = ignore;
-        this.examples = examples;
-        this.validators = validators;
-    }
-    /**
-     * Carrega o arquivo doc-gen.config.ts|.js da raiz do projeto.
-     */
-    static async load() {
-        const ROOT = process.cwd();
-        const CONFIG_PATH_TS = path.join(ROOT, "doc-gen.config.mts");
-        const CONFIG_PATH_JS = path.join(ROOT, "doc-gen.config.mjs");
-        let configFile;
-        if (fs.existsSync(CONFIG_PATH_TS))
-            configFile = CONFIG_PATH_TS;
-        else if (fs.existsSync(CONFIG_PATH_JS))
-            configFile = CONFIG_PATH_JS;
-        if (!configFile) {
-            console.warn("⚠️ Nenhum arquivo doc-gen.config.ts|.js encontrado. Usando configuração vazia.");
-            return this.newEmpty();
-        }
-        await import("tsx/esm");
-        const imported = await import(pathToFileURL(configFile).href);
-        const rules = imported.rules;
-        if (!rules) {
-            console.warn("⚠️ O arquivo doc-gen.config.ts|.js não exporta 'rules'.");
-            return this.newEmpty();
-        }
-        return this.newWithConfigs(rules);
-    }
-    /** Cria uma instância vazia */
-    static newEmpty() {
-        return new DocGenConfig(new DocGenRules({ ignore: [], examples: [], validators: [] }));
-    }
-    /** Cria uma instância a partir de configurações */
-    static newWithConfigs(params) {
-        return new DocGenConfig(new DocGenRules(params));
-    }
-}
-export const config = await DocGenConfig.load();

package/dist/helpers/propeties.static.d.ts

@@ -1,2 +0,0 @@
-export declare const FIELD_NAMES: readonly [""];
-export type FieldName = (typeof FIELD_NAMES)[number];

package/dist/index.d.ts

@@ -1,2 +0,0 @@
-export { DocGenRules } from "./rules.js";
-export { DocGenConfig } from "./helpers/loader.js";

package/dist/main.d.ts

@@ -1,13 +0,0 @@
-#!/usr/bin/env node
-import { DocEnums } from "./entities/enum.js";
-import { DocGenModel } from "./entities/model.js";
-import { DocFields } from "./field.type.js";
-export declare class DocGen {
-    datamodel: string;
-    properties: Set<string>;
-    enums: DocEnums;
-    fields: DocFields;
-    models: DocGenModel[];
-    init(): Promise<void>;
-    build(): void;
-}

package/dist/rules.d.ts

@@ -1,11 +0,0 @@
-import { ApiExampleBuilder, ValidatorBuilder } from "./types.js";
-export declare class DocGenRules {
-    ignore: string[];
-    examples: Map<string, ApiExampleBuilder>;
-    validators: Map<string, string[]>;
-    constructor(params: {
-        ignore: string[];
-        examples: ApiExampleBuilder[];
-        validators: ValidatorBuilder[];
-    });
-}