nest-prisma_doc-gen 1.0.0

package/src/entities/field.ts

@@ -0,0 +1,188 @@
+import { Helper } from "../helpers/helpers.js";
+import { config } from "../helpers/loader.js";
+import { Static } from "../static.js";
+import { FieldDefault, Scalar, FieldKind, FieldType, Field } from "../types.js";
+import { Validator } from "./validator.js";
+
+const helpers = new Helper();
+const rules = config;
+
+export class DocGenField {
+  name: string;
+  isList: boolean;
+  default?: FieldDefault | string;
+  scalarType: Scalar;
+  kind: FieldKind;
+
+  type!: string;
+  fieldType: FieldType;
+
+  isEnum: boolean = false;
+  isEntity: boolean = false;
+  isUpdatedAt: boolean = false;
+  isRequired: boolean;
+  validators = new Set<Validator>();
+
+  readonly scalarField: Field;
+
+  constructor(field: Field, fieldType: FieldType) {
+    const { name, isList, type, kind, isRequired, isUpdatedAt } = field;
+
+    this.name = name;
+    this.isList = isList;
+    this.scalarType = type;
+    this.kind = kind;
+    this.isRequired = isRequired;
+    this.scalarField = field;
+    this.isUpdatedAt = isUpdatedAt;
+    this.fieldType = fieldType;
+
+    this.setType();
+    this.setValidators();
+  }
+
+  private processValidator(name: string) {
+    const validator = new Validator({ name });
+    if (this.isList) validator.content = "{ each: true }";
+
+    this.validators.add(validator);
+  }
+
+  private setValidators() {
+    if (this.scalarType === "String" || this.scalarType === "DateTime") {
+      this.processValidator("IsString");
+
+      if (this.isRequired) {
+        this.processValidator("IsNotEmpty");
+      }
+    } else if (this.scalarType === "Boolean") {
+      this.processValidator("IsBoolean");
+    } else if (
+      this.scalarType === "Int" ||
+      this.scalarType === "BigInt" ||
+      this.scalarType === "Float" ||
+      this.scalarType === "Decimal"
+    ) {
+      this.processValidator("IsNumber");
+    }
+
+    if (this.isList) {
+      const validator = new Validator({ name: "IsArray" });
+      this.validators.add(validator);
+    }
+
+    if (!this.isRequired) this.processValidator("IsOptional");
+
+    if (this.isEnum) {
+      this.validators.add(
+        new Validator({
+          name: "IsEnum",
+          content: this.type,
+        })
+      );
+    }
+
+    const findedDecorators = rules.validators.get(this.name);
+
+    if (findedDecorators) {
+      findedDecorators.forEach((name) => {
+        this.processValidator(name);
+      });
+    }
+  }
+
+  private setType() {
+    if (this.kind === "enum") {
+      this.isEnum = true;
+      this.type = this.scalarType;
+    } else if (this.kind === "object") {
+      this.isEntity = true;
+      this.type = `${this.scalarType}Entity`;
+    } else if (this.kind === "scalar") {
+      this.type = Helper.prismaScalarToTs(this.scalarType);
+    }
+  }
+
+  private buildApiExample(): string[] {
+    const fieldName = this.scalarField.name;
+    const props: string[] = [];
+    const scalarDbName = this.scalarField.dbName ?? "genericDbName";
+
+    if (this.isEntity) {
+      if (this.isList) {
+        props.push(`example: [generateExample(${this.type})]`);
+      } else {
+        props.push(`example: generateExample(${this.type})`);
+      }
+    } else if (rules.examples.has(fieldName)) {
+      props.push(`example: '${rules.examples.get(fieldName)?.example}'`);
+    } else if (helpers.isDate(this.scalarField)) {
+      props.push(`example: '2025-09-03T03:00:00.000Z'`);
+    } else if (this.scalarField.isId || (this.scalarField.isReadOnly && scalarDbName.split("_").includes("id"))) {
+      props.push(`example: 'cmfxu4njg000008l52v7t8qze'`);
+    } else if (this.scalarField.type === "Boolean") {
+      props.push(`example: true`);
+    } else if (this.scalarField.kind === "enum") {
+      props.push(`example: ${this.scalarField.type}[0]`);
+    } else if (this.scalarField.type === "Int") {
+      props.push(`example: ${Static.getRandomNumber()}`);
+    }
+
+    props.push(`required: ${this.scalarField.isRequired}`);
+    return props;
+  }
+
+  private sanitizeValidators() {
+    const sanitizedValidators = Array.from(this.validators).map((validator) => {
+      return validator.build();
+    });
+
+    return sanitizedValidators;
+  }
+
+  private buildInfos() {
+    const key = this.isEnum ? "enum" : "type";
+
+    const apiType = () => {
+      if (this.type === "Date") return `'string'`;
+
+      if (this.isList && this.isEntity) {
+        return `[${this.type}]`;
+      } else if (this.isEnum) {
+        return this.type;
+      } else if (this.isEntity) {
+        return `() => ${this.type}`;
+      }
+
+      return `'${this.type}'`;
+    };
+
+    const fieldType = () => {
+      if (this.isList) {
+        return `${this.type}[]`;
+      } else {
+        return this.type;
+      }
+    };
+    const optionalFlag = this.isRequired ? "" : "?";
+
+    const validators = this.sanitizeValidators();
+    const apiExample = this.buildApiExample().join(", ");
+
+    return {
+      apiProperty: `@ApiProperty({ ${key}: ${apiType()}, ${apiExample} })`,
+      validators,
+      atributes: `${this.name}${optionalFlag}: ${fieldType()};`,
+    };
+  }
+
+  build() {
+    const { apiProperty, atributes, validators } = this.buildInfos();
+
+    if (this.fieldType === "dto") {
+      return [apiProperty, ...validators, atributes].join("\n");
+    } else {
+      return [apiProperty, atributes].join("\n");
+    }
+  }
+}

package/src/entities/model.ts

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

package/src/entities/validator.ts

@@ -0,0 +1,17 @@
+import { Scalar } from "../types.js";
+
+export class Validator {
+  name: string;
+  content: string;
+
+  constructor(params: { name: string; content?: string }) {
+    const { content, name } = params;
+
+    this.name = name;
+    this.content = content ?? "";
+  }
+
+  build() {
+    return `@${this.name}(${this.content})`;
+  }
+}

package/src/field.type.ts

@@ -0,0 +1,27 @@
+import { DocGenFile } from "./file.js";
+import { Static } from "./static.js";
+
+export class DocFields {
+  fields: string;
+  file: DocGenFile;
+
+  constructor(fields: string) {
+    this.fields = fields;
+
+    this.file = new DocGenFile({
+      dir: "/",
+      fileName: "fields.ts",
+      data: this.build(),
+    });
+  }
+
+  build() {
+    const content = `
+      ${Static.AUTO_GENERATED_COMMENT}
+      export const FIELD_NAMES = [${this.fields}] as const
+      export type FieldName = (typeof FIELD_NAMES)[number];
+    `;
+
+    return content;
+  }
+}

package/src/file.ts

@@ -0,0 +1,34 @@
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import * as prettier from "prettier";
+
+const ROOT = process.cwd();
+const OUT_DIR = path.join(ROOT, "generated/docgen");
+
+export class DocGenFile {
+  outDir: string;
+  data: string;
+
+  constructor(params: { fileName: string; dir: string; data: string; customDir?: string }) {
+    const { fileName, dir, data, customDir } = params;
+
+    this.outDir = path.join(OUT_DIR, dir, fileName);
+    this.data = data;
+
+    if (customDir) this.outDir = customDir;
+  }
+
+  async save() {
+    const dir = path.dirname(this.outDir);
+    await fs.mkdir(dir, { recursive: true });
+
+    const prettierConfig = await prettier.resolveConfig(this.outDir);
+
+    const formatted = await prettier.format(this.data, {
+      ...prettierConfig,
+      filepath: this.outDir,
+    });
+
+    await fs.writeFile(this.outDir, formatted, "utf-8");
+  }
+}

package/src/helpers/helpers.ts

@@ -0,0 +1,152 @@
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import { Scalar, Field, DocGenModel } from "../types.js";
+
+export class Helper {
+  static prismaScalarToTs(s: Scalar): string {
+    switch (s) {
+      case "String":
+        return "string";
+      case "Int":
+        return "number";
+      case "BigInt":
+        return "bigint";
+      case "Float":
+      case "Decimal":
+        return "number";
+      case "Boolean":
+        return "boolean";
+      case "DateTime":
+        return "Date";
+      case "Json":
+        return "any";
+      case "Bytes":
+        return "Buffer";
+      default: {
+        return "any";
+      }
+    }
+  }
+
+  static validatorForScalar(s: Scalar): string {
+    switch (s) {
+      case "String":
+        return "IsString";
+      case "Int":
+        return "IsInt";
+      case "BigInt":
+        return "IsNumber"; // class-validator não tem IsBigInt
+      case "Float":
+      case "Decimal":
+        return "IsNumber";
+      case "Boolean":
+        return "IsBoolean";
+      case "DateTime":
+        return "IsDate";
+      case "Json":
+        return ""; // costuma ser livre
+      case "Bytes":
+        return ""; // Buffer não tem decorador nativo
+      default:
+        return "";
+    }
+  }
+
+  static swaggerType(field: Field): string | undefined {
+    // mapeia para Swagger 'type' básico quando possível
+    if (field.kind === "scalar") {
+      const t = field.type;
+
+      switch (t) {
+        case "String":
+          return "string";
+        case "Int":
+        case "Float":
+        case "Decimal":
+          return "number";
+        case "BigInt":
+          return "integer";
+        case "Boolean":
+          return "boolean";
+        case "DateTime":
+          return "string"; // format date-time
+        case "Json":
+          return "object";
+        case "Bytes":
+          return "string"; // base64
+      }
+    }
+    return undefined;
+  }
+
+  static toKebab(s: string): string {
+    return s.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+  }
+
+  importsForModel(model: DocGenModel): {
+    enums: boolean;
+    hasDate: boolean;
+  } {
+    const needsEnum = model.fields.some((field) => field.kind === "enum");
+    return {
+      enums: needsEnum,
+      hasDate: model.fields.some((field) => field.kind === "scalar" && field.type === "DateTime"),
+    };
+  }
+
+  static async readPrismaFolderDatamodel(dir: string): Promise<string> {
+    const files: string[] = [];
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+
+    const mainSchemaPath = path.join(dir, "schema.prisma");
+    try {
+      const mainStat = await fs.stat(mainSchemaPath);
+      if (mainStat.isFile()) files.push(mainSchemaPath);
+    } catch {}
+
+    // varrer demais itens (exceto migrations e o schema.prisma já incluído)
+    for (const entry of entries) {
+      if (entry.name === "migrations") continue;
+      const full = path.join(dir, entry.name);
+
+      if (entry.isDirectory()) {
+        const nested = await this.readPrismaFolderDatamodel(full);
+        if (nested.trim()) files.push(`\n// ---- ${full} ----\n${nested}`);
+      } else if (entry.isFile() && entry.name.endsWith(".prisma") && full !== mainSchemaPath) {
+        const content = await fs.readFile(full, "utf-8");
+        files.push(`\n// ---- ${full} ----\n${content}`);
+      }
+    }
+
+    // se não houver nada além de subpastas, retorna o que juntou nelas
+    if (!files.length) return "";
+
+    // quando schema.prisma existe, ele já está no topo do array
+    if (files[0] === mainSchemaPath) {
+      const head = await fs.readFile(mainSchemaPath, "utf-8");
+      const tail = files.slice(1).join("\n");
+      return `${head}\n${tail}`;
+    }
+
+    // caso não exista schema.prisma, apenas concatena
+    const contents = await Promise.all(files.map(async (f) => (f.startsWith("\n// ---- ") ? f : fs.readFile(f, "utf-8"))));
+    return contents.join("\n");
+  }
+
+  findTypeForField(field: Field): string {
+    if (field.kind === "scalar") {
+      const base = Helper.prismaScalarToTs(field.type);
+      return field.isList ? `${base}[]` : base;
+    } else if (field.kind === "enum") {
+      const base = field.type;
+      return field.isList ? `${base}[]` : base;
+    } else if (field.kind === "object") {
+      const base = "any";
+      return field.isList ? `${base}[]` : base;
+    } else return "any";
+  }
+
+  isDate(field: Field): boolean {
+    return field.kind === "scalar" && field.type === "DateTime";
+  }
+}

package/src/helpers/loader.ts

@@ -0,0 +1,60 @@
+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";
+import { ApiExampleBuilder, DocGenParams } from "../types.js";
+
+export class DocGenConfig {
+  public readonly ignore: string[];
+  public readonly examples: Map<string, ApiExampleBuilder>;
+  public readonly validators: Map<string, string[]>;
+
+  constructor(configs: DocGenRules) {
+    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(): Promise<DocGenConfig> {
+    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: string | undefined;
+    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 as DocGenParams | undefined;
+    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 */
+  private static newEmpty() {
+    return new DocGenConfig(new DocGenRules({ ignore: [], examples: [], validators: [] }));
+  }
+
+  /** Cria uma instância a partir de configurações */
+  private static newWithConfigs(params: DocGenParams) {
+    return new DocGenConfig(new DocGenRules(params));
+  }
+}
+
+export const config = await DocGenConfig.load();

package/src/helpers/propeties.static.ts

@@ -0,0 +1,3 @@
+// AUTO-GERADO: NÃO EDITAR MANUALMENTE. SUJEITO A PAULADAS!
+export const FIELD_NAMES = [""] as const;
+export type FieldName = (typeof FIELD_NAMES)[number];

package/src/index.ts

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

package/src/main.ts

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+import * as path from "node:path";
+import { DocEnums, DocGenEnum, EnumValue } from "./entities/enum.js";
+import { DocGenModel } from "./entities/model.js";
+import { DocFields } from "./field.type.js";
+import { Helper } from "./helpers/helpers.js";
+import { Model } from "./types.js";
+
+import prismaPkg from "@prisma/internals";
+import { config } from "./helpers/loader.js";
+const { getDMMF } = prismaPkg;
+
+const ROOT = process.cwd();
+const PRISMA_DIR = path.join(ROOT, "prisma");
+
+export class DocGen {
+  datamodel!: string;
+  properties!: Set<string>;
+  enums!: DocEnums;
+  fields!: DocFields;
+  models!: DocGenModel[];
+
+  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 as EnumValue[],
+        });
+      })
+    );
+
+    const fieldSet = new Set<string>();
+
+    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 as 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/src/rules.ts

@@ -0,0 +1,31 @@
+import { ApiExampleBuilder, ValidatorBuilder } from "./types.js";
+
+export class DocGenRules {
+  ignore: string[];
+  examples: Map<string, ApiExampleBuilder>;
+  validators: Map<string, string[]>;
+
+  constructor(params: { ignore: string[]; examples: ApiExampleBuilder[]; validators: ValidatorBuilder[] }) {
+    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<string, ApiExampleBuilder>(
+      examples.flatMap((builder) => builder.fields.map((field) => [field, builder]))
+    );
+
+    this.validators = new Map<string, string[]>(
+      uniqueFieldsToValidate.map((field) => [
+        field,
+        validators.filter((validator) => validator.fields.includes(field)).map((validator) => validator.decorator.name),
+      ])
+    );
+  }
+}

package/src/static.ts

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

package/src/types/global.d.ts

@@ -0,0 +1 @@
+declare module "tsx/esm";