prismadoc 1.0.29

package/dist/types/ticket.ts

@@ -0,0 +1,177 @@
+// AUTO-GERADO: NÃO EDITAR MANUALMENTE. SUJEITO A PAULADAS!
+/* eslint-disable @typescript-eslint/no-namespace */
+import { ApiProperty, IntersectionType } from "@nestjs/swagger";
+import { EnumTicketStatus } from "@prisma/client";
+import { IsString, IsNotEmpty, IsEnum, IsOptional } from "src/_nest/validators";
+
+class StatusDto {
+  @ApiProperty({
+    enum: EnumTicketStatus,
+    example: Object.values(EnumTicketStatus)[0],
+    required: true,
+  })
+  @IsEnum(EnumTicketStatus)
+  status!: EnumTicketStatus;
+}
+
+class TitleDto {
+  @ApiProperty({ type: "string", example: "ordinary string", required: true })
+  @IsString()
+  @IsNotEmpty()
+  title!: string;
+}
+
+class TenantIdDto {
+  @ApiProperty({
+    type: "string",
+    example: "cmfxu4njg000008l52v7t8qze",
+    required: false,
+  })
+  @IsString()
+  @IsOptional()
+  tenantId?: string;
+}
+
+class ApplicantAccountIdDto {
+  @ApiProperty({
+    type: "string",
+    example: "cmfxu4njg000008l52v7t8qze",
+    required: true,
+  })
+  @IsString()
+  @IsNotEmpty()
+  applicantAccountId!: string;
+}
+
+class TicketDto extends IntersectionType(
+  StatusDto,
+  TitleDto,
+  TenantIdDto,
+  ApplicantAccountIdDto,
+) {}
+
+class TicketId {
+  @ApiProperty({
+    type: "string",
+    example: "cmfxu4njg000008l52v7t8qze",
+    required: true,
+  })
+  @IsString()
+  @IsNotEmpty()
+  ticketId!: string;
+}
+class IdRes {
+  @ApiProperty({
+    type: "string",
+    example: "cmfxu4njg000008l52v7t8qze",
+    required: true,
+  })
+  id!: string;
+}
+
+class StatusRes {
+  @ApiProperty({
+    enum: EnumTicketStatus,
+    example: Object.values(EnumTicketStatus)[0],
+    required: true,
+  })
+  status!: EnumTicketStatus;
+}
+
+class TitleRes {
+  @ApiProperty({ type: "string", example: "ordinary string", required: true })
+  title!: string;
+}
+
+class TenantIdRes {
+  @ApiProperty({
+    type: "string",
+    example: "cmfxu4njg000008l52v7t8qze",
+    required: false,
+  })
+  tenantId?: string;
+}
+
+class ApplicantAccountIdRes {
+  @ApiProperty({
+    type: "string",
+    example: "cmfxu4njg000008l52v7t8qze",
+    required: true,
+  })
+  applicantAccountId!: string;
+}
+
+class CreatedAtRes {
+  @ApiProperty({
+    type: "string",
+    example: "2025-09-03T03:00:00.000Z",
+    required: true,
+  })
+  createdAt!: Date;
+}
+
+class UpdatedAtRes {
+  @ApiProperty({
+    type: "string",
+    example: "2025-09-03T03:00:00.000Z",
+    required: true,
+  })
+  updatedAt!: Date;
+}
+
+class TicketRes extends IntersectionType(
+  IdRes,
+  StatusRes,
+  TitleRes,
+  TenantIdRes,
+  ApplicantAccountIdRes,
+  CreatedAtRes,
+  UpdatedAtRes,
+) {}
+export namespace Ticket {
+  export const Dto = TicketDto;
+  export type Dto = TicketDto;
+  export const Res = TicketRes;
+  export type Res = TicketRes;
+  export const Id = TicketId;
+  export type Id = TicketId;
+
+  export namespace Input {
+    export namespace Status {
+      export type Dto = StatusDto;
+      export const Dto = StatusDto;
+      export type Res = StatusRes;
+      export const Res = StatusRes;
+    }
+    export namespace Title {
+      export type Dto = TitleDto;
+      export const Dto = TitleDto;
+      export type Res = TitleRes;
+      export const Res = TitleRes;
+    }
+    export namespace TenantId {
+      export type Dto = TenantIdDto;
+      export const Dto = TenantIdDto;
+      export type Res = TenantIdRes;
+      export const Res = TenantIdRes;
+    }
+    export namespace ApplicantAccountId {
+      export type Dto = ApplicantAccountIdDto;
+      export const Dto = ApplicantAccountIdDto;
+      export type Res = ApplicantAccountIdRes;
+      export const Res = ApplicantAccountIdRes;
+    }
+    export namespace Id {
+      export type Res = IdRes;
+      export const Res = IdRes;
+    }
+    export namespace CreatedAt {
+      export type Res = CreatedAtRes;
+      export const Res = CreatedAtRes;
+    }
+    export namespace UpdatedAt {
+      export type Res = UpdatedAtRes;
+      export const Res = UpdatedAtRes;
+    }
+  }
+}

package/dist/types/user.ts

@@ -0,0 +1,281 @@
+// AUTO-GERADO: NÃO EDITAR MANUALMENTE. SUJEITO A PAULADAS!
+/* eslint-disable @typescript-eslint/no-namespace */
+import { ApiProperty, IntersectionType } from "@nestjs/swagger";
+import { EnumUserRole, EnumUserStatus } from "@prisma/client";
+import {
+  IsString,
+  IsNotEmpty,
+  IsEmail,
+  IsStrongPassword,
+  IsEnum,
+  IsOptional,
+} from "src/_nest/validators";
+
+class EmailDto {
+  @ApiProperty({
+    type: "string",
+    example: "email@pinaculodigital.com.br",
+    required: true,
+  })
+  @IsString()
+  @IsNotEmpty()
+  @IsEmail()
+  email!: string;
+}
+
+class PasswordDto {
+  @ApiProperty({ type: "string", example: "Senha123!@#", required: true })
+  @IsString()
+  @IsNotEmpty()
+  @IsStrongPassword()
+  password!: string;
+}
+
+class NameDto {
+  @ApiProperty({ type: "string", example: "Fulano", required: true })
+  @IsString()
+  @IsNotEmpty()
+  name!: string;
+}
+
+class RoleDto {
+  @ApiProperty({
+    enum: EnumUserRole,
+    example: Object.values(EnumUserRole)[0],
+    required: true,
+  })
+  @IsEnum(EnumUserRole)
+  role!: EnumUserRole;
+}
+
+class StatusDto {
+  @ApiProperty({
+    enum: EnumUserStatus,
+    example: Object.values(EnumUserStatus)[0],
+    required: true,
+  })
+  @IsEnum(EnumUserStatus)
+  status!: EnumUserStatus;
+}
+
+class TenantIdDto {
+  @ApiProperty({
+    type: "string",
+    example: "cmfxu4njg000008l52v7t8qze",
+    required: false,
+  })
+  @IsString()
+  @IsOptional()
+  tenantId?: string;
+}
+
+class SystemEmailDto {
+  @ApiProperty({ type: "string", example: "ordinary string", required: false })
+  @IsString()
+  @IsOptional()
+  systemEmail?: string;
+}
+
+class InactivatedAtDto {
+  @ApiProperty({
+    type: "string",
+    example: "2025-09-03T03:00:00.000Z",
+    required: false,
+  })
+  @IsString()
+  @IsOptional()
+  inactivatedAt?: Date;
+}
+
+class UserDto extends IntersectionType(
+  EmailDto,
+  PasswordDto,
+  NameDto,
+  RoleDto,
+  StatusDto,
+  TenantIdDto,
+  SystemEmailDto,
+  InactivatedAtDto,
+) {}
+
+class UserId {
+  @ApiProperty({
+    type: "string",
+    example: "cmfxu4njg000008l52v7t8qze",
+    required: true,
+  })
+  @IsString()
+  @IsNotEmpty()
+  userId!: string;
+}
+class IdRes {
+  @ApiProperty({
+    type: "string",
+    example: "cmfxu4njg000008l52v7t8qze",
+    required: true,
+  })
+  id!: string;
+}
+
+class EmailRes {
+  @ApiProperty({
+    type: "string",
+    example: "email@pinaculodigital.com.br",
+    required: true,
+  })
+  email!: string;
+}
+
+class PasswordRes {
+  @ApiProperty({ type: "string", example: "Senha123!@#", required: true })
+  password!: string;
+}
+
+class NameRes {
+  @ApiProperty({ type: "string", example: "Fulano", required: true })
+  name!: string;
+}
+
+class RoleRes {
+  @ApiProperty({
+    enum: EnumUserRole,
+    example: Object.values(EnumUserRole)[0],
+    required: true,
+  })
+  role!: EnumUserRole;
+}
+
+class StatusRes {
+  @ApiProperty({
+    enum: EnumUserStatus,
+    example: Object.values(EnumUserStatus)[0],
+    required: true,
+  })
+  status!: EnumUserStatus;
+}
+
+class TenantIdRes {
+  @ApiProperty({
+    type: "string",
+    example: "cmfxu4njg000008l52v7t8qze",
+    required: false,
+  })
+  tenantId?: string;
+}
+
+class SystemEmailRes {
+  @ApiProperty({ type: "string", example: "ordinary string", required: false })
+  systemEmail?: string;
+}
+
+class CreatedAtRes {
+  @ApiProperty({
+    type: "string",
+    example: "2025-09-03T03:00:00.000Z",
+    required: true,
+  })
+  createdAt!: Date;
+}
+
+class UpdatedAtRes {
+  @ApiProperty({
+    type: "string",
+    example: "2025-09-03T03:00:00.000Z",
+    required: true,
+  })
+  updatedAt!: Date;
+}
+
+class InactivatedAtRes {
+  @ApiProperty({
+    type: "string",
+    example: "2025-09-03T03:00:00.000Z",
+    required: false,
+  })
+  inactivatedAt?: Date;
+}
+
+class UserRes extends IntersectionType(
+  IdRes,
+  EmailRes,
+  PasswordRes,
+  NameRes,
+  RoleRes,
+  StatusRes,
+  TenantIdRes,
+  SystemEmailRes,
+  CreatedAtRes,
+  UpdatedAtRes,
+  InactivatedAtRes,
+) {}
+export namespace User {
+  export const Dto = UserDto;
+  export type Dto = UserDto;
+  export const Res = UserRes;
+  export type Res = UserRes;
+  export const Id = UserId;
+  export type Id = UserId;
+
+  export namespace Input {
+    export namespace Email {
+      export type Dto = EmailDto;
+      export const Dto = EmailDto;
+      export type Res = EmailRes;
+      export const Res = EmailRes;
+    }
+    export namespace Password {
+      export type Dto = PasswordDto;
+      export const Dto = PasswordDto;
+      export type Res = PasswordRes;
+      export const Res = PasswordRes;
+    }
+    export namespace Name {
+      export type Dto = NameDto;
+      export const Dto = NameDto;
+      export type Res = NameRes;
+      export const Res = NameRes;
+    }
+    export namespace Role {
+      export type Dto = RoleDto;
+      export const Dto = RoleDto;
+      export type Res = RoleRes;
+      export const Res = RoleRes;
+    }
+    export namespace Status {
+      export type Dto = StatusDto;
+      export const Dto = StatusDto;
+      export type Res = StatusRes;
+      export const Res = StatusRes;
+    }
+    export namespace TenantId {
+      export type Dto = TenantIdDto;
+      export const Dto = TenantIdDto;
+      export type Res = TenantIdRes;
+      export const Res = TenantIdRes;
+    }
+    export namespace SystemEmail {
+      export type Dto = SystemEmailDto;
+      export const Dto = SystemEmailDto;
+      export type Res = SystemEmailRes;
+      export const Res = SystemEmailRes;
+    }
+    export namespace InactivatedAt {
+      export type Dto = InactivatedAtDto;
+      export const Dto = InactivatedAtDto;
+      export type Res = InactivatedAtRes;
+      export const Res = InactivatedAtRes;
+    }
+    export namespace Id {
+      export type Res = IdRes;
+      export const Res = IdRes;
+    }
+    export namespace CreatedAt {
+      export type Res = CreatedAtRes;
+      export const Res = CreatedAtRes;
+    }
+    export namespace UpdatedAt {
+      export type Res = UpdatedAtRes;
+      export const Res = UpdatedAtRes;
+    }
+  }
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/helpers.js

@@ -0,0 +1,146 @@
+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 "object";
+            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.replaceAll(/([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: 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) {
+        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";
+    }
+    static splitByUpperCase(str) {
+        return str.split(/(?=[A-Z])/);
+    }
+    isDate(field) {
+        return field.kind === "scalar" && field.type === "DateTime";
+    }
+    // Mais segura (remove espaços do começo e lida melhor com alguns caracteres)
+    static capitalizeFirstSafe(str) {
+        const s = str.trimStart();
+        if (!s)
+            return s;
+        const [first, ...rest] = Array.from(s); // lida melhor com unicode
+        return first.toUpperCase() + rest.join("");
+    }
+}

package/dist/utils/loader.js

@@ -0,0 +1,81 @@
+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;
+    validatorPath;
+    prismaPath;
+    outputPath;
+    externalPrismaSchemas;
+    constructor(configs) {
+        const { examples, ignore, validators, validatorPath, prismaPath, outputPath, externalPrismaSchemas } = configs;
+        this.ignore = ignore;
+        this.examples = examples;
+        this.validators = validators;
+        this.validatorPath = validatorPath;
+        this.prismaPath = prismaPath;
+        this.outputPath = outputPath;
+        this.externalPrismaSchemas = externalPrismaSchemas;
+    }
+    static async readJson(filePath) {
+        const content = await fs.readFile(filePath, "utf8");
+        return JSON.parse(content);
+    }
+    /** Carrega variáveis do .env do projeto para process.env (sem sobrescrever) */
+    static async loadEnvFile() {
+        const envPath = path.join(process.cwd(), ".env");
+        try {
+            const content = await fs.readFile(envPath, "utf-8");
+            for (const line of content.split("\n")) {
+                const trimmed = line.trim();
+                if (!trimmed || trimmed.startsWith("#"))
+                    continue;
+                const eqIndex = trimmed.indexOf("=");
+                if (eqIndex === -1)
+                    continue;
+                const key = trimmed.slice(0, eqIndex).trim();
+                const rawValue = trimmed.slice(eqIndex + 1).trim();
+                // Remove aspas e comentários inline
+                const value = rawValue.replaceAll(/^["']|["']$/g, "").split("#")[0].trim();
+                if (!process.env[key]) {
+                    process.env[key] = value;
+                }
+            }
+        }
+        catch {
+            // .env não encontrado, ignorar
+        }
+    }
+    static async load() {
+        // Carrega .env antes de tudo
+        await this.loadEnvFile();
+        // 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}`);
+        }
+        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();