hekireki 0.7.0 → 0.7.2

package/README.md

@@ -2,18 +2,31 @@
 
 # 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, ORM models, and ER diagrams from [Prisma](https://www.prisma.io/) schemas — supporting TypeScript, Python, Go, Rust, and Elixir.
 
 ## Features
 
+### TypeScript Validation Libraries
+
 - 💎 Automatically generates [Zod](https://zod.dev/) schemas from your Prisma schema
 - 🤖 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
+
+### ORM / Schema Generation (Multi-Language)
+
 - 🗄️ Automatically generates [Drizzle ORM](https://orm.drizzle.team/) table schemas and relations from your Prisma schema
+- 🐍 Automatically generates [SQLAlchemy](https://www.sqlalchemy.org/) models (Python) — with `Mapped[T]` type hints, relationships, enums, composite keys, and index support
+- 🐹 Automatically generates [GORM](https://gorm.io/) models (Go) — with struct tags, JSON tags, relationships, enums, composite keys, and index support
+- 🦀 Automatically generates [Sea-ORM](https://www.sea-ql.org/SeaORM/) entities (Rust) — with `DeriveEntityModel`, relations, enums, serde support, and `rename_all`
+- 🧪 Generates [Ecto](https://hexdocs.pm/ecto/Ecto.Schema.html) schemas (Elixir) — with associations (`belongs_to`, `has_many`, `has_one`), composite primary keys, `@type t` typespecs, array fields, `@@map`/`@map` support, and `@moduledoc`
+
+### Diagrams & Documentation
+
 - 📊 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 — with associations (`belongs_to`, `has_many`, `has_one`), composite primary keys, `@type t` typespecs, array fields, `@@map`/`@map` support, and `@moduledoc`
 
 ## Installation
 
@@ -62,10 +75,41 @@ 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"
 }
 
+generator Hekireki-SQLAlchemy {
+    provider = "hekireki-sqlalchemy"
+    output   = "./sqlalchemy"
+}
+
+generator Hekireki-GORM {
+    provider = "hekireki-gorm"
+    output   = "./gorm"
+    package  = "model"
+}
+
+generator Hekireki-SeaORM {
+    provider   = "hekireki-sea-orm"
+    output     = "./sea_orm"
+    renameAll  = "camelCase"
+}
+
 generator Hekireki-Ecto {
     provider = "hekireki-ecto"
     output = "./ecto"
@@ -88,12 +132,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[]
@@ -105,24 +153,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])
@@ -295,6 +351,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
@@ -390,18 +548,90 @@ defmodule DBSchema.Post do
 end
 ```
 
-**Supported features:**
+### SQLAlchemy
 
-| Feature | Details |
-|---|---|
-| Primary keys | UUID (`@default(uuid())`), autoincrement (`@default(autoincrement())`), CUID, composite (`@@id`) |
-| Associations | `belongs_to`, `has_many`, `has_one` with correct FK types |
-| Timestamps | `timestamps()` with `inserted_at_source`/`updated_at_source` for `@map`/camelCase fields |
-| Enums | `Ecto.Enum` with `values: [...]` |
-| Array fields | `{:array, :type}` for Prisma list scalars (`String[]`, `Int[]`, etc.) |
-| Name mapping | `@@map` → schema table name, `@map` → field `source:` option |
-| Typespecs | `@type t :: %__MODULE__{...}` auto-generated for Dialyzer |
-| `@moduledoc` | Uses `///` model documentation, or `false` when absent |
+```python
+from sqlalchemy import ForeignKey
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship
+
+
+class Base(DeclarativeBase):
+    pass
+
+
+class User(Base):
+    __tablename__ = "user"
+
+    id: Mapped[str] = mapped_column(primary_key=True)
+    name: Mapped[str]
+
+    posts: Mapped[list["Post"]] = relationship(back_populates="user")
+
+
+class Post(Base):
+    __tablename__ = "post"
+
+    id: Mapped[str] = mapped_column(primary_key=True)
+    title: Mapped[str]
+    content: Mapped[str]
+    user_id: Mapped[str] = mapped_column(ForeignKey("user.id"))
+
+    user: Mapped["User"] = relationship(back_populates="posts")
+```
+
+### GORM
+
+```go
+package model
+
+type User struct {
+	ID   string `gorm:"column:id;primaryKey;type:char(36)" json:"id"`
+	Name string `gorm:"column:name;not null" json:"name"`
+	Posts []Post `gorm:"foreignKey:UserID"`
+}
+
+type Post struct {
+	ID      string `gorm:"column:id;primaryKey;type:char(36)" json:"id"`
+	Title   string `gorm:"column:title;not null" json:"title"`
+	Content string `gorm:"column:content;not null" json:"content"`
+	UserID  string `gorm:"column:user_id;not null" json:"user_id"`
+	User    User
+}
+```
+
+### Sea-ORM
+
+Each model is output as a separate `.rs` file with `mod.rs` and `prelude.rs`, following Sea-ORM conventions.
+
+**user.rs:**
+
+```rust
+use sea_orm::entity::prelude::*;
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+#[sea_orm(table_name = "user")]
+pub struct Model {
+    #[sea_orm(primary_key, auto_increment = false)]
+    pub id: String,
+    pub name: String,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(has_many = "super::post::Entity")]
+    Posts,
+}
+
+impl Related<super::post::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Posts.def()
+    }
+}
+
+impl ActiveModelBehavior for ActiveModel {}
+```
 
 ### DBML
 
@@ -487,6 +717,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"
@@ -499,7 +747,27 @@ generator Hekireki-ER {
     output   = "./mermaid-er" // Output path (default: ./mermaid-er/ER.md)
 }
 
-// Ecto Generator
+// SQLAlchemy Generator (Python)
+generator Hekireki-SQLAlchemy {
+    provider = "hekireki-sqlalchemy"
+    output   = "./sqlalchemy"      // Output path (default: ./sqlalchemy/models.py)
+}
+
+// GORM Generator (Go)
+generator Hekireki-GORM {
+    provider = "hekireki-gorm"
+    output   = "./gorm"            // Output path (default: ./gorm/models.go)
+    package  = "model"             // Go package name (default: model)
+}
+
+// Sea-ORM Generator (Rust)
+generator Hekireki-SeaORM {
+    provider   = "hekireki-sea-orm"
+    output     = "./sea_orm"       // Output directory for .rs files
+    renameAll  = "camelCase"       // #[serde(rename_all = "...")] attribute (optional)
+}
+
+// Ecto Generator (Elixir)
 generator Hekireki-Ecto {
     provider = "hekireki-ecto"
     output   = "./ecto"      // Output directory (default: ./ecto/)

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-DeZn2r_T.js";
-import { n as validationSchemas, t as makeRelationsOnly } from "../../prisma-Cc0YxSiO.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-DeZn2r_T.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