nest-prisma_doc-gen 1.0.2 → 1.0.4

package/dist/static.d.ts

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

@@ -1,79 +0,0 @@
-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/src/entities/dto-generator.ts

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

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

@@ -1,47 +0,0 @@
-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")}
-    `;
-  }
-}

package/src/entities/field.ts

@@ -1,188 +0,0 @@
-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.scalarType === "Json") {
-      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

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

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

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

@@ -1,34 +0,0 @@
-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, "src/types/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

@@ -1,152 +0,0 @@
-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";
-  }
-}