nest-prisma_doc-gen 1.0.0

package/dist/helpers/loader.js

@@ -0,0 +1,50 @@
+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

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

package/dist/helpers/propeties.static.js

@@ -0,0 +1,2 @@
+// AUTO-GERADO: NÃO EDITAR MANUALMENTE. SUJEITO A PAULADAS!
+export const FIELD_NAMES = [""];

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/main.d.ts

@@ -0,0 +1,13 @@
+#!/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/main.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+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 prismaPkg from "@prisma/internals";
+const { getDMMF } = prismaPkg;
+const ROOT = process.cwd();
+const PRISMA_DIR = path.join(ROOT, "prisma");
+export class DocGen {
+    datamodel;
+    properties;
+    enums;
+    fields;
+    models;
+    async init() {
+        const prismaDataModel = await Helper.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,
+            });
+        }));
+        const fieldSet = new Set();
+        datamodel.models.forEach((model) => {
+            model.fields.forEach((field) => fieldSet.add(`'${field.name}'`));
+        });
+        this.fields = new DocFields(Array.from(fieldSet).toString());
+        this.models = datamodel.models.map((model) => {
+            return new DocGenModel(model);
+        });
+        this.build();
+    }
+    build() {
+        this.fields.file.save();
+        this.enums.file.save();
+        this.models.forEach((model) => {
+            model.save();
+        });
+    }
+}
+const generator = new DocGen();
+try {
+    await generator.init();
+    console.log("✅ DTOs gerados com sucesso!");
+}
+catch (err) {
+    console.error("❌ Erro ao gerar DTOs:", err);
+    process.exit(1);
+}

package/dist/rules.d.ts

@@ -0,0 +1,11 @@
+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[];
+    });
+}

package/dist/rules.js

@@ -0,0 +1,19 @@
+export class DocGenRules {
+    ignore;
+    examples;
+    validators;
+    constructor(params) {
+        const { examples, ignore, validators } = params;
+        this.ignore = ignore;
+        if (!validators.length) {
+            console.warn("[doc-gen] Nenhum validator encontrado. Verifique seu docgen.config.ts*");
+        }
+        const allFields = validators.flatMap((validator) => validator.fields);
+        const uniqueFieldsToValidate = [...new Set(allFields)];
+        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),
+        ]));
+    }
+}

package/dist/static.d.ts

@@ -0,0 +1,6 @@
+export declare class Static {
+    static readonly AUTO_GENERATED_COMMENT: "// AUTO-GERADO: N\u00C3O EDITAR MANUALMENTE. SUJEITO A PAULADAS!";
+    static readonly STATIC_NAMES: readonly ["Alessandro", "Pablo", "Cláudio", "Thiago", "Guilherme", "Dalton", "Kaio", "Gustavo", "Cadu", "Neyanne", "John", "Matheus", "Davi"];
+    static getRandomString(values: string[]): string;
+    static getRandomNumber(min?: number, max?: number): number;
+}

package/dist/static.js

@@ -0,0 +1,25 @@
+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/types.d.ts

@@ -0,0 +1,79 @@
+export type FieldKind = "scalar" | "object" | "enum";
+type FieldDefaultName = "now" | "autoincrement" | "cuid";
+export type FieldType = "entity" | "dto";
+export type DbName = string | null;
+export type Scalar = "String" | "Int" | "BigInt" | "Float" | "Decimal" | "Boolean" | "DateTime" | "Json" | "Bytes";
+export type Field = {
+    name: string;
+    dbName: string;
+    kind: FieldKind;
+    isList: boolean;
+    isRequired: boolean;
+    isUnique: boolean;
+    isId: boolean;
+    isReadOnly: boolean;
+    hasDefaultValue: boolean;
+    type: Scalar;
+    isGenerated: boolean;
+    isUpdatedAt: boolean;
+    nativeType: any;
+    default?: FieldDefault | string;
+};
+export interface FieldDefault {
+    name: FieldDefaultName;
+    args: number[];
+}
+export type DocGenModel = {
+    name: string | null;
+    dbName: string | null;
+    schema: string | null;
+    readonly fields: Field[];
+    uniqueFields: string[][];
+    uniqueIndexes: ModelUniqueIndexes[];
+    primaryKey: null;
+    documentation?: string;
+    isGenerated?: boolean;
+};
+export type ModelUniqueIndexes = {
+    name: string | null;
+    fields: any[];
+};
+export declare class ValidatorBuilder {
+    decorator: ValidatorFactory | PropertyDecorator;
+    fields: string[];
+    constructor(decorator: PropertyDecorator, fields: string[]);
+}
+export declare class ApiExampleBuilder {
+    fields: string[];
+    example: string | boolean | number;
+    constructor(fields: string[], example: string | boolean | number);
+}
+export type Rules = {
+    ignore: string[];
+    examples: ApiExampleBuilder[];
+    validators: ValidatorBuilder[];
+};
+type ValidatorFactory = (...args: any[]) => PropertyDecorator;
+export type Model = {
+    name: string;
+    dbName: string | null;
+    schema: string | null;
+    readonly fields: Field[];
+    uniqueFields: string[][];
+    uniqueIndexes: ModelUniqueIndexes[];
+    primaryKey: null;
+    documentation?: string;
+    isGenerated?: boolean;
+};
+export type ModelParams = {
+    model: Model;
+    examples: Map<string, ApiExampleBuilder>;
+    validators: Map<string, string[]>;
+};
+export type FieldParams = {
+    examples: Map<string, ApiExampleBuilder>;
+    validators: Map<string, string[]>;
+    field: Field;
+    fieldType: FieldType;
+};
+export {};

package/dist/types.js

@@ -0,0 +1,17 @@
+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

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "nest-prisma_doc-gen",
+  "version": "1.0.0",
+  "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"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aleleppy/nest-prisma-doc-gen.git"
+  },
+  "bin": {
+    "doc-gen": "dist/main.js"
+  },
+  "keywords": [
+    "scalar",
+    "prisma",
+    "nestJS",
+    "documentation",
+    "swagger",
+    "automatic",
+    "generation"
+  ],
+  "author": "Alessandro Lepore",
+  "license": "ISC",
+  "dependencies": {
+    "@prisma/internals": "^6.17.1",
+    "prettier": "^3.6.2",
+    "ts-node": "^10.9.2"
+  },
+  "devDependencies": {
+    "@types/node": "^24.7.2",
+    "tsx": "^4.20.6",
+    "typescript": "^5.6.3"
+  }
+}

package/src/entities/dto-generator.ts

@@ -0,0 +1,61 @@
+import { DocGenFile } from "../file.js";
+import { Helper } from "../helpers/helpers.js";
+import { Static } from "../static.js";
+import { Model } from "../types.js";
+import { DocGenField } from "./field.js";
+
+export class DocGenDto {
+  name: string;
+  file: DocGenFile;
+  fields: DocGenField[] = [];
+  imports = new Set([`${Static.AUTO_GENERATED_COMMENT}`, `import { ApiProperty } from '@nestjs/swagger'`]);
+  classValidators = new Set<string>();
+  enums = new Set<string>();
+
+  constructor(model: Model) {
+    this.name = model.name;
+
+    model.fields.forEach((field) => {
+      if (field.isUpdatedAt || field.isId || field.name === "createdAt" || field.kind === "object") return;
+
+      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
+      .map((field) => {
+        field.validators.forEach((v) => this.classValidators.add(v.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'`);
+        } else if (field.isEnum) {
+          this.enums.add(field.type);
+        }
+
+        return field.build();
+      })
+      .join("\n\n");
+
+    if (this.enums.size > 0) {
+      this.classValidators.add("IsEnum");
+      this.imports.add(`import { ${Array.from(this.enums)} } from '../enums';`);
+    }
+
+    this.imports.add(`import { ${Array.from(this.classValidators)} } from 'class-validator';`);
+
+    return [
+      `${Array.from(this.imports).join("\n")}`,
+      `export class ${this.name}Dto {
+        ${sanitizedFields}
+      }`,
+    ].join("\n\n");
+  }
+}

package/src/entities/entity-generator.ts

@@ -0,0 +1,55 @@
+import { DocGenFile } from "../file.js";
+import { Helper } from "../helpers/helpers.js";
+import { Static } from "../static.js";
+import { Model } from "../types.js";
+import { DocGenField } from "./field.js";
+
+export class DocGenEntity {
+  name: string;
+  file: DocGenFile;
+  fields: DocGenField[] = [];
+  imports = new Set([`${Static.AUTO_GENERATED_COMMENT}`, `import { ApiProperty } from '@nestjs/swagger'`]);
+  enums = new Set<string>();
+
+  constructor(model: Model) {
+    this.name = model.name;
+
+    model.fields.forEach((field) => {
+      if (field.kind === "object") return;
+
+      this.fields.push(new DocGenField(field, "entity"));
+    });
+
+    this.file = new DocGenFile({
+      dir: "/entity",
+      fileName: `${Helper.toKebab(this.name)}.entity.ts`,
+      data: this.build(),
+    });
+  }
+
+  build() {
+    const sanitizedFields = this.fields
+      .map((field) => {
+        if (field.isEntity) {
+          this.imports.add(`import { ${field.type} } from './${Helper.toKebab(field.scalarType)}.entity'`);
+          this.imports.add(`import { generateExample } from 'src/utils/functions/reflect'`);
+        } else 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 '../enums';`);
+    }
+
+    return [
+      `${Array.from(this.imports).join("\n")}`,
+      `export class ${this.name}Entity {
+        ${sanitizedFields}
+      }`,
+    ].join("\n\n");
+  }
+}

package/src/entities/enum.ts

@@ -0,0 +1,47 @@
+import { DocGenFile } from "../file.js";
+import { DbName } from "../types.js";
+
+export type EnumValue = { name: string; dbName: DbName };
+
+export class DocGenEnum {
+  name: string;
+  values: EnumValue[];
+  dbName: DbName;
+
+  constructor(params: { name: string; values: EnumValue[]; dbName: DbName }) {
+    const { dbName, name, values } = params;
+    this.dbName = dbName;
+    this.name = name;
+    this.values = values;
+  }
+}
+
+export class DocEnums {
+  enums: DocGenEnum[];
+  file: DocGenFile;
+
+  constructor(enums: DocGenEnum[]) {
+    this.enums = enums;
+
+    this.file = new DocGenFile({
+      dir: "/",
+      fileName: "enums.ts",
+      data: this.build(),
+    });
+  }
+
+  build() {
+    const enums = this.enums.map((en) => {
+      const enumName = en.name;
+      return `
+        export const ${enumName} = [${en.values.map((n) => `'${n.name}'`)}] as const;
+        export type ${enumName} = typeof ${enumName}[number];
+      `;
+    });
+
+    return `
+      // AUTO-GERADO: NÃO EDITAR MANUALMENTE. SUJEITO A PAULADAS!
+      ${enums.join("\n")}
+    `;
+  }
+}