nest-prisma_doc-gen 1.0.0

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

@@ -0,0 +1,13 @@
+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/dto-generator.js

@@ -0,0 +1,51 @@
+import { DocGenFile } from "../file.js";
+import { Helper } from "../helpers/helpers.js";
+import { Static } from "../static.js";
+import { DocGenField } from "./field.js";
+export class DocGenDto {
+    name;
+    file;
+    fields = [];
+    imports = new Set([`${Static.AUTO_GENERATED_COMMENT}`, `import { ApiProperty } from '@nestjs/swagger'`]);
+    classValidators = new Set();
+    enums = new Set();
+    constructor(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/dist/entities/entity-generator.d.ts

@@ -0,0 +1,12 @@
+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/entity-generator.js

@@ -0,0 +1,47 @@
+import { DocGenFile } from "../file.js";
+import { Helper } from "../helpers/helpers.js";
+import { Static } from "../static.js";
+import { DocGenField } from "./field.js";
+export class DocGenEntity {
+    name;
+    file;
+    fields = [];
+    imports = new Set([`${Static.AUTO_GENERATED_COMMENT}`, `import { ApiProperty } from '@nestjs/swagger'`]);
+    enums = new Set();
+    constructor(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/dist/entities/enum.d.ts

@@ -0,0 +1,22 @@
+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/enum.js

@@ -0,0 +1,37 @@
+import { DocGenFile } from "../file.js";
+export class DocGenEnum {
+    name;
+    values;
+    dbName;
+    constructor(params) {
+        const { dbName, name, values } = params;
+        this.dbName = dbName;
+        this.name = name;
+        this.values = values;
+    }
+}
+export class DocEnums {
+    enums;
+    file;
+    constructor(enums) {
+        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/dist/entities/field.d.ts

@@ -0,0 +1,24 @@
+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/field.js

@@ -0,0 +1,169 @@
+import { Helper } from "../helpers/helpers.js";
+import { config } from "../helpers/loader.js";
+import { Static } from "../static.js";
+import { Validator } from "./validator.js";
+const helpers = new Helper();
+const rules = config;
+export class DocGenField {
+    name;
+    isList;
+    default;
+    scalarType;
+    kind;
+    type;
+    fieldType;
+    isEnum = false;
+    isEntity = false;
+    isUpdatedAt = false;
+    isRequired;
+    validators = new Set();
+    scalarField;
+    constructor(field, 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();
+    }
+    processValidator(name) {
+        const validator = new Validator({ name });
+        if (this.isList)
+            validator.content = "{ each: true }";
+        this.validators.add(validator);
+    }
+    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);
+            });
+        }
+    }
+    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);
+        }
+    }
+    buildApiExample() {
+        const fieldName = this.scalarField.name;
+        const props = [];
+        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;
+    }
+    sanitizeValidators() {
+        const sanitizedValidators = Array.from(this.validators).map((validator) => {
+            return validator.build();
+        });
+        return sanitizedValidators;
+    }
+    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/dist/entities/model.d.ts

@@ -0,0 +1,11 @@
+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/entities/model.js

@@ -0,0 +1,18 @@
+import { DocGenDto } from "./dto-generator.js";
+import { DocGenEntity } from "./entity-generator.js";
+export class DocGenModel {
+    name;
+    entitie;
+    createDtos;
+    fields;
+    constructor(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/dist/entities/validator.js

@@ -0,0 +1,12 @@
+export class Validator {
+    name;
+    content;
+    constructor(params) {
+        const { content, name } = params;
+        this.name = name;
+        this.content = content ?? "";
+    }
+    build() {
+        return `@${this.name}(${this.content})`;
+    }
+}

package/dist/field.type.d.ts

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

package/dist/field.type.js

@@ -0,0 +1,22 @@
+import { DocGenFile } from "./file.js";
+import { Static } from "./static.js";
+export class DocFields {
+    fields;
+    file;
+    constructor(fields) {
+        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/dist/file.d.ts

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

package/dist/file.js

@@ -0,0 +1,26 @@
+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;
+    data;
+    constructor(params) {
+        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/dist/helpers/helpers.d.ts

@@ -0,0 +1,14 @@
+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/helpers.js

@@ -0,0 +1,143 @@
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+export class Helper {
+    static prismaScalarToTs(s) {
+        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) {
+        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) {
+        // 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) {
+        return s.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+    }
+    importsForModel(model) {
+        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) {
+        const files = [];
+        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) {
+        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) {
+        return field.kind === "scalar" && field.type === "DateTime";
+    }
+}

package/dist/helpers/loader.d.ts

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