hekireki 0.4.2 → 0.5.1

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,48 +345,106 @@ defmodule DBSchema.Post do
 end
 ```
 
-## Configuration
+## 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
 
-### Zod Generator Options
+The `hekireki-svg` generator outputs ER diagrams as PNG or SVG images using [dbml-renderer](https://github.com/softwaretechnik-berlin/dbml-renderer).
 
-| Option       | Type      | Default                             | Description                                      |
-|--------------|-----------|-------------------------------------|--------------------------------------------------|
-| `output`     | `string`  | `./zod`                             | Output directory                                 |
-| `file`       | `string`  | `index.ts`                          | File Name                                        |
-| `type`       | `boolean` | `false`                             | Generate TypeScript types                        |
-| `comment`    | `boolean` | `false`                             | Include schema documentation                     |
-| `zod`        | `string`  | `'v4'`                              | Zod import version (`'mini'`, `'@hono/zod-openapi'`, or default `'v4'`) |
-| `relation`   | `boolean` | `false`                             | Generate relation schemas                        |
+Output: `docs/er-diagram.png`
 
-### Valibot Generator Options
+## Configuration
+
+Configure each generator directly in your `schema.prisma` file:
 
-| Option       | Type      | Default                             | Description                                      |
-|--------------|-----------|-------------------------------------|--------------------------------------------------|
-| `output`     | `string`  | `./valibot`                         | Output directory                                 |
-| `file`       | `string`  | `index.ts`                          | File Name                                        |
-| `type`       | `boolean` | `false`                             | Generate TypeScript types                        |
-| `comment`    | `boolean` | `false`                             | Include schema documentation                     |
-| `relation`   | `boolean` | `false`                             | Generate relation schemas                        |
+```prisma
+// Zod Generator
+generator Hekireki-Zod {
+    provider = "hekireki-zod"
+    output   = "./zod"       // Output directory (default: ./zod)
+    file     = "index.ts"    // File name (default: index.ts)
+    type     = true          // Generate TypeScript types (default: false)
+    comment  = true          // Include schema documentation (default: false)
+    zod      = "v4"          // Zod import: "v4", "mini", or "@hono/zod-openapi" (default: v4)
+    relation = true          // Generate relation schemas (default: false)
+}
 
-### Mermaid ER Generator Options
+// Valibot Generator
+generator Hekireki-Valibot {
+    provider = "hekireki-valibot"
+    output   = "./valibot"   // Output directory (default: ./valibot)
+    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)
+}
 
-| Option       | Type      | Default                             | Description                                      |
-|--------------|-----------|-------------------------------------|--------------------------------------------------|
-| `output`     | `string`  | `./mermaid-er`                      | Output directory                                 |
-| `file`       | `string`  | `ER.md`                             | File Name                                        |
+// ArkType Generator
+generator Hekireki-ArkType {
+    provider = "hekireki-arktype"
+    output   = "./arktype"   // Output directory (default: ./arktype)
+    file     = "index.ts"    // File name (default: index.ts)
+    type     = true          // Generate TypeScript types (default: false)
+    comment  = true          // Include schema documentation (default: false)
+}
 
-### Ecto Generator Options
+// Effect Schema Generator
+generator Hekireki-Effect {
+    provider = "hekireki-effect"
+    output   = "./effect"    // Output directory (default: ./effect)
+    file     = "index.ts"    // File name (default: index.ts)
+    type     = true          // Generate TypeScript types (default: false)
+    comment  = true          // Include schema documentation (default: false)
+}
 
-| Option       | Type      | Default                             | Description                                      |
-|--------------|-----------|-------------------------------------|--------------------------------------------------|
-| `output`     | `string`  | `./ecto`                            | Output directory                                 |
-| `app`        | `string`  | `MyApp`                             | App Name                                        |
+// Mermaid ER Generator
+generator Hekireki-ER {
+    provider = "hekireki-mermaid-er"
+    output   = "./mermaid-er" // Output directory (default: ./mermaid-er)
+    file     = "ER.md"        // File name (default: ER.md)
+}
 
-⚠️ WARNING: Potential Breaking Changes Without Notice
+// Ecto Generator
+generator Hekireki-Ecto {
+    provider = "hekireki-ecto"
+    output   = "./ecto"      // Output directory (default: ./ecto)
+    app      = "MyApp"       // App name (default: MyApp)
+}
 
-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:
+// DBML Generator
+generator Hekireki-DBML {
+    provider = "hekireki-dbml"
+    output   = "./dbml"      // Output directory (default: ./dbml)
+    file     = "schema.dbml" // File name (default: schema.dbml)
+}
 
+// 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)
+}
+```
 
 ## 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/cli/index.d.ts

@@ -0,0 +1,14 @@
+//#region src/cli/index.d.ts
+type Result<T> = {
+  readonly ok: true;
+  readonly value: T;
+} | {
+  readonly ok: false;
+  readonly error: string;
+};
+/**
+ * Main CLI entry point for hekireki.
+ */
+declare const hekireki: () => Result<string>;
+//#endregion
+export { hekireki };

package/dist/cli/index.js

@@ -0,0 +1,164 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import { serve } from "@hono/node-server";
+import { serveStatic } from "@hono/node-server/serve-static";
+import { Hono } from "hono";
+
+//#region src/cli/index.ts
+/**
+* CLI module for hekireki.
+*
+* Provides the main entry point for the hekireki CLI tool.
+*
+* @module cli
+*/
+const HELP_TEXT = `⚡️ hekireki - Prisma schema tools
+
+Usage:
+  hekireki <command> [options]
+
+Commands:
+  docs serve    Start a local server to view the documentation
+
+Options:
+  -p, --port <port>    Specify the port (default: 5858)
+  -h, --help           Show help
+
+Examples:
+  hekireki docs serve
+  hekireki docs serve -p 3000`;
+const DOCS_HELP_TEXT = `⚡️ hekireki docs - Documentation tools
+
+Usage:
+  hekireki docs serve [options]
+
+Commands:
+  serve    Start a local server to view the documentation
+
+Options:
+  -p, --port <port>    Specify the port (default: 5858)
+  -h, --help           Show help
+
+Examples:
+  hekireki docs serve
+  hekireki docs serve -p 3000`;
+/**
+* Parse port from CLI arguments.
+*/
+const parsePort = (args) => {
+	const portIndex = args.findIndex((arg) => arg === "-p" || arg === "--port");
+	if (portIndex === -1) return {
+		ok: true,
+		value: 5858
+	};
+	const portStr = args[portIndex + 1];
+	if (!portStr || portStr.startsWith("-")) return {
+		ok: false,
+		error: "❌ Error: --port requires a number"
+	};
+	const port = parseInt(portStr, 10);
+	if (isNaN(port)) return {
+		ok: false,
+		error: `❌ Error: Invalid port number: ${portStr}`
+	};
+	return {
+		ok: true,
+		value: port
+	};
+};
+/**
+* Parse CLI arguments for docs serve command.
+*/
+const parseDocsServeArgs = (args) => {
+	const portResult = parsePort(args);
+	if (!portResult.ok) return portResult;
+	return {
+		ok: true,
+		value: { port: portResult.value }
+	};
+};
+/**
+* Start the documentation server.
+*/
+const startDocsServer = (options) => {
+	const absolutePath = path.resolve("./docs");
+	if (!fs.existsSync(absolutePath)) return {
+		ok: false,
+		error: `❌ Error: Directory not found: ${absolutePath}\n   Run "prisma generate" first to generate the documentation.`
+	};
+	const indexPath = path.join(absolutePath, "index.html");
+	if (!fs.existsSync(indexPath)) return {
+		ok: false,
+		error: `❌ Error: index.html not found in ${absolutePath}\n   Run "prisma generate" first to generate the documentation.`
+	};
+	const app = new Hono();
+	app.get("/", (c) => {
+		const html = fs.readFileSync(indexPath, "utf-8");
+		return c.html(html);
+	});
+	app.use("/*", serveStatic({ root: absolutePath }));
+	const server = serve({
+		fetch: app.fetch,
+		port: options.port
+	});
+	process.on("SIGTERM", () => {
+		server.close();
+		process.exit(0);
+	});
+	process.on("SIGINT", () => {
+		server.close();
+		process.exit(0);
+	});
+	return {
+		ok: true,
+		value: `⚡️ Hekireki Docs Server started at http://localhost:${options.port}\n📂 Serving documentation from: ${absolutePath}`
+	};
+};
+/**
+* Handle docs subcommand.
+*/
+const handleDocs = (args) => {
+	const subcommand = args[0];
+	if (!subcommand || subcommand === "-h" || subcommand === "--help") return {
+		ok: true,
+		value: DOCS_HELP_TEXT
+	};
+	if (subcommand !== "serve") return {
+		ok: false,
+		error: `❌ Unknown command: docs ${subcommand}\n\n${DOCS_HELP_TEXT}`
+	};
+	const parseResult = parseDocsServeArgs(args.slice(1));
+	if (!parseResult.ok) return parseResult;
+	return startDocsServer(parseResult.value);
+};
+/**
+* Command handlers map.
+*/
+const commands = { docs: handleDocs };
+/**
+* Main CLI entry point for hekireki.
+*/
+const hekireki = () => {
+	const args = process.argv.slice(2);
+	const command = args[0];
+	if (!command || command === "-h" || command === "--help") return {
+		ok: true,
+		value: HELP_TEXT
+	};
+	const handler = commands[command];
+	if (!handler) return {
+		ok: false,
+		error: `❌ Unknown command: ${command}\n\n${HELP_TEXT}`
+	};
+	return handler(args.slice(1));
+};
+const result = hekireki();
+if (result.ok) console.log(result.value);
+else {
+	console.error(result.error);
+	process.exit(1);
+}
+
+//#endregion
+export { hekireki };

package/dist/fsp-FOfmtPYd.js

@@ -0,0 +1,68 @@
+import fs 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 fs.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 fs.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 fs.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 };