hekireki 0.6.3 → 0.7.1

package/README.md

@@ -2,7 +2,7 @@
 
 # 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 [Drizzle ORM](https://orm.drizzle.team/) schemas and 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, Effect Schema, TypeBox, and AJV (JSON Schema), as well as [Drizzle ORM](https://orm.drizzle.team/) schemas and ER diagrams, from [Prisma](https://www.prisma.io/) schemas annotated with comments.
 
 ## Features
 
@@ -10,11 +10,12 @@
 - 🤖 Automatically generates [Valibot](https://valibot.dev/) schemas from your Prisma schema
 - 🏹 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
+- 📦 Automatically generates [TypeBox](https://github.com/sinclairzx81/typebox) schemas from your Prisma schema
+- 📋 Automatically generates [AJV](https://ajv.js.org/)-compatible JSON Schema objects from your Prisma schema
 - 🗄️ Automatically generates [Drizzle ORM](https://orm.drizzle.team/) table schemas and relations 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 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
+- 🧪 Generates [Ecto](https://hexdocs.pm/ecto/Ecto.Schema.html) schemas for Elixir projects — with associations (`belongs_to`, `has_many`, `has_one`), composite primary keys, `@type t` typespecs, array fields, `@@map`/`@map` support, and `@moduledoc`
 
 ## Installation
 
@@ -63,6 +64,20 @@ generator Hekireki-Effect {
     relation = true
 }
 
+generator Hekireki-TypeBox {
+    provider = "hekireki-typebox"
+    type     = true
+    comment  = true
+    relation = true
+}
+
+generator Hekireki-AJV {
+    provider = "hekireki-ajv"
+    type     = true
+    comment  = true
+    relation = true
+}
+
 generator Hekireki-Drizzle {
     provider = "hekireki-drizzle"
 }
@@ -89,12 +104,16 @@ model User {
     /// @v.pipe(v.string(), v.uuid())
     /// @a."string.uuid"
     /// @e.Schema.UUID
+    /// @t.Type.String({ format: 'uuid' })
+    /// @j.{ type: 'string' as const, format: 'uuid' as const }
     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))
+    /// @t.Type.String({ minLength: 1, maxLength: 50 })
+    /// @j.{ type: 'string' as const, minLength: 1, maxLength: 50 }
     name  String
     /// One-to-many relation to Post
     posts Post[]
@@ -106,24 +125,32 @@ model Post {
     /// @v.pipe(v.string(), v.uuid())
     /// @a."string.uuid"
     /// @e.Schema.UUID
+    /// @t.Type.String({ format: 'uuid' })
+    /// @j.{ type: 'string' as const, format: 'uuid' as const }
     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))
+    /// @t.Type.String({ minLength: 1, maxLength: 100 })
+    /// @j.{ type: 'string' as const, minLength: 1, maxLength: 100 }
     title String
     /// Body content (no length limit)
     /// @z.string()
     /// @v.string()
     /// @a."string"
     /// @e.Schema.String
+    /// @t.Type.String()
+    /// @j.{ type: 'string' as const }
     content String
     /// Foreign key referencing User.id
     /// @z.uuid()
     /// @v.pipe(v.string(), v.uuid())
     /// @a."string.uuid"
     /// @e.Schema.UUID
+    /// @t.Type.String({ format: 'uuid' })
+    /// @j.{ type: 'string' as const, format: 'uuid' as const }
     userId  String
     /// Prisma relation definition
     user    User   @relation(fields: [userId], references: [id])
@@ -296,6 +323,108 @@ export const PostSchema = Schema.Struct({
 export type Post = Schema.Schema.Type<typeof PostSchema>
 ```
 
+### TypeBox
+
+```ts
+import { type Static, Type } from '@sinclair/typebox'
+
+export const UserSchema = Type.Object({
+  /** Primary key */
+  id: Type.String({ format: 'uuid' }),
+  /** Display name */
+  name: Type.String({ minLength: 1, maxLength: 50 }),
+})
+
+export type User = Static<typeof UserSchema>
+
+export const PostSchema = Type.Object({
+  /** Primary key */
+  id: Type.String({ format: 'uuid' }),
+  /** Article title */
+  title: Type.String({ minLength: 1, maxLength: 100 }),
+  /** Body content (no length limit) */
+  content: Type.String(),
+  /** Foreign key referencing User.id */
+  userId: Type.String({ format: 'uuid' }),
+})
+
+export type Post = Static<typeof PostSchema>
+
+export const UserRelationsSchema = Type.Object({
+  ...UserSchema.properties,
+  posts: Type.Array(PostSchema),
+})
+
+export type UserRelations = Static<typeof UserRelationsSchema>
+
+export const PostRelationsSchema = Type.Object({
+  ...PostSchema.properties,
+  user: UserSchema,
+})
+
+export type PostRelations = Static<typeof PostRelationsSchema>
+```
+
+### AJV (JSON Schema)
+
+```ts
+import type { FromSchema } from 'json-schema-to-ts'
+
+export const UserSchema = {
+  type: 'object' as const,
+  properties: {
+    /** Primary key */
+    id: { type: 'string' as const, format: 'uuid' as const },
+    /** Display name */
+    name: { type: 'string' as const, minLength: 1, maxLength: 50 },
+  },
+  required: ['id', 'name'] as const,
+  additionalProperties: false,
+} as const
+
+export type User = FromSchema<typeof UserSchema>
+
+export const PostSchema = {
+  type: 'object' as const,
+  properties: {
+    /** Primary key */
+    id: { type: 'string' as const, format: 'uuid' as const },
+    /** Article title */
+    title: { type: 'string' as const, minLength: 1, maxLength: 100 },
+    /** Body content (no length limit) */
+    content: { type: 'string' as const },
+    /** Foreign key referencing User.id */
+    userId: { type: 'string' as const, format: 'uuid' as const },
+  },
+  required: ['id', 'title', 'content', 'userId'] as const,
+  additionalProperties: false,
+} as const
+
+export type Post = FromSchema<typeof PostSchema>
+
+export const UserRelationsSchema = {
+  type: 'object' as const,
+  properties: {
+    ...UserSchema.properties,
+    posts: { type: 'array' as const, items: PostSchema },
+  },
+  additionalProperties: false,
+} as const
+
+export type UserRelations = FromSchema<typeof UserRelationsSchema>
+
+export const PostRelationsSchema = {
+  type: 'object' as const,
+  properties: {
+    ...PostSchema.properties,
+    user: UserSchema,
+  },
+  additionalProperties: false,
+} as const
+
+export type PostRelations = FromSchema<typeof PostRelationsSchema>
+```
+
 ### Drizzle
 
 ```ts
@@ -344,19 +473,25 @@ erDiagram
 
 ### Ecto
 
+Each model is output as a separate `.ex` file (1 model = 1 file), following Elixir conventions.
+
 ```elixir
 defmodule DBSchema.User do
   use Ecto.Schema
+  @moduledoc false
 
   @primary_key {:id, :binary_id, autogenerate: true}
+  @foreign_key_type :binary_id
 
   @type t :: %__MODULE__{
           id: Ecto.UUID.t(),
-          name: String.t()
+          name: String.t(),
+          posts: [DBSchema.Post.t()]
         }
 
   schema "user" do
     field(:name, :string)
+    has_many(:posts, DBSchema.Post, foreign_key: :user_id)
   end
 end
 ```
@@ -364,20 +499,23 @@ end
 ```elixir
 defmodule DBSchema.Post do
   use Ecto.Schema
+  @moduledoc false
 
   @primary_key {:id, :binary_id, autogenerate: true}
+  @foreign_key_type :binary_id
 
   @type t :: %__MODULE__{
           id: Ecto.UUID.t(),
           title: String.t(),
           content: String.t(),
-          userId: String.t()
+          user: DBSchema.User.t() | nil
         }
 
   schema "post" do
     field(:title, :string)
     field(:content, :string)
-    field(:userId, :string)
+    field(:user_id, :binary_id, source: :userId)
+    belongs_to(:user, DBSchema.User, foreign_key: :user_id, define_field: false)
   end
 end
 ```
@@ -466,6 +604,24 @@ generator Hekireki-Effect {
     relation = true          // Generate relation schemas (default: false)
 }
 
+// TypeBox Generator
+generator Hekireki-TypeBox {
+    provider = "hekireki-typebox"
+    output   = "./typebox"   // Output path (default: ./typebox/index.ts)
+    type     = true          // Generate TypeScript types (default: false)
+    comment  = true          // Include schema documentation (default: false)
+    relation = true          // Generate relation schemas (default: false)
+}
+
+// AJV (JSON Schema) Generator
+generator Hekireki-AJV {
+    provider = "hekireki-ajv"
+    output   = "./ajv"       // Output path (default: ./ajv/index.ts)
+    type     = true          // Generate TypeScript types (default: false)
+    comment  = true          // Include schema documentation (default: false)
+    relation = true          // Generate relation schemas (default: false)
+}
+
 // Drizzle ORM Schema Generator
 generator Hekireki-Drizzle {
     provider = "hekireki-drizzle"

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

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

package/dist/generator/ajv/index.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+import { t as fmt } from "../../format-CzXgkLDe.js";
+import { c as parseDocumentWithoutAnnotations, d as mkdir, f as writeFile, s as makeValidationExtractor, t as getBool } from "../../utils-COHZyQue.js";
+import { n as validationSchemas, t as makeRelationsOnly } from "../../prisma-ChsFqlYX.js";
+import path from "node:path";
+import pkg from "@prisma/generator-helper";
+
+//#region src/helper/ajv.ts
+function makeAjvInfer(modelName) {
+	return `export type ${modelName} = FromSchema<typeof ${modelName}Schema>`;
+}
+function makeAjvEnumExpression(values) {
+	return `{ enum: [${values.map((v) => `'${v}'`).join(", ")}] as const }`;
+}
+const PRISMA_TO_AJV = {
+	String: "{ type: 'string' as const }",
+	Int: "{ type: 'integer' as const }",
+	Float: "{ type: 'number' as const }",
+	Boolean: "{ type: 'boolean' as const }",
+	DateTime: "{ type: 'string' as const, format: 'date-time' as const }",
+	BigInt: "{ type: 'integer' as const }",
+	Decimal: "{ type: 'number' as const }",
+	Json: "{}",
+	Bytes: "{ type: 'string' as const }"
+};
+function makeAjvSchemas(modelFields, comment) {
+	const modelName = modelFields[0].modelName;
+	const properties = modelFields.map((field) => {
+		return `${comment && field.comment.length > 0 ? `${field.comment.map((c) => `    /** ${c} */`).join("\n")}\n` : ""}    ${field.fieldName}: ${field.validation ?? "{ type: 'unknown' as const }"},`;
+	}).join("\n");
+	const requiredFields = modelFields.filter((f) => f.isRequired).map((f) => f.fieldName);
+	return `export const ${modelName}Schema = {\n  type: 'object' as const,\n  properties: {\n${properties}\n  },${requiredFields.length > 0 ? `\n  required: [${requiredFields.map((f) => `'${f}'`).join(", ")}] as const,` : ""}\n  additionalProperties: false,\n} as const`;
+}
+function makeAjvRelations(model, relProps, options) {
+	if (relProps.length === 0) return null;
+	const base = `    ...${model.name}Schema.properties,`;
+	const rels = relProps.map((r) => `    ${r.key}: ${r.isMany ? `{ type: 'array' as const, items: ${r.targetModel}Schema }` : `${r.targetModel}Schema`},`).join("\n");
+	const typeLine = options?.includeType ? `\n\nexport type ${model.name}Relations = FromSchema<typeof ${model.name}RelationsSchema>` : "";
+	return `export const ${model.name}RelationsSchema = {\n  type: 'object' as const,\n  properties: {\n${base}\n${rels}\n  },\n  additionalProperties: false,\n} as const${typeLine}`;
+}
+function ajv(models, type, comment, enums) {
+	return validationSchemas(models, type, comment, {
+		importStatement: type ? `import type { FromSchema } from 'json-schema-to-ts'` : "",
+		annotationPrefix: "@j.",
+		parseDocument: parseDocumentWithoutAnnotations,
+		extractValidation: makeValidationExtractor("@j."),
+		inferType: makeAjvInfer,
+		schemas: makeAjvSchemas,
+		typeMapping: PRISMA_TO_AJV,
+		enums,
+		formatEnum: makeAjvEnumExpression
+	});
+}
+
+//#endregion
+//#region src/generator/ajv/index.ts
+const { generatorHandler } = pkg;
+async function main(options) {
+	if (!(options.generator.isCustomOutput && options.generator.output?.value)) throw new Error("output is required for Hekireki-AJV. Please specify output in your generator config.");
+	const output = options.generator.output.value;
+	const resolved = path.extname(output) ? {
+		dir: path.dirname(output),
+		file: output
+	} : {
+		dir: output,
+		file: path.join(output, "index.ts")
+	};
+	const enableRelation = getBool(options.generator.config?.relation);
+	const fmtResult = await fmt([ajv(options.dmmf.datamodel.models, getBool(options.generator.config?.type), getBool(options.generator.config?.comment), options.dmmf.datamodel.enums), enableRelation ? makeRelationsOnly(options.dmmf, getBool(options.generator.config?.type), makeAjvRelations) : ""].filter(Boolean).join("\n\n"));
+	if (!fmtResult.ok) throw new Error(`Format error: ${fmtResult.error}`);
+	const mkdirResult = await mkdir(resolved.dir);
+	if (!mkdirResult.ok) throw new Error(`Failed to create directory: ${mkdirResult.error}`);
+	const writeResult = await writeFile(resolved.file, fmtResult.value);
+	if (!writeResult.ok) throw new Error(`Failed to write file: ${writeResult.error}`);
+}
+generatorHandler({
+	onManifest() {
+		return {
+			defaultOutput: ".",
+			prettyName: "Hekireki-AJV"
+		};
+	},
+	onGenerate: main
+});
+
+//#endregion
+export { main };

package/dist/generator/arktype/index.js

@@ -1,11 +1,25 @@
 #!/usr/bin/env node
 import { t as fmt } from "../../format-CzXgkLDe.js";
-import { N as mkdir, O as parseDocumentWithoutAnnotations, P as writeFile, a as getBool, d as makeArktypeProperties, f as makeArktypeSchema, j as schemaFromFields, l as makeArktypeEnumExpression, u as makeArktypeInfer, w as makeValidationExtractor } from "../../utils-bU9015ai.js";
-import { n as validationSchemas, t as makeRelationsOnly } from "../../prisma-DKvlcO1B.js";
+import { c as parseDocumentWithoutAnnotations, d as mkdir, f as writeFile, l as schemaFromFields, s as makeValidationExtractor, t as getBool } from "../../utils-COHZyQue.js";
+import { n as validationSchemas, t as makeRelationsOnly } from "../../prisma-ChsFqlYX.js";
 import path from "node:path";
 import pkg from "@prisma/generator-helper";
 
 //#region src/helper/arktype.ts
+function makeArktypeInfer(modelName) {
+	return `export type ${modelName} = typeof ${modelName}Schema.infer`;
+}
+function makeArktypeSchema(modelName, fields) {
+	return `export const ${modelName}Schema = type({\n${fields}\n})`;
+}
+function makeArktypeProperties(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");
+}
+function makeArktypeEnumExpression(values) {
+	return `"${values.map((v) => `'${v}'`).join(" | ")}"`;
+}
 const PRISMA_TO_ARKTYPE = {
 	String: "\"string\"",
 	Int: "\"number\"",
@@ -53,7 +67,7 @@ async function main(options) {
 		dir: output,
 		file: path.join(output, "index.ts")
 	};
-	const enableRelation = options.generator.config?.relation === "true" || Array.isArray(options.generator.config?.relation) && options.generator.config?.relation[0] === "true";
+	const enableRelation = getBool(options.generator.config?.relation);
 	const fmtResult = await fmt([arktype(options.dmmf.datamodel.models, getBool(options.generator.config?.type), getBool(options.generator.config?.comment), options.dmmf.datamodel.enums), 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(resolved.dir);

package/dist/generator/dbml/index.js

@@ -1,11 +1,30 @@
 #!/usr/bin/env node
-import { F as writeFileBinary, M as stripAnnotations, N as mkdir, P as writeFile, _ as makeEnum, i as formatConstraints, o as getString, r as escapeNote, t as combineKeys, y as makeRefName } from "../../utils-bU9015ai.js";
+import { d as mkdir, f as writeFile, n as getString, p as writeFileBinary, u as stripAnnotations } from "../../utils-COHZyQue.js";
 import path from "node:path";
 import pkg from "@prisma/generator-helper";
 import { Resvg } from "@resvg/resvg-js";
 import { run } from "@softwaretechnik/dbml-renderer";
 
 //#region src/helper/dbml.ts
+function escapeNote(str) {
+	return str.replace(/'/g, "\\'");
+}
+function formatConstraints(constraints) {
+	return constraints.length > 0 ? ` [${constraints.join(", ")}]` : "";
+}
+function makeEnum(enumDef) {
+	return [
+		`Enum ${enumDef.name} {`,
+		...enumDef.values.map((v) => `  ${v}`),
+		"}"
+	].join("\n");
+}
+function makeRefName(ref) {
+	return ref.name ?? `${ref.fromTable}_${ref.fromColumn}_${ref.toTable}_${ref.toColumn}_fk`;
+}
+function combineKeys(keys) {
+	return keys.length > 1 ? `(${keys.join(", ")})` : keys[0];
+}
 function quote(value) {
 	return `'${escapeNote(value)}'`;
 }
@@ -34,43 +53,37 @@ function makePrismaColumn(column) {
 	].filter((c) => Boolean(c));
 	return `  ${column.name} ${column.type}${formatConstraints(constraints)}`;
 }
-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);
-}
 function toDBMLColumn(field, models, mapToDbSchema) {
 	const defaultDef = field.default;
+	const baseType = mapToDbSchema ? models.find((m) => m.name === field.type)?.dbName ?? field.type : field.type;
+	const type = field.isList && !field.relationName ? `${baseType}[]` : baseType;
+	const defaultValue = (() => {
+		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);
+	})();
 	return {
 		name: field.name,
-		type: resolveFieldType(field, models, mapToDbSchema),
+		type,
 		isPrimaryKey: field.isId,
 		isIncrement: defaultDef?.name === "autoincrement",
 		isUnique: field.isUnique,
 		isNotNull: field.isRequired && !field.isId,
-		defaultValue: resolveDefaultValue(field),
+		defaultValue,
 		note: stripAnnotations(field.documentation)
 	};
 }
-function makeTableIndexes(model) {
-	return [...model.primaryKey?.fields && model.primaryKey.fields.length > 0 ? [{
-		columns: model.primaryKey.fields,
-		isPrimaryKey: true
-	}] : [], ...model.uniqueFields.filter((c) => c.length > 1).map((c) => ({
-		columns: c,
-		isUnique: true
-	}))];
-}
 function makeTables(models, mapToDbSchema = false) {
 	return models.map((model) => {
 		const modelName = mapToDbSchema && model.dbName ? model.dbName : model.name;
 		const columnLines = model.fields.map((field) => toDBMLColumn(field, models, mapToDbSchema)).map(makePrismaColumn).join("\n");
-		const indexes = makeTableIndexes(model);
+		const indexes = [...model.primaryKey?.fields && model.primaryKey.fields.length > 0 ? [{
+			columns: model.primaryKey.fields,
+			isPrimaryKey: true
+		}] : [], ...model.uniqueFields.filter((c) => c.length > 1).map((c) => ({
+			columns: c,
+			isUnique: true
+		}))];
 		const indexBlock = indexes.length > 0 ? `\n\n  indexes {\n${indexes.map(makeIndex).join("\n")}\n  }` : "";
 		const strippedNote = stripAnnotations(model.documentation);
 		return `Table ${modelName} {\n${columnLines}${indexBlock}${strippedNote ? `\n\n  Note: ${quote(escapeNote(strippedNote))}` : ""}\n}`;
@@ -84,14 +97,11 @@ function makeEnums(enums) {
 		});
 	});
 }
-function getRelationOperator(models, from, to) {
-	return (models.find((m) => m.name === to)?.fields.find((f) => f.type === from))?.isList ? ">" : "-";
-}
 function makeRelations(models, mapToDbSchema = false) {
 	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 operator = (models.find((m) => m.name === relationTo)?.fields.find((f) => f.type === relationFrom))?.isList ? ">" : "-";
 		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;
@@ -118,25 +128,25 @@ function dbmlContent(datamodel, mapToDbSchema = false) {
 		...refs
 	].join("\n\n");
 }
-const makeDbmlFile = async (outputDir, content, fileName) => {
+async function makeDbmlFile(outputDir, content, fileName) {
 	const writeResult = await writeFile(`${outputDir}/${fileName}`, content);
 	if (!writeResult.ok) return {
 		ok: false,
 		error: `Failed to write DBML: ${writeResult.error}`
 	};
 	return { ok: true };
-};
-const makePng = async (outputDir, dbml, fileName) => {
+}
+async function makePng(outputDir, dbml, fileName) {
 	return makePngFile(`${outputDir}/${fileName}`, dbml);
-};
-const makePngFile = async (outputPath, dbml) => {
+}
+async function makePngFile(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 };
-};
+}
 
 //#endregion
 //#region src/generator/dbml/index.ts

package/dist/generator/drizzle/index.js

@@ -1,19 +1,10 @@
 #!/usr/bin/env node
 import { t as fmt } from "../../format-CzXgkLDe.js";
-import { N as mkdir, P as writeFile, b as makeSnakeCase } from "../../utils-bU9015ai.js";
+import { d as mkdir, f as writeFile, o as makeSnakeCase } from "../../utils-COHZyQue.js";
 import path from "node:path";
 import pkg from "@prisma/generator-helper";
 
 //#region src/helper/drizzle.ts
-function resolveProvider(provider) {
-	switch (provider) {
-		case "postgresql":
-		case "cockroachdb": return "postgresql";
-		case "mysql": return "mysql";
-		case "sqlite": return "sqlite";
-		default: throw new Error(`Unsupported provider: ${provider}`);
-	}
-}
 const PG_SCALAR_MAP = {
 	String: "text()",
 	Int: "integer()",
@@ -140,13 +131,6 @@ function toCamelCase(name) {
 function isFieldDefault(v) {
 	return typeof v === "object" && v !== null && "name" in v;
 }
-function insertColName(expr, colName) {
-	const parenIdx = expr.indexOf("(");
-	if (parenIdx === -1) return expr;
-	const fnName = expr.slice(0, parenIdx);
-	const rest = expr.slice(parenIdx + 1);
-	return rest === ")" ? `${fnName}('${colName}')` : `${fnName}('${colName}', ${rest}`;
-}
 function resolveScalarType(field, provider) {
 	if (field.nativeType && provider !== "sqlite") {
 		const [nativeName, nativeArgs] = field.nativeType;
@@ -179,7 +163,11 @@ function makeColumnExpr(field, provider, imports, enums) {
 	const baseExpr = resolveScalarType(field, provider);
 	const fnName = baseExpr.match(/^(\w+)/)?.[1];
 	if (fnName) imports.addCore(fnName);
-	return insertColName(baseExpr, colName);
+	const parenIdx = baseExpr.indexOf("(");
+	if (parenIdx === -1) return baseExpr;
+	const baseFnName = baseExpr.slice(0, parenIdx);
+	const rest = baseExpr.slice(parenIdx + 1);
+	return rest === ")" ? `${baseFnName}('${colName}')` : `${baseFnName}('${colName}', ${rest}`;
 }
 function makeDefaultChain(dflt, fieldType, provider, imports) {
 	if (dflt === void 0 || dflt === null) return "";
@@ -228,9 +216,6 @@ function makeColumn(field, model, provider, imports, enums) {
 	].join("");
 	return `${field.name}: ${colExpr}${chain}`;
 }
-function makeEnums() {
-	return [];
-}
 function makeCompositeConstraints(model, imports, indexes) {
 	const pkLine = model.primaryKey ? (() => {
 		imports.addCore("primaryKey");
@@ -291,9 +276,16 @@ function makeRelations(models, imports) {
 	});
 }
 function drizzleSchema(datamodel, provider, indexes) {
-	const db = resolveProvider(provider);
+	const db = (() => {
+		switch (provider) {
+			case "postgresql":
+			case "cockroachdb": return "postgresql";
+			case "mysql": return "mysql";
+			case "sqlite": return "sqlite";
+			default: throw new Error(`Unsupported provider: ${provider}`);
+		}
+	})();
 	const imports = new ImportTracker(db);
-	const enumLines = makeEnums();
 	const tableLines = datamodel.models.map((model) => makeTable(model, db, imports, datamodel.enums, indexes));
 	const relationsLines = makeRelations(datamodel.models, imports);
 	const tableLinesWithGap = tableLines.flatMap((line, i) => i < tableLines.length - 1 ? [line, ""] : [line]);
@@ -301,7 +293,6 @@ function drizzleSchema(datamodel, provider, indexes) {
 	return [
 		imports.generate(),
 		"",
-		...enumLines.length > 0 ? [...enumLines, ""] : [],
 		...tableLinesWithGap,
 		...relationsLinesWithGap.length > 0 ? ["", ...relationsLinesWithGap] : []
 	].join("\n");