prismadoc 1.0.29

package/dist/entities/field.js

@@ -0,0 +1,192 @@
+import { Helper } from "../utils/helpers.js";
+import { config } from "../utils/loader.js";
+import { Validator } from "./validator.js";
+const helpers = new Helper();
+const rules = config;
+export class DocGenField {
+    name;
+    isArray;
+    default;
+    scalarType;
+    kind;
+    type;
+    fieldType;
+    isEnum = false;
+    isResponse = false;
+    isUpdatedAt = false;
+    isRequired;
+    validators = new Set();
+    scalarField;
+    constructor(field, fieldType) {
+        const { name, isList, type, kind, isRequired, isUpdatedAt } = field;
+        this.name = name;
+        this.isArray = isList;
+        this.scalarType = type;
+        this.kind = kind;
+        this.isRequired = isRequired;
+        this.scalarField = field;
+        this.isUpdatedAt = isUpdatedAt;
+        this.fieldType = fieldType;
+        this.setType();
+        this.setValidators();
+    }
+    processValidator(params) {
+        const validator = new Validator(params);
+        if (this.isArray)
+            validator.inside = {
+                type: "number",
+                content: "{ each: true }",
+            };
+        this.validators.add(validator);
+    }
+    setValidators() {
+        if (this.scalarType === "String" || this.scalarType === "DateTime" || this.scalarType === "Json") {
+            this.processValidator({ name: "IsString" });
+            if (this.isRequired) {
+                this.processValidator({ name: "IsNotEmpty" });
+            }
+        }
+        else if (this.scalarType === "Boolean") {
+            this.processValidator({ name: "IsBoolean" });
+        }
+        else if (this.scalarType === "Int" ||
+            this.scalarType === "BigInt" ||
+            this.scalarType === "Float" ||
+            this.scalarType === "Decimal") {
+            this.processValidator({ name: "IsNumber" });
+        }
+        if (this.isArray) {
+            const validator = new Validator({ name: "IsArray" });
+            this.validators.add(validator);
+        }
+        if (!this.isRequired)
+            this.processValidator({ name: "IsOptional" });
+        if (this.isEnum) {
+            const content = this.isArray ? `${this.type}, { each: true } ` : this.type;
+            this.validators.add(new Validator({
+                name: "IsEnum",
+                inside: {
+                    content,
+                    type: "number",
+                },
+            }));
+        }
+        const findedDecorators = rules.validators.get(this.name);
+        if (findedDecorators) {
+            for (const props of findedDecorators) {
+                const { decorator, inside } = props;
+                this.processValidator({ name: decorator, inside: inside });
+            }
+        }
+    }
+    setType() {
+        if (this.kind === "enum") {
+            this.isEnum = true;
+            this.type = this.scalarType;
+        }
+        else if (this.kind === "object") {
+            this.isResponse = true;
+            this.type = `${this.scalarType}Res`;
+        }
+        else if (this.kind === "scalar") {
+            this.type = Helper.prismaScalarToTs(this.scalarType);
+        }
+    }
+    getRuledExample(fieldName) {
+        const example = rules.examples.get(fieldName)?.example;
+        if (!example && example !== 0) {
+            return "example: 'aaaa'";
+        }
+        const isNumber = Number.isInteger(example);
+        return isNumber ? `example: ${example}` : `example: '${example}'`;
+    }
+    buildApiExample() {
+        const fieldName = this.scalarField.name;
+        const props = [];
+        if (this.isResponse) {
+            if (this.isArray) {
+                props.push(`example: [generateExample(${this.type})]`);
+            }
+            else {
+                props.push(`example: generateExample(${this.type})`);
+            }
+        }
+        else if (rules.examples.get(fieldName)) {
+            props.push(this.getRuledExample(fieldName));
+        }
+        else if (helpers.isDate(this.scalarField)) {
+            props.push(`example: '2025-09-03T03:00:00.000Z'`);
+        }
+        else if (this.scalarField.isId || Helper.splitByUpperCase(this.scalarField.name).includes("Id")) {
+            props.push(`example: 'cmfxu4njg000008l52v7t8qze'`);
+        }
+        else if (this.scalarField.type === "Boolean") {
+            props.push(`example: true`);
+        }
+        else if (this.scalarField.kind === "enum") {
+            const example = [`example: Object.values(${this.scalarField.type}) ${this.isArray ? "" : "[0]"}`];
+            props.push(example.join());
+        }
+        else if (this.scalarField.type === "Int") {
+            props.push(`example: 777`);
+        }
+        else if (this.scalarField.type === "String") {
+            props.push(`example: 'ordinary string'`);
+        }
+        if (this.type === "object") {
+            props.push(`additionalProperties: true`);
+        }
+        else {
+            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.isArray && this.isResponse) {
+                return `[${this.type}]`;
+            }
+            else if (this.isEnum) {
+                return `${this.type}`;
+            }
+            else if (this.isResponse) {
+                return `() => ${this.type}`;
+            }
+            return `'${this.type}'`;
+        };
+        const fieldType = () => {
+            if (this.isArray) {
+                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}, ${this.isArray ? "isArray: true" : ""} })`,
+            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/generic.js

@@ -0,0 +1,24 @@
+import { DocGenFile } from "../file.js";
+import { config } from "../utils/loader.js";
+export class DocGenGeneric {
+    file;
+    constructor() {
+        const imports = `
+      import { ApiProperty } from '@nestjs/swagger';
+      import { IsString, IsNotEmpty } from '${config.validatorPath}';
+    `;
+        const validatorProps = `
+      export class DefaultIdDto {
+        @ApiProperty({ type: 'string', example: 'cmfxu4njg000008l52v7t8qze', required: true })
+        @IsString()
+        @IsNotEmpty()
+        id!: string;
+      }
+    `;
+        const fileContent = [imports, validatorProps];
+        this.file = new DocGenFile({ fileName: "generic.dto.ts", data: fileContent.join("\n"), dir: "" });
+    }
+    build() {
+        this.file.save();
+    }
+}

package/dist/entities/model.js

@@ -0,0 +1,83 @@
+import { DocGenFile } from "../file.js";
+import { Helper } from "../utils/helpers.js";
+import { DocGenDto } from "./dto-generator.js";
+import { DocGenResponse } from "./response-generator.js";
+export class DocGenModel {
+    name;
+    response;
+    dto;
+    fields;
+    exports;
+    file;
+    servicePrefix;
+    constructor(model, servicePrefix) {
+        this.name = model.name;
+        this.fields = model.fields;
+        this.servicePrefix = servicePrefix;
+        const enumImportPath = servicePrefix ? "../enums" : undefined;
+        this.response = new DocGenResponse(model);
+        this.dto = new DocGenDto(model, enumImportPath);
+        const kebabName = Helper.toKebab(this.name);
+        const fileName = servicePrefix ? `${servicePrefix}.${kebabName}` : kebabName;
+        this.exports = [`export * from './types/${fileName}'`];
+        const teste = new Map();
+        const bla = [...this.dto.fields, ...this.response.fields];
+        bla.forEach((field) => {
+            let a = teste.get(field.name);
+            if (!a) {
+                a = [];
+                teste.set(field.name, a);
+            }
+            a.push(field.fieldType);
+        });
+        const fdm = `
+            export namespace Input {
+          ${Array.from(teste)
+            .map(([fieldName, fieldTypes]) => {
+            const name = Helper.capitalizeFirstSafe(fieldName);
+            const types = fieldTypes.map((type) => Helper.capitalizeFirstSafe(type));
+            return `
+              export namespace ${name} {
+                ${types
+                .map((type) => {
+                return `
+                    export type ${type} = ${name + type}
+                    export const ${type} = ${name + type}
+                  `;
+            })
+                .join(";")}
+              }
+            `;
+        })
+            .join(";")}
+        }
+    `;
+        const intaaa = `
+      export namespace ${this.name} {
+        export const Dto = ${this.name}Dto;
+        export type Dto = ${this.name}Dto;
+        export const Res = ${this.name}Res;
+        export type Res = ${this.name}Res;
+        export const Id = ${this.name}Id;
+        export type Id = ${this.name}Id;
+            ${fdm}
+      }
+    `;
+        // Build response primeiro para coletar enums, depois mergear no DTO
+        const responseResult = this.response.build();
+        for (const e of this.response.enums) {
+            this.dto.enums.add(e);
+        }
+        const dtoResult = this.dto.build();
+        const data = [dtoResult, responseResult, intaaa].join("");
+        const fileDir = servicePrefix ? `/${servicePrefix}/types` : "/types";
+        this.file = new DocGenFile({
+            dir: fileDir,
+            fileName: `${fileName}.ts`,
+            data,
+        });
+    }
+    save() {
+        this.file.save();
+    }
+}

package/dist/entities/response-generator.js

@@ -0,0 +1,30 @@
+import { Helper } from "../utils/helpers.js";
+import { DocGenField } from "./field.js";
+export class DocGenResponse {
+    name;
+    // file: DocGenFile;
+    fields = [];
+    enums = new Set();
+    constructor(model) {
+        this.name = model.name;
+        for (const field of model.fields) {
+            if (field.kind === "object")
+                continue;
+            this.fields.push(new DocGenField(field, "res"));
+        }
+    }
+    build() {
+        const sanitizedFields = this.fields
+            .map((field) => {
+            if (field.isEnum) {
+                this.enums.add(field.type);
+            }
+            return `class ${Helper.capitalizeFirstSafe(field.name)}Res {
+          ${field.build()}
+        }`;
+        })
+            .join("\n\n");
+        const intersections = this.fields.map((field) => Helper.capitalizeFirstSafe(field.name) + "Res");
+        return [`${sanitizedFields}`, `class ${this.name}Res extends IntersectionType(${intersections.join(",")}) {}`].join("\n\n");
+    }
+}

package/dist/entities/validator.js

@@ -0,0 +1,16 @@
+export class Validator {
+    name;
+    inside;
+    constructor(params) {
+        const { name, inside } = params;
+        this.name = name;
+        this.inside = inside;
+    }
+    build() {
+        if (!this.inside) {
+            return `@${this.name}()`;
+        }
+        const value = this.inside.type === "number" ? this.inside.content : `'${this.inside.content}'`;
+        return `@${this.name}(${value})`;
+    }
+}

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/fields.ts

@@ -0,0 +1,138 @@
+// AUTO-GERADO: NÃO EDITAR MANUALMENTE. SUJEITO A PAULADAS!
+export const FIELD_NAMES = [
+  "id",
+  "user",
+  "country",
+  "admin",
+  "owner",
+  "customer",
+  "member",
+  "staff",
+  "agenda",
+  "notifications",
+  "twoFactorAuth",
+  "kycAttempts",
+  "tickets",
+  "ticketMessages",
+  "avatarId",
+  "createdAt",
+  "updatedAt",
+  "account",
+  "status",
+  "daysConfig",
+  "meetingGuestIn",
+  "meetingOwnerIn",
+  "accountAgenda",
+  "weekDay",
+  "timeConfigs",
+  "startMin",
+  "endMin",
+  "weekDayConfigId",
+  "weekDayConfig",
+  "planId",
+  "plan",
+  "title",
+  "message",
+  "read",
+  "accountId",
+  "readAt",
+  "name",
+  "posts",
+  "content",
+  "categoryId",
+  "category",
+  "coverId",
+  "imagesId",
+  "publishedAt",
+  "phone",
+  "nationality",
+  "street",
+  "number",
+  "complement",
+  "neighborhood",
+  "city",
+  "state",
+  "zipCode",
+  "kycAttemptId",
+  "kycAttempt",
+  "guests",
+  "meetingOwnerAccountAgendaId",
+  "meetingOwnerAccountAgenda",
+  "startDate",
+  "endDate",
+  "inviteStatus",
+  "agendaId",
+  "meetingId",
+  "meeting",
+  "acceptedAt",
+  "roleId",
+  "role",
+  "email",
+  "code",
+  "expiresAt",
+  "tenant",
+  "externalId",
+  "enabled",
+  "secret",
+  "logs",
+  "action",
+  "success",
+  "accountTwoFactorAuthId",
+  "accountTwoFactorAuth",
+  "privacy",
+  "mimeType",
+  "key",
+  "size",
+  "url",
+  "isUnique",
+  "originalName",
+  "referenceCount",
+  "fileId",
+  "files",
+  "active",
+  "projectId",
+  "privateKey",
+  "clientEmail",
+  "isEnabled",
+  "mandatoryDocuments",
+  "expirationInDays",
+  "maxAttempts",
+  "tenantId",
+  "legalName",
+  "dateOfBirth",
+  "details",
+  "documents",
+  "rejectionReason",
+  "adminComments",
+  "submittedAt",
+  "approvedAt",
+  "rejectedAt",
+  "type",
+  "description",
+  "server",
+  "port",
+  "password",
+  "systemEmail",
+  "inactivatedAt",
+  "permissions",
+  "staffUsers",
+  "price",
+  "customers",
+  "members",
+  "users",
+  "roles",
+  "plans",
+  "policies",
+  "kycConfig",
+  "smtpConfig",
+  "ownerId",
+  "text",
+  "ticketId",
+  "senderAccountId",
+  "senderAccount",
+  "ticket",
+  "applicantAccountId",
+  "applicantAccount",
+  "messages",
+] as const;
+export type FieldName = (typeof FIELD_NAMES)[number];

package/dist/file.js

@@ -0,0 +1,27 @@
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import * as prettier from "prettier";
+import { config } from "./utils/loader.js";
+const ROOT = process.cwd();
+const OUT_DIR = path.join(ROOT, config.outputPath);
+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/generic.dto.ts

@@ -0,0 +1,13 @@
+import { ApiProperty } from "@nestjs/swagger";
+import { IsString, IsNotEmpty } from "src/_nest/validators";
+
+export class DefaultIdDto {
+  @ApiProperty({
+    type: "string",
+    example: "cmfxu4njg000008l52v7t8qze",
+    required: true,
+  })
+  @IsString()
+  @IsNotEmpty()
+  id!: string;
+}

package/dist/index.js

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

package/dist/index.ts

@@ -0,0 +1,40 @@
+export * from "./types/account";
+export * from "./types/admin";
+export * from "./types/account-agenda";
+export * from "./types/agenda-week-day-config";
+export * from "./types/agenda-day-time-config";
+export * from "./types/customer";
+export * from "./types/notification";
+export * from "./types/knowledge-base-category";
+export * from "./types/knowledge-base-post";
+export * from "./types/kyc-attempt-details";
+export * from "./types/meeting";
+export * from "./types/meeting-guest";
+export * from "./types/member";
+export * from "./types/otp-auth-code";
+export * from "./types/otp-auth-code-request-log";
+export * from "./types/owner";
+export * from "./types/push-notification";
+export * from "./types/email-auth-code";
+export * from "./types/account-two-factor-auth";
+export * from "./types/account-two-factor-auth-log";
+export * from "./types/file";
+export * from "./types/dummy";
+export * from "./types/dummy-many";
+export * from "./types/dummy-unique";
+export * from "./types/firebase-config";
+export * from "./types/kyc-config";
+export * from "./types/kyc-attempt";
+export * from "./types/kyc-document";
+export * from "./types/policy";
+export * from "./types/smtp-config";
+export * from "./types/user";
+export * from "./types/staff-role";
+export * from "./types/staff";
+export * from "./types/tenant-plan";
+export * from "./types/tenant-role";
+export * from "./types/tenant";
+export * from "./types/ticket-message";
+export * from "./types/ticket";
+export { FieldName } from "./fields";
+export * as DG from "../dist/index";