hekireki 0.4.2 → 0.5.0

package/README.md

@@ -1,12 +1,16 @@
 # Hekireki
 
-**[Hekireki](https://www.npmjs.com/package/hekireki)** is a tool that generates validation schemas for Zod and Valibot, as well as ER diagrams, from [Prisma](https://www.prisma.io/) schemas annotated with comments.
+**[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.
 
 ## Features
 
 - 💎 Automatically generates [Zod](https://zod.dev/) schemas from your Prisma schema
 - 🤖 Automatically generates [Valibot](https://valibot.dev/) schemas from your Prisma schema
-- 📊 Creates [Mermaid](https://mermaid.js.org/) ER diagrams
+- 🏹 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 [Ecto](https://hexdocs.pm/ecto/Ecto.Schema.html) schemas for Elixir projects
   ⚠️ Foreign key constraints are **not** included — manage relationships in your application logic
 
@@ -21,13 +25,8 @@ npm install -D hekireki
 Prepare `schema.prisma`:
 
 ```prisma
-generator client {
-    provider = "prisma-client-js"
-}
-
 datasource db {
     provider = "sqlite"
-    url      = env("DATABASE_URL")
 }
 
 generator Hekireki-ER {
@@ -48,42 +47,75 @@ generator Hekireki-Valibot {
     relation = true
 }
 
+generator Hekireki-ArkType {
+    provider = "hekireki-arktype"
+    type     = true
+    comment  = true
+}
+
+generator Hekireki-Effect {
+    provider = "hekireki-effect"
+    type     = true
+    comment  = true
+}
+
 generator Hekireki-Ecto {
     provider = "hekireki-ecto"
     output = "schema"
     app = "DBSchema"
 }
 
+generator Hekireki-DBML {
+    provider = "hekireki-dbml"
+}
+
+generator Hekireki-SVG {
+    provider = "hekireki-svg"
+    output   = "docs"
+    format   = "png"
+}
+
 model User {
     /// Primary key
     /// @z.uuid()
     /// @v.pipe(v.string(), v.uuid())
+    /// @a."string.uuid"
+    /// @e.Schema.UUID
     id    String @id @default(uuid())
     /// Display name
     /// @z.string().min(1).max(50)
     /// @v.pipe(v.string(), v.minLength(1), v.maxLength(50))
+    /// @a."1 <= string <= 50"
+    /// @e.Schema.String.pipe(Schema.minLength(1), Schema.maxLength(50))
     name  String
     /// One-to-many relation to Post
     posts Post[]
 }
 
-/// @relation User.id Post.userId one-to-many
 model Post {
     /// Primary key
     /// @z.uuid()
     /// @v.pipe(v.string(), v.uuid())
+    /// @a."string.uuid"
+    /// @e.Schema.UUID
     id String @id @default(uuid())
     /// Article title
     /// @z.string().min(1).max(100)
     /// @v.pipe(v.string(), v.minLength(1), v.maxLength(100))
+    /// @a."1 <= string <= 100"
+    /// @e.Schema.String.pipe(Schema.minLength(1), Schema.maxLength(100))
     title String
     /// Body content (no length limit)
     /// @z.string()
     /// @v.string()
+    /// @a."string"
+    /// @e.Schema.String
     content String
     /// Foreign key referencing User.id
     /// @z.uuid()
     /// @v.pipe(v.string(), v.uuid())
+    /// @a."string.uuid"
+    /// @e.Schema.UUID
     userId  String
     /// Prisma relation definition
     user    User   @relation(fields: [userId], references: [id])
@@ -147,6 +179,7 @@ export type PostRelations = z.infer<typeof PostRelationsSchema>
 ```
 
 ## Valibot
+
 ```ts
 import * as v from 'valibot'
 
@@ -184,29 +217,91 @@ export const PostSchema = v.object({
 
 export type Post = v.InferInput<typeof PostSchema>
 
-export const UserRelationsSchema = v.object({ ...UserSchema.entries, posts: v.array(PostSchema) })
+export const UserRelationsSchema = v.object({
+  ...UserSchema.entries,
+  posts: v.array(PostSchema),
+})
 
 export type UserRelations = v.InferInput<typeof UserRelationsSchema>
 
-export const PostRelationsSchema = v.object({ ...PostSchema.entries, user: UserSchema })
+export const PostRelationsSchema = v.object({
+  ...PostSchema.entries,
+  user: UserSchema,
+})
 
 export type PostRelations = v.InferInput<typeof PostRelationsSchema>
 ```
 
+## ArkType
+
+```ts
+import { type } from 'arktype'
+
+export const UserSchema = type({
+  /** Primary key */
+  id: 'string.uuid',
+  /** Display name */
+  name: '1 <= string <= 50',
+})
+
+export type User = typeof UserSchema.infer
+
+export const PostSchema = type({
+  /** Primary key */
+  id: 'string.uuid',
+  /** Article title */
+  title: '1 <= string <= 100',
+  /** Body content (no length limit) */
+  content: 'string',
+  /** Foreign key referencing User.id */
+  userId: 'string.uuid',
+})
+
+export type Post = typeof PostSchema.infer
+```
+
+## Effect Schema
+
+```ts
+import { Schema } from 'effect'
+
+export const UserSchema = Schema.Struct({
+  /** Primary key */
+  id: Schema.UUID,
+  /** Display name */
+  name: Schema.String.pipe(Schema.minLength(1), Schema.maxLength(50)),
+})
+
+export type User = Schema.Schema.Type<typeof UserSchema>
+
+export const PostSchema = Schema.Struct({
+  /** Primary key */
+  id: Schema.UUID,
+  /** Article title */
+  title: Schema.String.pipe(Schema.minLength(1), Schema.maxLength(100)),
+  /** Body content (no length limit) */
+  content: Schema.String,
+  /** Foreign key referencing User.id */
+  userId: Schema.UUID,
+})
+
+export type Post = Schema.Schema.Type<typeof PostSchema>
+```
+
 ## Mermaid
 
 ```mermaid
 erDiagram
     User ||--}| Post : "(id) - (userId)"
     User {
-        String id "Primary key"
-        String name "Display name"
+        string id PK "Primary key"
+        string name "Display name"
     }
     Post {
-        String id "Primary key"
-        String title "Article title"
-        String content "Body content (no length limit)"
-        String userId "Foreign key referencing User.id"
+        string id PK "Primary key"
+        string title "Article title"
+        string content "Body content (no length limit)"
+        string userId FK "Foreign key referencing User.id"
     }
 ```
 
@@ -250,6 +345,32 @@ defmodule DBSchema.Post do
 end
 ```
 
+## DBML
+
+```dbml
+Table User {
+  id String [pk, note: 'Primary key']
+  name String [not null, note: 'Display name']
+  posts Post [not null, note: 'One-to-many relation to Post']
+}
+
+Table Post {
+  id String [pk, note: 'Primary key']
+  title String [not null, note: 'Article title']
+  content String [not null, note: 'Body content (no length limit)']
+  userId String [not null, note: 'Foreign key referencing User.id']
+  user User [not null, note: 'Prisma relation definition']
+}
+
+Ref Post_userId_fk: Post.userId > User.id
+```
+
+## PNG/SVG
+
+The `hekireki-svg` generator outputs ER diagrams as PNG or SVG images using [dbml-renderer](https://github.com/softwaretechnik-berlin/dbml-renderer).
+
+Output: `docs/er-diagram.png`
+
 ## Configuration
 
 ### Zod Generator Options
@@ -273,6 +394,24 @@ end
 | `comment`    | `boolean` | `false`                             | Include schema documentation                     |
 | `relation`   | `boolean` | `false`                             | Generate relation schemas                        |
 
+### ArkType Generator Options
+
+| Option       | Type      | Default                             | Description                                      |
+|--------------|-----------|-------------------------------------|--------------------------------------------------|
+| `output`     | `string`  | `./arktype`                         | Output directory                                 |
+| `file`       | `string`  | `index.ts`                          | File Name                                        |
+| `type`       | `boolean` | `false`                             | Generate TypeScript types                        |
+| `comment`    | `boolean` | `false`                             | Include schema documentation                     |
+
+### Effect Schema Generator Options
+
+| Option       | Type      | Default                             | Description                                      |
+|--------------|-----------|-------------------------------------|--------------------------------------------------|
+| `output`     | `string`  | `./effect`                          | Output directory                                 |
+| `file`       | `string`  | `index.ts`                          | File Name                                        |
+| `type`       | `boolean` | `false`                             | Generate TypeScript types                        |
+| `comment`    | `boolean` | `false`                             | Include schema documentation                     |
+
 ### Mermaid ER Generator Options
 
 | Option       | Type      | Default                             | Description                                      |
@@ -285,13 +424,34 @@ end
 | Option       | Type      | Default                             | Description                                      |
 |--------------|-----------|-------------------------------------|--------------------------------------------------|
 | `output`     | `string`  | `./ecto`                            | Output directory                                 |
-| `app`        | `string`  | `MyApp`                             | App Name                                        |
+| `app`        | `string`  | `MyApp`                             | App Name                                         |
+
+### DBML Generator Options
+
+| Option       | Type      | Default                             | Description                                      |
+|--------------|-----------|-------------------------------------|--------------------------------------------------|
+| `output`     | `string`  | `./dbml`                            | Output directory                                 |
+| `file`       | `string`  | `schema.dbml`                       | File Name                                        |
+
+### SVG Generator Options
+
+| Option       | Type      | Default                             | Description                                      |
+|--------------|-----------|-------------------------------------|--------------------------------------------------|
+| `output`     | `string`  | `./docs`                            | Output directory                                 |
+| `file`       | `string`  | `er-diagram`                        | File Name (without extension)                    |
+| `format`     | `string`  | `png`                               | Output format (`png`, `svg`, or `dot`)           |
 
-⚠️ WARNING: Potential Breaking Changes Without Notice
+## Annotation Prefixes
 
-This project is in **early development** and being maintained by a developer with about 2 years of experience. While I'm doing my best to create a useful tool:
+Each generator uses a specific annotation prefix in Prisma schema comments:
 
+| Generator      | Prefix | Example                                                    |
+|----------------|--------|------------------------------------------------------------|
+| Zod            | `@z.`  | `/// @z.uuid()`                                            |
+| Valibot        | `@v.`  | `/// @v.pipe(v.string(), v.uuid())`                        |
+| ArkType        | `@a.`  | `/// @a."string.uuid"`                                     |
+| Effect Schema  | `@e.`  | `/// @e.Schema.UUID`                                       |
 
 ## License
 
-Distributed under the MIT License. See [LICENSE](https://github.com/nakita628/hekireki?tab=MIT-1-ov-file) for more information.
+Distributed under the MIT License. See [LICENSE](https://github.com/nakita628/hekireki?tab=MIT-1-ov-file) for more information.

package/dist/dbml-content-D3ioOw2D.js

@@ -0,0 +1,151 @@
+import { escapeNote, formatConstraints, generateEnum, generateIndex, generateRef, quote } from "utils-lab";
+
+//#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;
+}
+/**
+* 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,
+		isPrimaryKey: field.isId,
+		isIncrement: defaultDef?.name === "autoincrement",
+		isUnique: field.isUnique,
+		isNotNull: field.isRequired && !field.isId,
+		defaultValue,
+		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,
+		isPrimaryKey: true
+	});
+	for (const composite of model.uniqueFields) if (composite.length > 1) indexes.push({
+		columns: composite,
+		isUnique: true
+	});
+	return indexes;
+}
+/**
+* Generate table definitions
+*/
+function generateTables(models, mapToDbSchema = false, includeRelationFields = true) {
+	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 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({
+			name: e.name,
+			values: e.values.map((v) => v.name)
+		});
+	});
+}
+/**
+* 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;
+}
+/**
+* Generate complete DBML content from Prisma DMMF
+*/
+function dbmlContent(datamodel, mapToDbSchema = false, includeRelationFields = true) {
+	const tables = generateTables(datamodel.models, mapToDbSchema, includeRelationFields);
+	const enums = generateEnums(datamodel.enums);
+	const refs = generateRelations(datamodel.models, mapToDbSchema);
+	return [
+		...enums,
+		...tables,
+		...refs
+	].join("\n\n");
+}
+
+//#endregion
+export { dbmlContent as t };

package/dist/fsp-DYtOxLN_.js

@@ -0,0 +1,68 @@
+import fsp from "node:fs/promises";
+
+//#region src/shared/fsp/index.ts
+/**
+* Creates a directory if it does not already exist.
+*
+* @param dir - Directory path to create.
+* @returns A `Result` that is `ok` on success, otherwise an error message.
+*/
+async function mkdir(dir) {
+	try {
+		await fsp.mkdir(dir, { recursive: true });
+		return {
+			ok: true,
+			value: void 0
+		};
+	} catch (e) {
+		return {
+			ok: false,
+			error: e instanceof Error ? e.message : String(e)
+		};
+	}
+}
+/**
+* Writes UTF-8 text to a file, creating it if necessary.
+*
+* @param path - File path to write.
+* @param data - Text data to write.
+* @returns A `Result` that is `ok` on success, otherwise an error message.
+*/
+async function writeFile(path, data) {
+	try {
+		await fsp.writeFile(path, data, "utf-8");
+		return {
+			ok: true,
+			value: void 0
+		};
+	} catch (e) {
+		return {
+			ok: false,
+			error: e instanceof Error ? e.message : String(e)
+		};
+	}
+}
+/**
+* Writes binary data to a file, creating it if necessary.
+*
+* @param path - File path to write.
+* @param data - Binary data to write.
+* @returns A `Result` that is `ok` on success, otherwise an error message.
+*/
+async function writeFileBinary(path, data) {
+	try {
+		await fsp.writeFile(path, data);
+		return {
+			ok: true,
+			value: void 0
+		};
+	} catch (e) {
+		return {
+			ok: false,
+			error: e instanceof Error ? e.message : String(e)
+		};
+	}
+}
+
+//#endregion
+export { writeFile as n, writeFileBinary as r, mkdir as t };

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

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

package/dist/generator/arktype/index.js

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+import { a as getString, i as getBool, n as validationSchemas, o as fmt, r as parseDocumentWithoutAnnotations, t as schemaFromFields } from "../../utils-CXBzdZih.js";
+import { n as writeFile, t as mkdir } from "../../fsp-DYtOxLN_.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})`;
+}
+
+//#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'`,
+		annotationPrefix: "@a.",
+		parseDocument: parseDocumentWithoutAnnotations,
+		extractValidation: makeValidationExtractor("@a."),
+		inferType: makeArktypeInfer,
+		schemas
+	});
+}
+
+//#endregion
+//#region src/generator/arktype/index.ts
+const { generatorHandler } = pkg;
+const emit = async (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)));
+	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);
+generatorHandler({
+	onManifest() {
+		return {
+			defaultOutput: "./arktype/",
+			prettyName: "Hekireki-ArkType"
+		};
+	},
+	onGenerate
+});
+
+//#endregion
+export { onGenerate };

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

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

package/dist/generator/dbml/index.js

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+import { n as writeFile, t as mkdir } from "../../fsp-DYtOxLN_.js";
+import { t as dbmlContent } from "../../dbml-content-D3ioOw2D.js";
+import pkg from "@prisma/generator-helper";
+
+//#region src/generator/dbml/index.ts
+const { generatorHandler } = pkg;
+/**
+* Get string value from config
+*/
+function getStringValue(value) {
+	if (value === void 0) return void 0;
+	return Array.isArray(value) ? value[0] : value;
+}
+/**
+* Get boolean option from config
+*/
+function getBoolOption(config, key, defaultValue) {
+	const value = getStringValue(config[key]);
+	if (value === void 0) return defaultValue;
+	return value.toLowerCase() !== "false";
+}
+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 output = options.generator.output?.value ?? "./dbml";
+	const file = getStringValue(config.file) ?? "schema.dbml";
+	const isOutputFile = output.includes(".");
+	const outputDir = isOutputFile ? "." : output;
+	const outputFile = isOutputFile ? output : `${output}/${file}`;
+	const mkdirResult = await mkdir(outputDir);
+	if (!mkdirResult.ok) throw new Error(`Failed to create directory: ${mkdirResult.error}`);
+	const writeResult = await writeFile(outputFile, content);
+	if (!writeResult.ok) throw new Error(`Failed to write file: ${writeResult.error}`);
+}
+generatorHandler({
+	onManifest() {
+		return {
+			defaultOutput: "./dbml",
+			prettyName: "Hekireki-DBML"
+		};
+	},
+	onGenerate: main
+});
+
+//#endregion
+export { main };