hekireki 0.7.0 → 0.7.2

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-DeZn2r_T.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");

package/dist/generator/ecto/index.js

@@ -1,9 +1,36 @@
 #!/usr/bin/env node
-import { N as mkdir, P as writeFile, b as makeSnakeCase, k as prismaTypeToEctoType, n as ectoTypeToTypespec } from "../../utils-DeZn2r_T.js";
+import { d as mkdir, f as writeFile, o as makeSnakeCase } from "../../utils-COHZyQue.js";
 import { join } from "node:path";
 import pkg from "@prisma/generator-helper";
 
 //#region src/helper/ecto.ts
+function prismaTypeToEctoType(type) {
+	if (type === "Int") return "integer";
+	if (type === "BigInt") return "integer";
+	if (type === "Float") return "float";
+	if (type === "Decimal") return "decimal";
+	if (type === "String") return "string";
+	if (type === "Boolean") return "boolean";
+	if (type === "DateTime") return "utc_datetime";
+	if (type === "Json") return "map";
+	if (type === "Bytes") return "binary";
+	return "string";
+}
+function ectoTypeToTypespec(type) {
+	switch (type) {
+		case "string": return "String.t()";
+		case "integer": return "integer()";
+		case "float": return "float()";
+		case "boolean": return "boolean()";
+		case "binary_id": return "Ecto.UUID.t()";
+		case "naive_datetime": return "NaiveDateTime.t()";
+		case "utc_datetime": return "DateTime.t()";
+		case "decimal": return "Decimal.t()";
+		case "map": return "map()";
+		case "binary": return "binary()";
+		default: return "term()";
+	}
+}
 function getPrimaryKeyConfig(field) {
 	const def = field.default;
 	const isFunctionDefault = def && typeof def === "object" && "name" in def;
@@ -26,13 +53,6 @@ function getPrimaryKeyConfig(field) {
 		useBinaryForeignKey: false
 	};
 }
-function getFieldDefaultOption(field) {
-	const def = field.default;
-	if (def === void 0 || def === null) return null;
-	if (typeof def === "string") return `default: "${def}"`;
-	if (typeof def === "number" || typeof def === "boolean") return `default: ${def}`;
-	return null;
-}
 function makeTimestampsLine(fields) {
 	const insertedAliases = [
 		"inserted_at",
@@ -183,7 +203,12 @@ function ectoSchemas(models, app, allModels, enums) {
 			}
 			const type = prismaTypeToEctoType(f.type);
 			const ectoType = f.isList ? `{:array, :${type}}` : `:${type}`;
-			const defaultOpt = getFieldDefaultOption(f);
+			const defaultOpt = ((def) => {
+				if (def === void 0 || def === null) return null;
+				if (typeof def === "string") return `default: "${def}"`;
+				if (typeof def === "number" || typeof def === "boolean") return `default: ${def}`;
+				return null;
+			})(f.default);
 			return `    field(:${snakeName}, ${ectoType}${primary}${defaultOpt ? `, ${defaultOpt}` : ""}${sourceOpt})`;
 		});
 		const fkFieldLines = [];

package/dist/generator/effect/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, g as makeEffectSchema, h as makeEffectProperties, j as schemaFromFields, m as makeEffectInfer, p as makeEffectEnumExpression, 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/effect.ts
+function makeEffectInfer(modelName) {
+	return `export type ${modelName} = Schema.Schema.Type<typeof ${modelName}Schema>`;
+}
+function makeEffectSchema(modelName, fields) {
+	return `export const ${modelName}Schema = Schema.Struct({\n${fields}\n})`;
+}
+function makeEffectProperties(fields, comment) {
+	return fields.map((field) => {
+		return `${comment && field.comment.length > 0 ? `${field.comment.map((c) => `  /** ${c} */`).join("\n")}\n` : ""}  ${field.fieldName}: ${field.validation ?? "Schema.Unknown"},`;
+	}).join("\n");
+}
+function makeEffectEnumExpression(values) {
+	return `Schema.Literal(${values.map((v) => `'${v}'`).join(", ")})`;
+}
 const PRISMA_TO_EFFECT = {
 	String: "Schema.String",
 	Int: "Schema.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([effect(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), makeEffectRelations) : ""].filter(Boolean).join("\n\n"));
 	if (!fmtResult.ok) throw new Error(`Format error: ${fmtResult.error}`);
 	const mkdirResult = await mkdir(resolved.dir);

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/mermaid-er/index.js

@@ -1,32 +1,26 @@
 #!/usr/bin/env node
-import { A as removeDuplicateRelations, N as mkdir, P as writeFile } from "../../utils-DeZn2r_T.js";
+import { d as mkdir, f as writeFile, u as stripAnnotations } from "../../utils-COHZyQue.js";
 import path from "node:path";
 import pkg from "@prisma/generator-helper";
 
 //#region src/helper/mermaid-er.ts
-const ZOD_ANNOTATION = "@z.";
-const VALIBOT_ANNOTATION = "@v.";
-const RELATION_ANNOTATION = "@relation";
+function removeDuplicateRelations(relations) {
+	return [...new Set(relations)];
+}
 const RELATIONSHIPS = {
 	"zero-one": "|o",
 	one: "||",
 	"zero-many": "}o",
 	many: "}|"
 };
-function toMermaidType(prismaType) {
-	return prismaType.toLowerCase();
-}
 function modelFields(model) {
 	const fkFields = new Set(model.fields.filter((f) => f.relationFromFields && f.relationFromFields.length > 0).flatMap((f) => f.relationFromFields ?? []));
 	return model.fields.map((field) => {
 		if (field.relationName) return null;
-		const commentPart = field.documentation ? field.documentation.split("\n").filter((line) => {
-			const trimmed = line.trim();
-			return !(trimmed.startsWith(ZOD_ANNOTATION) || trimmed.startsWith(VALIBOT_ANNOTATION) || trimmed.startsWith("@a.") || trimmed.startsWith("@e.") || trimmed.includes(RELATION_ANNOTATION) || trimmed === "@z" || trimmed === "@v" || trimmed === "@a" || trimmed === "@e");
-		}).join("\n").trim() : "";
+		const commentPart = stripAnnotations(field.documentation) ?? "";
 		const keyMarker = field.isId ? "PK" : fkFields.has(field.name) ? "FK" : "";
 		const keyPart = keyMarker ? ` ${keyMarker}` : "";
-		return `        ${toMermaidType(field.type)} ${field.name}${keyPart}${commentPart ? ` "${commentPart}"` : ""}`;
+		return `        ${field.type.toLowerCase()} ${field.name}${keyPart}${commentPart ? ` "${commentPart}"` : ""}`;
 	}).filter((field) => field !== null);
 }
 function modelInfo(model) {

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 };