hekireki 0.7.1 → 0.7.2

package/README.md

@@ -2,20 +2,31 @@
 
 # Hekireki
 
-**[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.
+**[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
 
@@ -82,6 +93,23 @@ 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"
@@ -520,6 +548,91 @@ defmodule DBSchema.Post do
 end
 ```
 
+### SQLAlchemy
+
+```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
 
 ```dbml
@@ -634,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/gorm/index.d.ts

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

package/dist/generator/gorm/index.js

@@ -0,0 +1,370 @@
+#!/usr/bin/env node
+import { d as mkdir, f as writeFile, n as getString, o as makeSnakeCase } from "../../utils-COHZyQue.js";
+import path, { dirname } from "node:path";
+import pkg from "@prisma/generator-helper";
+
+//#region src/helper/gorm.ts
+const PRISMA_TO_GO = {
+	String: "string",
+	Int: "int",
+	BigInt: "int64",
+	Float: "float64",
+	Decimal: "float64",
+	Boolean: "bool",
+	DateTime: "time.Time",
+	Json: "datatypes.JSON",
+	Bytes: "[]byte"
+};
+function prismaTypeToGoType(type, isRequired) {
+	const base = PRISMA_TO_GO[type] ?? "string";
+	if (!isRequired && base !== "[]byte" && base !== "datatypes.JSON") return `*${base}`;
+	return base;
+}
+function resolveNativeType(field) {
+	if (!field.nativeType) return null;
+	const [nativeName, nativeArgs] = field.nativeType;
+	const args = nativeArgs ?? [];
+	switch (nativeName) {
+		case "VarChar":
+		case "Char": return args.length > 0 ? `varchar(${args[0]})` : null;
+		case "Text":
+		case "MediumText":
+		case "LongText":
+		case "TinyText": return "text";
+		case "SmallInt":
+		case "TinyInt": return "smallint";
+		case "MediumInt": return "mediumint";
+		case "DoublePrecision":
+		case "Double":
+		case "Real": return "double precision";
+		case "Decimal":
+		case "Money": return args.length >= 2 ? `decimal(${args[0]},${args[1]})` : "decimal";
+		case "Uuid": return "char(36)";
+		case "Timestamp":
+		case "Timestamptz": return "timestamp";
+		case "Date": return "date";
+		case "Time":
+		case "Timetz": return "time";
+		case "JsonB": return "jsonb";
+		case "Xml": return "xml";
+		default: return null;
+	}
+}
+function getAssociations(model, allModels) {
+	const belongsTo = [];
+	const hasMany = [];
+	const hasOne = [];
+	const manyToMany = [];
+	for (const field of model.fields) {
+		if (field.kind !== "object") continue;
+		if (field.relationFromFields && field.relationFromFields.length > 0) belongsTo.push({
+			name: field.name,
+			targetModel: field.type,
+			foreignKey: field.relationFromFields[0],
+			references: field.relationToFields?.[0] ?? "id"
+		});
+		else if (field.isList) {
+			const targetModel = allModels.find((m) => m.name === field.type);
+			if (!targetModel) continue;
+			if (targetModel.fields.find((f) => f.relationName === field.relationName && f.kind === "object")?.isList) manyToMany.push({
+				name: field.name,
+				targetModel: field.type,
+				relationName: field.relationName ?? `${model.name}To${field.type}`
+			});
+			else {
+				const fkField = targetModel.fields.find((f) => f.relationName === field.relationName && f.relationFromFields && f.relationFromFields.length > 0);
+				const foreignKey = fkField?.relationFromFields?.[0];
+				if (!foreignKey) continue;
+				const references = fkField?.relationToFields?.[0] ?? "id";
+				hasMany.push({
+					name: field.name,
+					targetModel: field.type,
+					foreignKey,
+					references,
+					isList: true
+				});
+			}
+		} else {
+			const targetModel = allModels.find((m) => m.name === field.type);
+			if (!targetModel) continue;
+			const fkField = targetModel.fields.find((f) => f.relationName === field.relationName && f.relationFromFields && f.relationFromFields.length > 0);
+			const foreignKey = fkField?.relationFromFields?.[0];
+			if (!foreignKey) continue;
+			const references = fkField?.relationToFields?.[0] ?? "id";
+			hasOne.push({
+				name: field.name,
+				targetModel: field.type,
+				foreignKey,
+				references,
+				isList: false
+			});
+		}
+	}
+	return {
+		belongsTo,
+		hasMany,
+		hasOne,
+		manyToMany
+	};
+}
+function isFunctionDefault(def) {
+	return def !== null && typeof def === "object" && "name" in def;
+}
+function isAutoincrement(field) {
+	return isFunctionDefault(field.default) && field.default.name === "autoincrement";
+}
+function formatGoDefault(def) {
+	if (def === void 0 || def === null) return null;
+	if (typeof def === "boolean") return def ? "true" : "false";
+	if (typeof def === "number") return String(def);
+	if (typeof def === "string") return def;
+	return null;
+}
+function buildGormTags(field, isPk, isCompositePk, compositeIndexTags) {
+	const columnName = field.dbName ?? makeSnakeCase(field.name);
+	const parts = [`column:${columnName}`];
+	if (isPk) {
+		parts.push("primaryKey");
+		if (isAutoincrement(field)) parts.push("autoIncrement");
+		if (isFunctionDefault(field.default) && field.default.name === "uuid") parts.push("type:char(36)");
+	}
+	if (field.isUnique) parts.push("uniqueIndex");
+	for (const tag of compositeIndexTags) parts.push(tag);
+	const nativeType = resolveNativeType(field);
+	if (nativeType && !isPk) parts.push(`type:${nativeType}`);
+	else if (nativeType && isPk && !isFunctionDefault(field.default)) parts.push(`type:${nativeType}`);
+	else if (nativeType && isPk && isFunctionDefault(field.default) && field.default.name !== "uuid") parts.push(`type:${nativeType}`);
+	if (!isPk || isCompositePk) if (field.type === "DateTime" && isFunctionDefault(field.default) && field.default.name === "now") parts.push("autoCreateTime");
+	else if (field.isUpdatedAt) {} else {
+		const defaultVal = formatGoDefault(field.default);
+		if (defaultVal !== null) parts.push(`default:${defaultVal}`);
+	}
+	else if (isPk && !isCompositePk) {
+		if (field.type === "DateTime" && isFunctionDefault(field.default) && field.default.name === "now") parts.push("autoCreateTime");
+	}
+	if (field.isUpdatedAt) parts.push("autoUpdateTime");
+	if (field.isRequired && !isPk) parts.push("not null");
+	return `\`gorm:"${parts.join(";")}" json:"${columnName}"\``;
+}
+function collectCompositeIndexTags(model, indexes) {
+	const tagMap = /* @__PURE__ */ new Map();
+	const addTag = (fieldName, tag) => {
+		const existing = tagMap.get(fieldName) ?? [];
+		existing.push(tag);
+		tagMap.set(fieldName, existing);
+	};
+	for (const fields of model.uniqueFields) {
+		if (fields.length <= 1) continue;
+		const idxName = `idx_${fields.map((f) => {
+			return model.fields.find((mf) => mf.name === f)?.dbName ?? makeSnakeCase(f);
+		}).join("_")}_unique`;
+		for (const f of fields) addTag(f, `uniqueIndex:${idxName}`);
+	}
+	for (const idx of indexes) {
+		if (idx.model !== model.name) continue;
+		if (idx.type !== "normal" && idx.type !== "fulltext") continue;
+		const idxName = idx.dbName ?? idx.name ?? `idx_${idx.fields.map((f) => makeSnakeCase(f.name)).join("_")}`;
+		for (const f of idx.fields) addTag(f.name, `index:${idxName}`);
+	}
+	return tagMap;
+}
+const GO_INITIALISMS = new Set([
+	"acl",
+	"api",
+	"ascii",
+	"cpu",
+	"css",
+	"dns",
+	"eof",
+	"guid",
+	"html",
+	"http",
+	"https",
+	"id",
+	"ip",
+	"json",
+	"lhs",
+	"qps",
+	"ram",
+	"rhs",
+	"rpc",
+	"sla",
+	"smtp",
+	"sql",
+	"ssh",
+	"tcp",
+	"tls",
+	"ttl",
+	"udp",
+	"ui",
+	"uid",
+	"uri",
+	"url",
+	"utf8",
+	"uuid",
+	"vm",
+	"xml",
+	"xmpp",
+	"xsrf",
+	"xss"
+]);
+/**
+* Split a camelCase/PascalCase name into words, applying Go initialism rules.
+* e.g. "userId" -> ["User", "ID"], "avatarUrl" -> ["Avatar", "URL"],
+*      "ipAddress" -> ["IP", "Address"], "createdAt" -> ["Created", "At"]
+*/
+function splitGoWords(name) {
+	const parts = name.replace(/([a-z0-9])([A-Z])/g, "$1\0$2").split("\0");
+	const result = [];
+	let i = 0;
+	while (i < parts.length) {
+		const lower = parts[i].toLowerCase();
+		if (GO_INITIALISMS.has(lower)) {
+			result.push(lower.toUpperCase());
+			i++;
+			continue;
+		}
+		result.push(parts[i].charAt(0).toUpperCase() + parts[i].slice(1));
+		i++;
+	}
+	return result;
+}
+function goFieldName(name) {
+	return splitGoWords(name).join("");
+}
+function generateStructField(field, isPk, isCompositePk, compositeIndexTags, _enumNames) {
+	const fieldName = goFieldName(field.name);
+	let goType;
+	if (field.kind === "enum") goType = field.isRequired ? "string" : "*string";
+	else goType = prismaTypeToGoType(field.type, field.isRequired);
+	const tag = buildGormTags(field, isPk, isCompositePk, compositeIndexTags);
+	const tagStr = tag ? ` ${tag}` : "";
+	return `\t${fieldName} ${goType}${tagStr}`;
+}
+function needsReferencesTag(references) {
+	return references !== "id";
+}
+function buildRelationTag(parts) {
+	return `\`gorm:"${parts.join(";")}"\``;
+}
+function generateRelationFields(model, associations) {
+	const lines = [];
+	for (const assoc of associations.belongsTo) {
+		const fieldName = goFieldName(assoc.name);
+		const fkFieldName = goFieldName(assoc.foreignKey);
+		const refsFieldName = goFieldName(assoc.references);
+		const isAmbiguous = fieldName !== assoc.targetModel || associations.belongsTo.filter((a) => a.targetModel === assoc.targetModel).length > 1;
+		const tagParts = [];
+		if (isAmbiguous) tagParts.push(`foreignKey:${fkFieldName}`);
+		if (needsReferencesTag(assoc.references)) tagParts.push(`references:${refsFieldName}`);
+		if (tagParts.length > 0) lines.push(`\t${fieldName} ${assoc.targetModel} ${buildRelationTag(tagParts)}`);
+		else lines.push(`\t${fieldName} ${assoc.targetModel}`);
+	}
+	for (const assoc of associations.hasMany) {
+		const tagParts = [`foreignKey:${goFieldName(assoc.foreignKey)}`];
+		if (needsReferencesTag(assoc.references)) tagParts.push(`references:${goFieldName(assoc.references)}`);
+		lines.push(`\t${goFieldName(assoc.name)} []${assoc.targetModel} ${buildRelationTag(tagParts)}`);
+	}
+	for (const assoc of associations.hasOne) {
+		const tagParts = [`foreignKey:${goFieldName(assoc.foreignKey)}`];
+		if (needsReferencesTag(assoc.references)) tagParts.push(`references:${goFieldName(assoc.references)}`);
+		lines.push(`\t${goFieldName(assoc.name)} ${assoc.targetModel} ${buildRelationTag(tagParts)}`);
+	}
+	for (const assoc of associations.manyToMany) {
+		const [leftName, rightName] = model.name < assoc.targetModel ? [model.name, assoc.targetModel] : [assoc.targetModel, model.name];
+		const joinTable = `_${leftName}To${rightName}`;
+		lines.push(`\t${goFieldName(assoc.name)} []${assoc.targetModel} \`gorm:"many2many:${joinTable};"\``);
+	}
+	return lines;
+}
+function generateModelStruct(model, allModels, enums, indexes) {
+	const idField = model.fields.find((f) => f.isId);
+	const compositePkFieldNames = new Set(model.primaryKey?.fields ?? []);
+	const isCompositePk = !idField && compositePkFieldNames.size > 0;
+	if (!(idField || isCompositePk)) return null;
+	const associations = getAssociations(model, allModels);
+	const enumNames = new Set((enums ?? []).map((e) => e.name));
+	const compositeTagMap = collectCompositeIndexTags(model, indexes);
+	const tableName = model.dbName ?? makeSnakeCase(model.name);
+	const fieldLines = model.fields.filter((f) => f.kind !== "object").map((field) => {
+		return generateStructField(field, field.isId || compositePkFieldNames.has(field.name), isCompositePk, compositeTagMap.get(field.name) ?? [], enumNames);
+	});
+	const relationLines = generateRelationFields(model, associations);
+	const lines = [
+		`type ${model.name} struct {`,
+		...fieldLines,
+		...relationLines.length > 0 ? relationLines : [],
+		"}"
+	];
+	if (tableName !== makeSnakeCase(model.name)) {
+		lines.push("");
+		lines.push(`func (${model.name}) TableName() string {`);
+		lines.push(`\treturn "${tableName}"`);
+		lines.push("}");
+	}
+	return lines.join("\n");
+}
+function collectImports(models) {
+	const imports = [];
+	const needsTime = models.some((m) => m.fields.some((f) => f.kind !== "object" && f.type === "DateTime"));
+	const needsDatatypes = models.some((m) => m.fields.some((f) => f.kind !== "object" && f.type === "Json"));
+	if (needsTime) imports.push("\"time\"");
+	if (needsDatatypes) imports.push("\"gorm.io/datatypes\"");
+	return imports;
+}
+function generateGormModels(models, enums, indexes, packageName = "model") {
+	const idx = indexes ?? [];
+	const modelBodies = models.map((model) => generateModelStruct(model, models, enums, idx)).filter((body) => body !== null);
+	const imports = collectImports(models);
+	const lines = [`package ${packageName}`];
+	if (imports.length > 0) {
+		lines.push("");
+		if (imports.length === 1) lines.push(`import ${imports[0]}`);
+		else {
+			lines.push("import (");
+			for (const imp of imports) lines.push(`\t${imp}`);
+			lines.push(")");
+		}
+	}
+	lines.push("");
+	lines.push(modelBodies.join("\n\n"));
+	lines.push("");
+	return lines.join("\n");
+}
+async function writeGormFile(models, outPath, enums, indexes, packageName = "model") {
+	const mkdirResult = await mkdir(dirname(outPath));
+	if (!mkdirResult.ok) return mkdirResult;
+	const writeResult = await writeFile(outPath, generateGormModels(models, enums, indexes, packageName));
+	if (!writeResult.ok) return writeResult;
+	console.log(`wrote ${outPath}`);
+	return {
+		ok: true,
+		value: void 0
+	};
+}
+
+//#endregion
+//#region src/generator/gorm/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-GORM. Please specify output in your generator config.");
+	const output = options.generator.output.value;
+	const resolved = path.extname(output) ? output : path.join(output, "models.go");
+	const packageName = getString(options.generator.config.package, "model");
+	const enums = options.dmmf.datamodel.enums;
+	const indexes = options.dmmf.datamodel.indexes;
+	const result = await writeGormFile(options.dmmf.datamodel.models, resolved, enums, indexes, packageName);
+	if (!result.ok) throw new Error(`Failed to write GORM models: ${result.error}`);
+}
+generatorHandler({
+	onManifest() {
+		return {
+			defaultOutput: ".",
+			prettyName: "Hekireki-GORM"
+		};
+	},
+	onGenerate: main
+});
+
+//#endregion
+export { main };

package/dist/generator/sea-orm/index.d.ts

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