prisma-entity-gen 0.1.0

package/dist/index.cjs

@@ -0,0 +1,691 @@
+'use strict';
+
+var fs = require('fs');
+var path = require('path');
+var zod = require('zod');
+var prismaAst = require('@mrleebo/prisma-ast');
+
+// src/config/loader.ts
+var ConfigSchema = zod.z.object({
+  /**
+   * Caminho para o schema.prisma
+   * @default "prisma/schema.prisma"
+   */
+  schemaPath: zod.z.string().default("prisma/schema.prisma"),
+  /**
+   * Diretório de saída das entities geradas
+   * @default "src/entities"
+   */
+  outputDir: zod.z.string().default("src/entities"),
+  /**
+   * Modo de geração:
+   * - "type"  → type aliases e interfaces puras (melhor performance TS)
+   * - "class" → classes com decorators (NestJS / class-validator)
+   * - "both"  → gera os dois em subpastas /types e /classes
+   */
+  mode: zod.z.enum(["type", "class", "both"]).default("type"),
+  /**
+   * Quando mode="class", inclui decorators do class-validator
+   * @default false
+   */
+  classValidator: zod.z.boolean().default(false),
+  /**
+   * Quando mode="class", inclui decorators do class-transformer
+   * @default false
+   */
+  classTransformer: zod.z.boolean().default(false),
+  /**
+   * Gera barrel index.ts na raiz do outputDir
+   * @default true
+   */
+  barrel: zod.z.boolean().default(true),
+  /**
+   * Modelos a ignorar na geração
+   * @default []
+   */
+  exclude: zod.z.array(zod.z.string()).default([]),
+  /**
+   * Apenas esses modelos serão gerados (vazio = todos)
+   * @default []
+   */
+  include: zod.z.array(zod.z.string()).default([]),
+  /**
+   * Formato de saída dos enums:
+   * - "enum"  → export enum Role { ADMIN = "ADMIN" }
+   * - "union" → export type Role = "ADMIN" | "USER"
+   * Use "union" para evitar conflitos com enums do @prisma/client
+   * @default "enum"
+   */
+  enumOutput: zod.z.enum(["enum", "union"]).default("enum"),
+  /**
+   * Define se campos de relação são opcionais ou obrigatórios na entity gerada:
+   * - "optional" → relações sempre com ? (compatível com queries sem include)
+   * - "required" → relações sem ? (requer include em toda query que retornar o tipo)
+   * @default "optional"
+   */
+  relations: zod.z.enum(["optional", "required"]).default("optional"),
+  /**
+   * Sufixo dos arquivos gerados
+   * @default "entity"
+   * Resulta em: user.entity.ts
+   */
+  suffix: zod.z.string().default("entity"),
+  /**
+   * Simula a geração sem escrever arquivos
+   * @default false
+   */
+  dryRun: zod.z.boolean().default(false),
+  /**
+   * Nível de log: "silent" | "info" | "verbose"
+   * @default "info"
+   */
+  logLevel: zod.z.enum(["silent", "info", "verbose"]).default("info")
+});
+var DEFAULT_CONFIG = ConfigSchema.parse({});
+
+// src/config/loader.ts
+var RC_FILES = [
+  ".entitygenrc.json",
+  "entitygen.config.json",
+  ".entitygenrc"
+];
+var ConfigError = class extends Error {
+  constructor(message, cause) {
+    super(message, { cause });
+    this.name = "ConfigError";
+  }
+};
+function loadConfig(cwd = process.cwd()) {
+  const rcFile = RC_FILES.map((f) => path.resolve(cwd, f)).find(fs.existsSync);
+  if (!rcFile) {
+    return ConfigSchema.parse({});
+  }
+  let raw;
+  try {
+    raw = JSON.parse(fs.readFileSync(rcFile, "utf-8"));
+  } catch (err) {
+    throw new ConfigError(`Falha ao ler ${rcFile}: arquivo JSON inv\xE1lido`, err);
+  }
+  try {
+    return ConfigSchema.parse(raw);
+  } catch (err) {
+    if (err instanceof zod.ZodError) {
+      const messages = err.errors.map((e) => `  \u2022 ${e.path.join(".")} \u2014 ${e.message}`).join("\n");
+      throw new ConfigError(
+        `Config inv\xE1lido em ${rcFile}:
+${messages}`,
+        err
+      );
+    }
+    throw err;
+  }
+}
+
+// src/parser/types.ts
+var PRISMA_TO_TS = {
+  String: "string",
+  Boolean: "boolean",
+  Int: "number",
+  BigInt: "bigint",
+  Float: "number",
+  Decimal: "string",
+  // Decimal não tem tipo nativo TS — string é mais seguro que number
+  DateTime: "Date",
+  Json: "Record<string, unknown>",
+  Bytes: "Buffer"
+};
+var SCALARS = new Set(Object.keys(PRISMA_TO_TS));
+function isScalar(type) {
+  return SCALARS.has(type);
+}
+function resolveTsType(prismaType, knownEnums) {
+  if (isScalar(prismaType)) return PRISMA_TO_TS[prismaType];
+  if (knownEnums.has(prismaType)) return prismaType;
+  return prismaType;
+}
+
+// src/parser/relations.ts
+function detectCircularRefs(graph) {
+  const color = /* @__PURE__ */ new Map();
+  const circular = /* @__PURE__ */ new Map();
+  for (const node of graph.keys()) {
+    color.set(node, "white");
+    circular.set(node, /* @__PURE__ */ new Set());
+  }
+  function addCircular(a, b) {
+    circular.get(a)?.add(b);
+    circular.get(b)?.add(a);
+  }
+  function dfs(node, ancestors) {
+    color.set(node, "gray");
+    for (const neighbor of graph.get(node) ?? []) {
+      if (!color.has(neighbor)) continue;
+      if (color.get(neighbor) === "gray") {
+        addCircular(node, neighbor);
+        for (const anc of ancestors) {
+          if (color.get(anc) === "gray") {
+            addCircular(anc, neighbor);
+            addCircular(node, anc);
+          }
+        }
+      } else if (color.get(neighbor) === "white") {
+        dfs(neighbor, [...ancestors, node]);
+      }
+    }
+    color.set(node, "black");
+  }
+  for (const node of graph.keys()) {
+    if (color.get(node) === "white") {
+      dfs(node, []);
+    }
+  }
+  return circular;
+}
+
+// src/parser/index.ts
+function hasAttribute(field, name) {
+  return field.attributes?.some((a) => a.name === name) ?? false;
+}
+function hasDefault(field) {
+  return hasAttribute(field, "default") || hasAttribute(field, "updatedAt");
+}
+function parseEnum(node) {
+  const values = node.enumerators.filter((e) => e.type === "enumerator").map((e) => e.name);
+  return { name: node.name, values, documentation: node.comment };
+}
+function parseField(field, knownModels, knownEnums) {
+  return {
+    name: field.name,
+    prismaType: field.fieldType,
+    tsType: resolveTsType(field.fieldType, knownEnums),
+    isOptional: field.optional,
+    isArray: field.array,
+    isRelation: knownModels.has(field.fieldType),
+    isCircular: false,
+    hasDefault: hasDefault(field),
+    isId: hasAttribute(field, "id"),
+    isUnique: hasAttribute(field, "unique"),
+    isUpdatedAt: hasAttribute(field, "updatedAt"),
+    decorators: []
+  };
+}
+function parseModel(node, knownModels, knownEnums) {
+  const fields = node.properties.filter((p) => p.type === "field").map((f) => parseField(f, knownModels, knownEnums));
+  const relations = [...new Set(
+    fields.filter((f) => f.isRelation).map((f) => f.prismaType)
+  )];
+  return {
+    name: node.name,
+    fields,
+    relations,
+    circularRefs: [],
+    documentation: node.comment
+  };
+}
+var ParseError = class extends Error {
+  constructor(message, cause) {
+    super(message, { cause });
+    this.name = "ParseError";
+  }
+};
+function parseSchema(schemaPath) {
+  let raw;
+  try {
+    raw = fs.readFileSync(schemaPath, "utf-8");
+  } catch (err) {
+    throw new ParseError(`N\xE3o foi poss\xEDvel ler o schema em "${schemaPath}"`, err);
+  }
+  return parseSchemaString(raw);
+}
+function parseSchemaString(schemaContent) {
+  let ast;
+  try {
+    ast = prismaAst.getSchema(schemaContent);
+  } catch (err) {
+    throw new ParseError("Falha ao fazer parse do schema Prisma", err);
+  }
+  const rawNodes = ast.list;
+  const knownModels = new Set(
+    rawNodes.filter((n) => n.type === "model").map((n) => n.name)
+  );
+  const knownEnums = new Set(
+    rawNodes.filter((n) => n.type === "enum").map((n) => n.name)
+  );
+  const enums = rawNodes.filter((n) => n.type === "enum").map((n) => parseEnum(n));
+  const models = rawNodes.filter((n) => n.type === "model").map((n) => parseModel(n, knownModels, knownEnums));
+  const graph = new Map(models.map((m) => [m.name, m.relations]));
+  const circularMap = detectCircularRefs(graph);
+  for (const model of models) {
+    const circulars = circularMap.get(model.name) ?? /* @__PURE__ */ new Set();
+    model.circularRefs = [...circulars];
+    for (const field of model.fields) {
+      if (field.isRelation && circulars.has(field.prismaType)) {
+        field.isCircular = true;
+      }
+    }
+  }
+  return { models, enums };
+}
+
+// src/emitters/base.ts
+function fileHeader() {
+  return [
+    "/**",
+    " * ARQUIVO GERADO AUTOMATICAMENTE \u2014 N\xC3O EDITE MANUALMENTE.",
+    " * Gerado por prisma-entity-gen. Rode o gerador para atualizar.",
+    " */",
+    ""
+  ].join("\n");
+}
+function formatFieldType(tsType, isArray, isOptional, isCircular) {
+  const base = isArray ? `${tsType}[]` : tsType;
+  const nullable = isOptional ? ` | null` : "";
+  return `${base}${nullable}`;
+}
+function formatJsDoc(doc) {
+  if (!doc) return "";
+  const lines = doc.split("\n").map((l) => ` * ${l.trim()}`).join("\n");
+  return `/**
+${lines}
+ */
+`;
+}
+var BaseEmitter = class {
+};
+
+// src/emitters/type.emitter.ts
+function toKebab(name) {
+  return name.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").toLowerCase();
+}
+var TypeEmitter = class extends BaseEmitter {
+  constructor(options = {}) {
+    super();
+    this.options = options;
+  }
+  options;
+  emit(model, enums) {
+    const enumNames = new Set(enums.map((e) => e.name));
+    const lines = [fileHeader()];
+    const relationImports = this.collectRelationImports(model, enumNames);
+    if (relationImports.length > 0) {
+      for (const imp of relationImports) lines.push(imp);
+      lines.push("");
+    }
+    const enumImports = this.collectEnumImports(model, enumNames);
+    if (enumImports.length > 0) {
+      for (const imp of enumImports) lines.push(imp);
+      lines.push("");
+    }
+    if (model.documentation) lines.push(formatJsDoc(model.documentation));
+    lines.push(`export interface ${model.name}Entity {`);
+    for (const field of model.fields) {
+      lines.push(`  ${this.formatField(field)}`);
+    }
+    lines.push("}");
+    lines.push("");
+    return lines.join("\n");
+  }
+  formatField(field) {
+    const relationsOptional = this.options.relations !== "required";
+    const optional = field.isRelation && relationsOptional || field.isOptional ? "?" : "";
+    const tsType = field.isRelation ? `${field.prismaType}Entity` : field.tsType;
+    const type = formatFieldType(tsType, field.isArray, field.isOptional, field.isCircular);
+    return `${field.name}${optional}: ${type};`;
+  }
+  collectRelationImports(model, enumNames) {
+    const seen = /* @__PURE__ */ new Set();
+    const imports = [];
+    for (const field of model.fields) {
+      if (field.isRelation && !enumNames.has(field.prismaType) && !seen.has(field.prismaType) && field.prismaType !== model.name) {
+        seen.add(field.prismaType);
+        imports.push(
+          `import type { ${field.prismaType}Entity } from "./${toKebab(field.prismaType)}.entity.js";`
+        );
+      }
+    }
+    return imports;
+  }
+  collectEnumImports(model, enumNames) {
+    const seen = /* @__PURE__ */ new Set();
+    const imports = [];
+    for (const field of model.fields) {
+      if (enumNames.has(field.prismaType) && !seen.has(field.prismaType)) {
+        seen.add(field.prismaType);
+        imports.push(
+          `import { ${field.prismaType} } from "./${toKebab(field.prismaType)}.enum.js";`
+        );
+      }
+    }
+    return imports;
+  }
+};
+
+// src/emitters/class.emitter.ts
+var ClassEmitter = class extends BaseEmitter {
+  constructor(options = {}) {
+    super();
+    this.options = options;
+  }
+  options;
+  emit(model, enums) {
+    const enumNames = new Set(enums.map((e) => e.name));
+    const lines = [fileHeader()];
+    const cvImports = this.collectCvImports(model, enumNames);
+    if (this.options.classValidator && cvImports.length > 0) {
+      lines.push(`import { ${cvImports.join(", ")} } from "class-validator";`);
+    }
+    if (this.options.classTransformer) {
+      lines.push(`import { Type } from "class-transformer";`);
+    }
+    if (this.options.classValidator && cvImports.length > 0 || this.options.classTransformer) {
+      lines.push("");
+    }
+    const relationImports = this.collectRelationImports(model, enumNames);
+    if (relationImports.length > 0) {
+      for (const imp of relationImports) lines.push(imp);
+      lines.push("");
+    }
+    const enumImports = this.collectEnumImports(model, enumNames);
+    if (enumImports.length > 0) {
+      for (const imp of enumImports) lines.push(imp);
+      lines.push("");
+    }
+    if (model.documentation) lines.push(formatJsDoc(model.documentation));
+    lines.push(`export class ${model.name}Entity {`);
+    for (const field of model.fields) {
+      const fieldLines = this.formatField(field, enumNames);
+      for (const l of fieldLines) lines.push(`  ${l}`);
+    }
+    lines.push("}");
+    lines.push("");
+    return lines.join("\n");
+  }
+  formatField(field, enumNames) {
+    const lines = [];
+    if (this.options.classValidator) {
+      const decorators = this.getCvDecorators(field, enumNames);
+      for (const d of decorators) lines.push(d);
+    }
+    if (this.options.classTransformer && field.isRelation && !field.isCircular) {
+      lines.push(`@Type(() => ${field.tsType}Entity)`);
+    }
+    const optional = field.isOptional || field.hasDefault ? "?" : "!";
+    const type = formatFieldType(
+      field.isRelation && !field.isCircular ? `${field.tsType}Entity` : field.tsType,
+      field.isArray,
+      field.isOptional,
+      field.isCircular
+    );
+    const comment = field.isCircular ? " // circular ref \u2014 usar Ref" : "";
+    lines.push(`${field.name}${optional}: ${type};${comment}`);
+    lines.push("");
+    return lines;
+  }
+  getCvDecorators(field, enumNames) {
+    const decorators = [];
+    if (field.isOptional || field.hasDefault) {
+      decorators.push("@IsOptional()");
+    }
+    if (field.isArray) {
+      decorators.push("@IsArray()");
+    }
+    if (field.isRelation || enumNames.has(field.prismaType)) {
+      return decorators;
+    }
+    switch (field.prismaType) {
+      case "String":
+        decorators.push("@IsString()");
+        break;
+      case "Boolean":
+        decorators.push("@IsBoolean()");
+        break;
+      case "Int":
+      case "Float":
+      case "Decimal":
+        decorators.push("@IsNumber()");
+        break;
+      case "BigInt":
+        decorators.push("@IsInt()");
+        break;
+      case "DateTime":
+        decorators.push("@IsDate()");
+        break;
+    }
+    return decorators;
+  }
+  collectCvImports(model, enumNames) {
+    const imports = /* @__PURE__ */ new Set();
+    for (const field of model.fields) {
+      if (field.isOptional || field.hasDefault) imports.add("IsOptional");
+      if (field.isArray) imports.add("IsArray");
+      if (field.isRelation || enumNames.has(field.prismaType)) continue;
+      switch (field.prismaType) {
+        case "String":
+          imports.add("IsString");
+          break;
+        case "Boolean":
+          imports.add("IsBoolean");
+          break;
+        case "Int":
+        case "Float":
+        case "Decimal":
+          imports.add("IsNumber");
+          break;
+        case "BigInt":
+          imports.add("IsInt");
+          break;
+        case "DateTime":
+          imports.add("IsDate");
+          break;
+      }
+    }
+    return [...imports].sort();
+  }
+  collectRelationImports(model, enumNames) {
+    const seen = /* @__PURE__ */ new Set();
+    const imports = [];
+    for (const field of model.fields) {
+      if (field.isRelation && !field.isCircular && !enumNames.has(field.prismaType) && !seen.has(field.prismaType)) {
+        seen.add(field.prismaType);
+        const fileName = field.prismaType.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").toLowerCase();
+        imports.push(
+          `import { ${field.prismaType}Entity } from "./${fileName}.entity.js";`
+        );
+      }
+    }
+    return imports;
+  }
+  collectEnumImports(model, enumNames) {
+    const seen = /* @__PURE__ */ new Set();
+    const imports = [];
+    for (const field of model.fields) {
+      if (enumNames.has(field.prismaType) && !seen.has(field.prismaType)) {
+        seen.add(field.prismaType);
+        const fileName = field.prismaType.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").toLowerCase();
+        imports.push(
+          `import { ${field.prismaType} } from "./${fileName}.enum.js";`
+        );
+      }
+    }
+    return imports;
+  }
+};
+var FileWriter = class {
+  constructor(outputDir, dryRun, logger) {
+    this.outputDir = outputDir;
+    this.dryRun = dryRun;
+    this.logger = logger;
+  }
+  outputDir;
+  dryRun;
+  logger;
+  writeAll(files) {
+    const result = { written: [], skipped: [] };
+    if (!this.dryRun) {
+      fs.mkdirSync(path.resolve(this.outputDir), { recursive: true });
+    }
+    for (const file of files) {
+      const absPath = path.resolve(this.outputDir, file.relativePath);
+      if (this.dryRun) {
+        this.logger.info(`[dry-run] ${file.relativePath}`);
+        result.skipped.push(absPath);
+        continue;
+      }
+      fs.mkdirSync(path.dirname(absPath), { recursive: true });
+      fs.writeFileSync(absPath, file.content, "utf-8");
+      this.logger.success(file.relativePath);
+      result.written.push(absPath);
+    }
+    return result;
+  }
+};
+
+// src/writer/barrel.ts
+function generateBarrel(files) {
+  const exports$1 = files.filter((f) => !f.relativePath.endsWith("index.ts")).map((f) => {
+    const path = f.relativePath.replace(/\.ts$/, ".js");
+    return `export * from "./${path}";`;
+  }).sort();
+  return [fileHeader(), ...exports$1, ""].join("\n");
+}
+
+// src/logger.ts
+var LEVELS = {
+  silent: 0,
+  info: 1,
+  verbose: 2
+};
+var Logger = class {
+  level;
+  constructor(logLevel = "info") {
+    this.level = LEVELS[logLevel];
+  }
+  info(msg) {
+    if (this.level >= LEVELS.info) {
+      console.log(`  ${msg}`);
+    }
+  }
+  verbose(msg) {
+    if (this.level >= LEVELS.verbose) {
+      console.log(`  [verbose] ${msg}`);
+    }
+  }
+  success(msg) {
+    if (this.level >= LEVELS.info) {
+      console.log(`  \u2713 ${msg}`);
+    }
+  }
+  warn(msg) {
+    if (this.level >= LEVELS.info) {
+      console.warn(`  \u26A0 ${msg}`);
+    }
+  }
+  error(msg) {
+    console.error(`  \u2717 ${msg}`);
+  }
+};
+
+// src/generator.ts
+function toKebabCase(name) {
+  return name.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").toLowerCase();
+}
+function shouldInclude(name, config) {
+  if (config.include.length > 0 && !config.include.includes(name)) return false;
+  if (config.exclude.includes(name)) return false;
+  return true;
+}
+function buildFiles(models, enums, config) {
+  const files = [];
+  const useType = config.mode === "type" || config.mode === "both";
+  const useClass = config.mode === "class" || config.mode === "both";
+  const typeEmitter = useType ? new TypeEmitter({ relations: config.relations }) : null;
+  const classEmitter = useClass ? new ClassEmitter({
+    classValidator: config.classValidator,
+    classTransformer: config.classTransformer
+  }) : null;
+  const typeDir = config.mode === "both" ? "types/" : "";
+  const classDir = config.mode === "both" ? "classes/" : "";
+  for (const model of models) {
+    if (!shouldInclude(model.name, config)) continue;
+    const fileName = `${toKebabCase(model.name)}.${config.suffix}.ts`;
+    if (typeEmitter) {
+      files.push({
+        relativePath: `${typeDir}${fileName}`,
+        content: typeEmitter.emit(model, enums),
+        sourceName: model.name
+      });
+    }
+    if (classEmitter) {
+      files.push({
+        relativePath: `${classDir}${fileName}`,
+        content: classEmitter.emit(model, enums),
+        sourceName: model.name
+      });
+    }
+  }
+  for (const enumDef of enums) {
+    if (!shouldInclude(enumDef.name, config)) continue;
+    const fileName = `${toKebabCase(enumDef.name)}.enum.ts`;
+    const content = buildEnumFile(enumDef, config.enumOutput);
+    if (typeDir) files.push({ relativePath: `${typeDir}${fileName}`, content, sourceName: enumDef.name });
+    else files.push({ relativePath: fileName, content, sourceName: enumDef.name });
+    if (classDir) files.push({ relativePath: `${classDir}${fileName}`, content, sourceName: enumDef.name });
+  }
+  return files;
+}
+function buildEnumFile(enumDef, enumOutput) {
+  const header = [
+    "/**",
+    " * ARQUIVO GERADO AUTOMATICAMENTE \u2014 N\xC3O EDITE MANUALMENTE.",
+    " * Gerado por prisma-entity-gen. Rode o gerador para atualizar.",
+    " */",
+    ""
+  ];
+  if (enumOutput === "union") {
+    const union = enumDef.values.map((v) => `"${v}"`).join(" | ");
+    return [...header, `export type ${enumDef.name} = ${union};`, ""].join("\n");
+  }
+  return [
+    ...header,
+    `export enum ${enumDef.name} {`,
+    ...enumDef.values.map((v) => `  ${v} = "${v}",`),
+    "}",
+    ""
+  ].join("\n");
+}
+async function generate(config) {
+  const logger = new Logger(config.logLevel);
+  logger.verbose(`Lendo schema: ${config.schemaPath}`);
+  const { models, enums } = parseSchema(config.schemaPath);
+  logger.info(`${models.length} models encontrados`);
+  logger.info(`${enums.length} enums encontrados`);
+  const files = buildFiles(models, enums, config);
+  logger.verbose(`${files.length} arquivos a gerar`);
+  if (config.barrel) {
+    files.push({
+      relativePath: "index.ts",
+      content: generateBarrel(files),
+      sourceName: "barrel"
+    });
+  }
+  const writer = new FileWriter(config.outputDir, config.dryRun, logger);
+  const result = writer.writeAll(files);
+  if (config.dryRun) {
+    logger.info(`${result.skipped.length} arquivos seriam gerados`);
+  } else {
+    logger.success(`${result.written.length} arquivos gerados em ${config.outputDir}`);
+  }
+}
+
+exports.ClassEmitter = ClassEmitter;
+exports.ConfigError = ConfigError;
+exports.ConfigSchema = ConfigSchema;
+exports.DEFAULT_CONFIG = DEFAULT_CONFIG;
+exports.ParseError = ParseError;
+exports.TypeEmitter = TypeEmitter;
+exports.generate = generate;
+exports.loadConfig = loadConfig;
+exports.parseSchema = parseSchema;
+exports.parseSchemaString = parseSchemaString;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map