hekireki 0.5.1 → 0.6.1

package/README.md

@@ -1,3 +1,5 @@
+![img](https://raw.githubusercontent.com/nakita628/hekireki/refs/heads/main/assets/img/hekireki.png)
+
 # Hekireki
 
 **[Hekireki](https://www.npmjs.com/package/hekireki)** is a tool that generates validation schemas for Zod, Valibot, ArkType, and Effect Schema, as well as ER diagrams, from [Prisma](https://www.prisma.io/) schemas annotated with comments.
@@ -9,8 +11,7 @@
 - 🏹 Automatically generates [ArkType](https://arktype.io/) schemas from your Prisma schema
 - ⚡ Automatically generates [Effect Schema](https://effect.website/docs/schema/introduction/) from your Prisma schema
 - 📊 Creates [Mermaid](https://mermaid.js.org/) ER diagrams with PK/FK markers
-- 📝 Generates [DBML](https://dbml.dbdiagram.io/) (Database Markup Language) files
-- 🖼️ Outputs ER diagrams as **PNG/SVG** images using [dbml-renderer](https://github.com/softwaretechnik-berlin/dbml-renderer)
+- 📝 Generates [DBML](https://dbml.dbdiagram.io/) (Database Markup Language) files and **PNG** ER diagrams via [dbml-renderer](https://github.com/softwaretechnik-berlin/dbml-renderer) — output format is determined by the file extension (`.dbml` or `.png`)
 - 🧪 Generates [Ecto](https://hexdocs.pm/ecto/Ecto.Schema.html) schemas for Elixir projects
   ⚠️ Foreign key constraints are **not** included — manage relationships in your application logic
 
@@ -51,28 +52,30 @@ generator Hekireki-ArkType {
     provider = "hekireki-arktype"
     type     = true
     comment  = true
+    relation = true
 }
 
 generator Hekireki-Effect {
     provider = "hekireki-effect"
     type     = true
     comment  = true
+    relation = true
 }
 
 generator Hekireki-Ecto {
     provider = "hekireki-ecto"
-    output = "schema"
+    output = "./ecto"
     app = "DBSchema"
 }
 
 generator Hekireki-DBML {
     provider = "hekireki-dbml"
+    output   = "docs/schema.dbml"
 }
 
-generator Hekireki-SVG {
-    provider = "hekireki-svg"
-    output   = "docs"
-    format   = "png"
+generator Hekireki-Docs {
+    provider = "hekireki-docs"
+    output   = "./docs"
 }
 
 model User {
@@ -122,9 +125,9 @@ model Post {
 }
 ```
 
-## Generate
+## Generated Output
 
-## Zod
+### Zod
 
 ```ts
 import * as z from 'zod'
@@ -178,7 +181,7 @@ export const PostRelationsSchema = z.object({
 export type PostRelations = z.infer<typeof PostRelationsSchema>
 ```
 
-## Valibot
+### Valibot
 
 ```ts
 import * as v from 'valibot'
@@ -232,7 +235,7 @@ export const PostRelationsSchema = v.object({
 export type PostRelations = v.InferInput<typeof PostRelationsSchema>
 ```
 
-## ArkType
+### ArkType
 
 ```ts
 import { type } from 'arktype'
@@ -260,7 +263,7 @@ export const PostSchema = type({
 export type Post = typeof PostSchema.infer
 ```
 
-## Effect Schema
+### Effect Schema
 
 ```ts
 import { Schema } from 'effect'
@@ -288,7 +291,7 @@ export const PostSchema = Schema.Struct({
 export type Post = Schema.Schema.Type<typeof PostSchema>
 ```
 
-## Mermaid
+### Mermaid
 
 ```mermaid
 erDiagram
@@ -305,7 +308,7 @@ erDiagram
     }
 ```
 
-## Ecto
+### Ecto
 
 ```elixir
 defmodule DBSchema.User do
@@ -345,7 +348,7 @@ defmodule DBSchema.Post do
 end
 ```
 
-## DBML
+### DBML
 
 ```dbml
 Table User {
@@ -365,11 +368,27 @@ Table Post {
 Ref Post_userId_fk: Post.userId > User.id
 ```
 
-## PNG/SVG
+### PNG
 
-The `hekireki-svg` generator outputs ER diagrams as PNG or SVG images using [dbml-renderer](https://github.com/softwaretechnik-berlin/dbml-renderer).
+The `hekireki-dbml` generator also outputs ER diagrams as PNG images when the `output` path ends with `.png`:
 
-Output: `docs/er-diagram.png`
+```prisma
+generator Hekireki-PNG {
+    provider = "hekireki-dbml"
+    output   = "docs/er-diagram.png"
+}
+```
+
+### Docs
+
+The `hekireki-docs` generator creates an HTML documentation page from your Prisma schema. Serve it locally with `hekireki docs serve`:
+
+```prisma
+generator Hekireki-Docs {
+    provider = "hekireki-docs"
+    output   = "./docs"
+}
+```
 
 ## Configuration
 
@@ -404,6 +423,7 @@ generator Hekireki-ArkType {
     file     = "index.ts"    // File name (default: index.ts)
     type     = true          // Generate TypeScript types (default: false)
     comment  = true          // Include schema documentation (default: false)
+    relation = true          // Generate relation schemas (default: false)
 }
 
 // Effect Schema Generator
@@ -413,6 +433,7 @@ generator Hekireki-Effect {
     file     = "index.ts"    // File name (default: index.ts)
     type     = true          // Generate TypeScript types (default: false)
     comment  = true          // Include schema documentation (default: false)
+    relation = true          // Generate relation schemas (default: false)
 }
 
 // Mermaid ER Generator
@@ -425,26 +446,45 @@ generator Hekireki-ER {
 // Ecto Generator
 generator Hekireki-Ecto {
     provider = "hekireki-ecto"
-    output   = "./ecto"      // Output directory (default: ./ecto)
+    output   = "./ecto"      // Output directory (default: ./ecto/)
     app      = "MyApp"       // App name (default: MyApp)
 }
 
-// DBML Generator
+// DBML Generator (output extension determines format: .dbml or .png)
 generator Hekireki-DBML {
     provider = "hekireki-dbml"
-    output   = "./dbml"      // Output directory (default: ./dbml)
-    file     = "schema.dbml" // File name (default: schema.dbml)
+    output   = "docs/schema.dbml"    // File path ending in .dbml or .png
+    mapToDbSchema = true             // Map to DB schema names (default: true)
+}
+
+// PNG output (same provider, different extension)
+generator Hekireki-PNG {
+    provider = "hekireki-dbml"
+    output   = "docs/er-diagram.png" // .png extension → PNG output
+    mapToDbSchema = true             // Map to DB schema names (default: true)
 }
 
-// SVG/PNG Generator
-generator Hekireki-SVG {
-    provider = "hekireki-svg"
-    output   = "./docs"      // Output directory (default: ./docs)
-    file     = "er-diagram"  // File name without extension (default: er-diagram)
-    format   = "png"         // Output format: "png", "svg", or "dot" (default: png)
+// Docs Generator
+generator Hekireki-Docs {
+    provider = "hekireki-docs"
+    output   = "./docs"              // Output directory (default: ./docs)
 }
 ```
 
+## Docs Server
+
+Hekireki includes a built-in documentation server powered by [Hono](https://hono.dev/). After generating docs with `prisma generate`, you can preview them locally:
+
+```bash
+# Start the docs server (default: http://localhost:5858)
+hekireki docs serve
+
+# Specify a custom port
+hekireki docs serve -p 3000
+```
+
+> **Note:** Run `prisma generate` first to generate the `docs/` directory with `index.html`.
+
 ## License
 
 Distributed under the MIT License. See [LICENSE](https://github.com/nakita628/hekireki?tab=MIT-1-ov-file) for more information.

package/dist/cli/index.js

@@ -58,7 +58,7 @@ const parsePort = (args) => {
 		error: "❌ Error: --port requires a number"
 	};
 	const port = parseInt(portStr, 10);
-	if (isNaN(port)) return {
+	if (Number.isNaN(port)) return {
 		ok: false,
 		error: `❌ Error: Invalid port number: ${portStr}`
 	};

package/dist/generator/arktype/index.d.ts

@@ -1,6 +1,6 @@
 import { GeneratorOptions } from "@prisma/generator-helper";
 
 //#region src/generator/arktype/index.d.ts
-declare const onGenerate: (options: GeneratorOptions) => Promise<void>;
+declare function main(options: GeneratorOptions): Promise<void>;
 //#endregion
-export { onGenerate };
+export { main };

package/dist/generator/arktype/index.js

@@ -1,73 +1,16 @@
 #!/usr/bin/env node
-import { a as getBool, i as collectRelationProps, n as validationSchemas, o as getString, r as parseDocumentWithoutAnnotations, s as fmt, t as schemaFromFields } from "../../utils-BHGDO4qk.js";
-import { n as writeFile, t as mkdir } from "../../fsp-FOfmtPYd.js";
+import { n as validationSchemas, r as fmt, t as makeRelationsOnly } from "../../prisma-vPHUnYiY.js";
+import { C as parseDocumentWithoutAnnotations, O as mkdir, b as makeValidationExtractor, k as writeFile, l as getBool, m as makeArktypeSchemas, p as makeArktypeInfer, u as getString } from "../../utils-0nIzqFtt.js";
 import path from "node:path";
 import pkg from "@prisma/generator-helper";
-import { makeValidationExtractor } from "utils-lab";
 
-//#region src/generator/arktype/generator/schema.ts
-/**
-* Generate ArkType schema
-* @param modelName - The name of the model
-* @param fields - The fields of the model
-* @returns The generated ArkType schema
-*/
-function schema(modelName, fields) {
-	return `export const ${modelName}Schema = type({\n${fields}\n})`;
-}
-/**
-* Make ArkType relations schema for a model.
-* @param model - The DMMF model
-* @param relProps - The relation properties
-* @param options - Options for the relation generation
-* @returns The generated ArkType relations schema or null if no relations
-*/
+//#region src/helper/arktype.ts
 function makeArktypeRelations(model, relProps, options) {
 	if (relProps.length === 0) return null;
 	const fields = `${`...${model.name}Schema.t,`}${relProps.map((r) => `${r.key}:${r.isMany ? `${r.targetModel}Schema.array()` : `${r.targetModel}Schema`},`).join("")}`;
 	const typeLine = options?.includeType ? `\n\nexport type ${model.name}Relations = typeof ${model.name}RelationsSchema.infer` : "";
 	return `export const ${model.name}RelationsSchema = type({${fields}})${typeLine}`;
 }
-
-//#endregion
-//#region src/generator/arktype/generator/schemas.ts
-/**
-* Generate properties for ArkType schema.
-*/
-function arktypePropertiesGenerator(fields, comment) {
-	return fields.map((field) => {
-		return `${comment && field.comment.length > 0 ? `${field.comment.map((c) => `  /** ${c} */`).join("\n")}\n` : ""}  ${field.fieldName}: ${field.validation ?? "\"unknown\""},`;
-	}).join("\n");
-}
-/**
-* Creates ArkType schemas from model fields.
-*
-* @param modelFields - The fields of the model
-* @param comment - Whether to include comments in the generated code
-* @returns The generated ArkType schemas
-*/
-function schemas(modelFields, comment) {
-	return schemaFromFields(modelFields, comment, schema, arktypePropertiesGenerator);
-}
-
-//#endregion
-//#region src/generator/arktype/generator/arktype.ts
-/**
-* Generate ArkType infer type statement.
-* @param modelName - The name of the model
-* @returns The generated type inference statement
-*/
-function makeArktypeInfer(modelName) {
-	return `export type ${modelName} = typeof ${modelName}Schema.infer`;
-}
-/**
-* Creates ArkType schemas and types from models.
-*
-* @param models - The models to generate the ArkType schemas and types for
-* @param type - Whether to generate types
-* @param comment - Whether to include comments in the generated code
-* @returns The generated ArkType schemas and types
-*/
 function arktype(models, type, comment) {
 	return validationSchemas(models, type, comment, {
 		importStatement: `import { type } from 'arktype'`,
@@ -75,38 +18,24 @@ function arktype(models, type, comment) {
 		parseDocument: parseDocumentWithoutAnnotations,
 		extractValidation: makeValidationExtractor("@a."),
 		inferType: makeArktypeInfer,
-		schemas
+		schemas: makeArktypeSchemas
 	});
 }
 
 //#endregion
 //#region src/generator/arktype/index.ts
 const { generatorHandler } = pkg;
-const buildRelationsOnly = (dmmf, includeType) => {
-	const models = dmmf.datamodel.models;
-	const relIndex = collectRelationProps(models);
-	const relByModel = {};
-	for (const r of relIndex) {
-		const existing = relByModel[r.model] ?? [];
-		relByModel[r.model] = [...existing, r];
-	}
-	return models.map((model) => makeArktypeRelations(model, (relByModel[model.name] ?? []).map(({ key, targetModel, isMany }) => ({
-		key,
-		targetModel,
-		isMany
-	})), { includeType })).filter((code) => Boolean(code)).join("\n\n");
-};
-const emit = async (options, enableRelation) => {
+async function main(options) {
 	const outDir = options.generator.output?.value ?? "./arktype";
 	const file = getString(options.generator.config?.file, "index.ts") ?? "index.ts";
-	const fmtResult = await fmt([arktype(options.dmmf.datamodel.models, getBool(options.generator.config?.type), getBool(options.generator.config?.comment)), enableRelation ? buildRelationsOnly(options.dmmf, getBool(options.generator.config?.type)) : ""].filter(Boolean).join("\n\n"));
+	const enableRelation = options.generator.config?.relation === "true" || Array.isArray(options.generator.config?.relation) && options.generator.config?.relation[0] === "true";
+	const fmtResult = await fmt([arktype(options.dmmf.datamodel.models, getBool(options.generator.config?.type), getBool(options.generator.config?.comment)), enableRelation ? makeRelationsOnly(options.dmmf, getBool(options.generator.config?.type), makeArktypeRelations) : ""].filter(Boolean).join("\n\n"));
 	if (!fmtResult.ok) throw new Error(`Format error: ${fmtResult.error}`);
 	const mkdirResult = await mkdir(outDir);
 	if (!mkdirResult.ok) throw new Error(`Failed to create directory: ${mkdirResult.error}`);
 	const writeResult = await writeFile(path.join(outDir, file), fmtResult.value);
 	if (!writeResult.ok) throw new Error(`Failed to write file: ${writeResult.error}`);
-};
-const onGenerate = (options) => emit(options, options.generator.config?.relation === "true" || Array.isArray(options.generator.config?.relation) && options.generator.config?.relation[0] === "true");
+}
 generatorHandler({
 	onManifest() {
 		return {
@@ -114,8 +43,8 @@ generatorHandler({
 			prettyName: "Hekireki-ArkType"
 		};
 	},
-	onGenerate
+	onGenerate: main
 });
 
 //#endregion
-export { onGenerate };
+export { main };

package/dist/generator/dbml/index.d.ts

@@ -1,9 +1,6 @@
 import { GeneratorOptions } from "@prisma/generator-helper";
 
 //#region src/generator/dbml/index.d.ts
-/**
- * Main generator function
- */
-declare const main: (options: GeneratorOptions) => Promise<void>;
+declare function main(options: GeneratorOptions): Promise<void>;
 //#endregion
 export { main };

package/dist/generator/dbml/index.js

@@ -1,93 +1,53 @@
 #!/usr/bin/env node
-import { n as writeFile, r as writeFileBinary, t as mkdir } from "../../fsp-FOfmtPYd.js";
+import { A as writeFileBinary, D as stripAnnotations, O as mkdir, T as quote, a as generateEnum, c as generateRef, k as writeFile, o as generateIndex, r as escapeNote, s as generatePrismaColumn, t as combineKeys, u as getString } from "../../utils-0nIzqFtt.js";
+import { dirname } from "node:path";
 import pkg from "@prisma/generator-helper";
-import { escapeNote, formatConstraints, generateEnum, generateIndex, generateRef, quote } from "utils-lab";
 import { Resvg } from "@resvg/resvg-js";
 import { run } from "@softwaretechnik/dbml-renderer";
 
-//#region src/generator/dbml/generator/dbml-content.ts
-/**
-* Strip validation annotations (@z.*, @v.*, @a.*, @e.*) and relation annotations (@relation) from documentation
-*/
-function stripAnnotations(doc) {
-	if (!doc) return void 0;
-	const result = doc.split("\n").filter((line) => {
-		const trimmed = line.trim();
-		return !(trimmed.startsWith("@z.") || trimmed.startsWith("@v.") || trimmed.startsWith("@a.") || trimmed.startsWith("@e.") || trimmed.startsWith("@relation"));
-	}).join("\n").trim();
-	return result.length > 0 ? result : void 0;
+//#region src/helper/dbml.ts
+function resolveFieldType(field, models, mapToDbSchema) {
+	const baseType = mapToDbSchema ? models.find((m) => m.name === field.type)?.dbName ?? field.type : field.type;
+	return field.isList && !field.relationName ? `${baseType}[]` : baseType;
+}
+function resolveDefaultValue(field) {
+	const defaultDef = field.default;
+	if (defaultDef?.name === "autoincrement") return void 0;
+	if (defaultDef?.name === "now") return "`now()`";
+	if (field.hasDefaultValue && typeof field.default !== "object") return field.type === "String" || field.type === "Json" || field.kind === "enum" ? `'${field.default}'` : String(field.default);
 }
-/**
-* Convert Prisma field to DBMLColumn
-*/
 function toDBMLColumn(field, models, mapToDbSchema) {
-	let fieldType = field.type;
-	if (mapToDbSchema) {
-		const relatedModel = models.find((m) => m.name === field.type);
-		if (relatedModel?.dbName) fieldType = relatedModel.dbName;
-	}
-	if (field.isList && !field.relationName) fieldType = `${fieldType}[]`;
-	let defaultValue;
 	const defaultDef = field.default;
-	if (defaultDef?.name === "autoincrement") {} else if (defaultDef?.name === "now") defaultValue = "`now()`";
-	else if (field.hasDefaultValue && typeof field.default !== "object") if (field.type === "String" || field.type === "Json" || field.kind === "enum") defaultValue = `'${field.default}'`;
-	else defaultValue = String(field.default);
 	return {
 		name: field.name,
-		type: fieldType,
+		type: resolveFieldType(field, models, mapToDbSchema),
 		isPrimaryKey: field.isId,
 		isIncrement: defaultDef?.name === "autoincrement",
 		isUnique: field.isUnique,
 		isNotNull: field.isRequired && !field.isId,
-		defaultValue,
+		defaultValue: resolveDefaultValue(field),
 		note: stripAnnotations(field.documentation)
 	};
 }
-/**
-* Generate custom column line with Prisma-specific formatting
-*/
-function generatePrismaColumn(column) {
-	const constraints = [];
-	if (column.isPrimaryKey) constraints.push("pk");
-	if (column.isIncrement) constraints.push("increment");
-	if (column.defaultValue !== void 0) constraints.push(`default: ${column.defaultValue}`);
-	if (column.isUnique) constraints.push("unique");
-	if (column.isNotNull) constraints.push("not null");
-	if (column.note) constraints.push(`note: ${quote(column.note)}`);
-	return `  ${column.name} ${column.type}${formatConstraints(constraints)}`;
-}
-/**
-* Generate table indexes block
-*/
 function generateTableIndexes(model) {
-	const indexes = [];
-	const primaryFields = model.primaryKey?.fields;
-	if (primaryFields && primaryFields.length > 0) indexes.push({
-		columns: primaryFields,
+	return [...model.primaryKey?.fields && model.primaryKey.fields.length > 0 ? [{
+		columns: model.primaryKey.fields,
 		isPrimaryKey: true
-	});
-	for (const composite of model.uniqueFields) if (composite.length > 1) indexes.push({
-		columns: composite,
+	}] : [], ...model.uniqueFields.filter((c) => c.length > 1).map((c) => ({
+		columns: c,
 		isUnique: true
-	});
-	return indexes;
+	}))];
 }
-/**
-* Generate table definitions
-*/
-function generateTables(models, mapToDbSchema = false, includeRelationFields = true) {
+function generateTables(models, mapToDbSchema = false) {
 	return models.map((model) => {
 		const modelName = mapToDbSchema && model.dbName ? model.dbName : model.name;
-		const columnLines = (includeRelationFields ? model.fields : model.fields.filter((field) => !field.relationName)).map((field) => toDBMLColumn(field, models, mapToDbSchema)).map(generatePrismaColumn).join("\n");
+		const columnLines = model.fields.map((field) => toDBMLColumn(field, models, mapToDbSchema)).map(generatePrismaColumn).join("\n");
 		const indexes = generateTableIndexes(model);
 		const indexBlock = indexes.length > 0 ? `\n\n  indexes {\n${indexes.map(generateIndex).join("\n")}\n  }` : "";
 		const strippedNote = stripAnnotations(model.documentation);
 		return `Table ${modelName} {\n${columnLines}${indexBlock}${strippedNote ? `\n\n  Note: ${quote(escapeNote(strippedNote))}` : ""}\n}`;
 	});
 }
-/**
-* Generate enum definitions
-*/
 function generateEnums(enums) {
 	return enums.map((e) => {
 		return generateEnum({
@@ -96,53 +56,32 @@ function generateEnums(enums) {
 		});
 	});
 }
-/**
-* Get relation operator based on cardinality
-*/
 function getRelationOperator(models, from, to) {
 	return (models.find((m) => m.name === to)?.fields.find((f) => f.type === from))?.isList ? ">" : "-";
 }
-/**
-* Combine keys for composite foreign keys
-*/
-function combineKeys(keys) {
-	return keys.length > 1 ? `(${keys.join(", ")})` : keys[0];
-}
-/**
-* Generate foreign key references
-*/
 function generateRelations(models, mapToDbSchema = false) {
-	const refs = [];
-	for (const model of models) {
-		const relFields = model.fields.filter((field) => field.relationName && field.relationToFields?.length && field.relationFromFields?.length);
-		for (const field of relFields) {
-			const relationFrom = model.name;
-			const relationTo = field.type;
-			const operator = getRelationOperator(models, relationFrom, relationTo);
-			const relationFromName = mapToDbSchema && model.dbName ? model.dbName : model.name;
-			const relatedModel = models.find((m) => m.name === relationTo);
-			const relationToName = mapToDbSchema && relatedModel?.dbName ? relatedModel.dbName : relationTo;
-			const fromColumn = combineKeys(field.relationFromFields ?? []);
-			const toColumn = combineKeys(field.relationToFields ?? []);
-			const ref = {
-				name: `${relationFromName}_${fromColumn}_fk`,
-				fromTable: relationFromName,
-				fromColumn,
-				toTable: relationToName,
-				toColumn,
-				type: operator,
-				onDelete: field.relationOnDelete
-			};
-			refs.push(generateRef(ref));
-		}
-	}
-	return refs;
+	return models.flatMap((model) => model.fields.filter((field) => field.relationName && field.relationToFields?.length && field.relationFromFields?.length).map((field) => {
+		const relationFrom = model.name;
+		const relationTo = field.type;
+		const operator = getRelationOperator(models, relationFrom, relationTo);
+		const relationFromName = mapToDbSchema && model.dbName ? model.dbName : model.name;
+		const relatedModel = models.find((m) => m.name === relationTo);
+		const relationToName = mapToDbSchema && relatedModel?.dbName ? relatedModel.dbName : relationTo;
+		const fromColumn = combineKeys(field.relationFromFields ?? []);
+		const toColumn = combineKeys(field.relationToFields ?? []);
+		return generateRef({
+			name: `${relationFromName}_${fromColumn}_fk`,
+			fromTable: relationFromName,
+			fromColumn,
+			toTable: relationToName,
+			toColumn,
+			type: operator,
+			onDelete: field.relationOnDelete
+		});
+	}));
 }
-/**
-* Generate complete DBML content from Prisma DMMF
-*/
-function dbmlContent(datamodel, mapToDbSchema = false, includeRelationFields = true) {
-	const tables = generateTables(datamodel.models, mapToDbSchema, includeRelationFields);
+function dbmlContent(datamodel, mapToDbSchema = false) {
+	const tables = generateTables(datamodel.models, mapToDbSchema);
 	const enums = generateEnums(datamodel.enums);
 	const refs = generateRelations(datamodel.models, mapToDbSchema);
 	return [
@@ -151,25 +90,7 @@ function dbmlContent(datamodel, mapToDbSchema = false, includeRelationFields = t
 		...refs
 	].join("\n\n");
 }
-
-//#endregion
-//#region src/generator/dbml/index.ts
-const { generatorHandler } = pkg;
-/**
-* Get string value from config
-*/
-const getStringValue = (value) => value === void 0 ? void 0 : Array.isArray(value) ? value[0] : value;
-/**
-* Get boolean option from config
-*/
-const getBoolOption = (config, key, defaultValue) => {
-	const value = getStringValue(config[key]);
-	return value === void 0 ? defaultValue : value.toLowerCase() !== "false";
-};
-/**
-* Generate DBML file
-*/
-const generateDbml = async (outputDir, content, fileName) => {
+const generateDbmlFile = async (outputDir, content, fileName) => {
 	const writeResult = await writeFile(`${outputDir}/${fileName}`, content);
 	if (!writeResult.ok) return {
 		ok: false,
@@ -177,36 +98,49 @@ const generateDbml = async (outputDir, content, fileName) => {
 	};
 	return { ok: true };
 };
-/**
-* Generate PNG from DBML
-*/
 const generatePng = async (outputDir, dbml, fileName) => {
-	const pngBuffer = new Resvg(run(dbml, "svg"), { font: { loadSystemFonts: true } }).render().asPng();
-	const writeResult = await writeFileBinary(`${outputDir}/${fileName}`, pngBuffer);
+	return generatePngFile(`${outputDir}/${fileName}`, dbml);
+};
+const generatePngFile = async (outputPath, dbml) => {
+	const writeResult = await writeFileBinary(outputPath, new Resvg(run(dbml, "svg"), { font: { loadSystemFonts: true } }).render().asPng());
 	if (!writeResult.ok) return {
 		ok: false,
 		error: `Failed to write PNG: ${writeResult.error}`
 	};
 	return { ok: true };
 };
-/**
-* Main generator function
-*/
-const main = async (options) => {
+
+//#endregion
+//#region src/generator/dbml/index.ts
+const { generatorHandler } = pkg;
+async function main(options) {
 	const { config } = options.generator;
-	const mapToDbSchema = getBoolOption(config, "mapToDbSchema", true);
-	const includeRelationFields = getBoolOption(config, "includeRelationFields", true);
-	const content = dbmlContent(options.dmmf.datamodel, mapToDbSchema, includeRelationFields);
+	const mapToDbSchema = getString(config?.mapToDbSchema) !== "false";
+	const content = dbmlContent(options.dmmf.datamodel, mapToDbSchema);
 	const output = options.generator.output?.value ?? "./dbml";
-	const dbmlFile = getStringValue(config.file) ?? "schema.dbml";
-	const pngFile = getStringValue(config.pngFile) ?? "er-diagram.png";
-	const mkdirResult = await mkdir(output);
-	if (!mkdirResult.ok) throw new Error(`❌ Failed to create directory: ${mkdirResult.error}`);
-	const dbmlResult = await generateDbml(output, content, dbmlFile);
-	if (!dbmlResult.ok) throw new Error(`❌ ${dbmlResult.error}`);
-	const pngResult = await generatePng(output, content, pngFile);
-	if (!pngResult.ok) throw new Error(`❌ ${pngResult.error}`);
-};
+	if (output.endsWith(".png") || output.endsWith(".dbml")) {
+		const mkdirResult = await mkdir(dirname(output));
+		if (!mkdirResult.ok) throw new Error(`Failed to create directory: ${mkdirResult.error}`);
+		if (output.endsWith(".png")) {
+			const pngResult = await generatePngFile(output, content);
+			if (!pngResult.ok) throw new Error(pngResult.error);
+		} else {
+			const dbmlResult = await writeFile(output, content);
+			if (!dbmlResult.ok) throw new Error(`Failed to write DBML: ${dbmlResult.error}`);
+		}
+	} else {
+		const file = getString(config?.file, "schema.dbml") ?? "schema.dbml";
+		const mkdirResult = await mkdir(output);
+		if (!mkdirResult.ok) throw new Error(`Failed to create directory: ${mkdirResult.error}`);
+		if (file.endsWith(".png")) {
+			const pngResult = await generatePng(output, content, file);
+			if (!pngResult.ok) throw new Error(pngResult.error);
+		} else {
+			const dbmlResult = await generateDbmlFile(output, content, file);
+			if (!dbmlResult.ok) throw new Error(dbmlResult.error);
+		}
+	}
+}
 generatorHandler({
 	onManifest() {
 		return {