hekireki 0.8.6 → 0.9.1

package/dist/bin/ajv.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as registerGenerator } from "../bin-DLQOqGdU.js";
+import { t as registerGenerator } from "../bin-CR8sx_jS.js";
 //#region src/bin/ajv.ts
 registerGenerator("ajv");
 //#endregion

package/dist/bin/arktype.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as registerGenerator } from "../bin-DLQOqGdU.js";
+import { t as registerGenerator } from "../bin-CR8sx_jS.js";
 //#region src/bin/arktype.ts
 registerGenerator("arktype");
 //#endregion

package/dist/bin/dbml.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as registerGenerator } from "../bin-DLQOqGdU.js";
+import { t as registerGenerator } from "../bin-CR8sx_jS.js";
 //#region src/bin/dbml.ts
 registerGenerator("dbml");
 //#endregion

package/dist/bin/docs.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as registerGenerator } from "../bin-DLQOqGdU.js";
+import { t as registerGenerator } from "../bin-CR8sx_jS.js";
 //#region src/bin/docs.ts
 registerGenerator("docs");
 //#endregion

package/dist/bin/drizzle.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as registerGenerator } from "../bin-DLQOqGdU.js";
+import { t as registerGenerator } from "../bin-CR8sx_jS.js";
 //#region src/bin/drizzle.ts
 registerGenerator("drizzle");
 //#endregion

package/dist/bin/ecto.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as registerGenerator } from "../bin-DLQOqGdU.js";
+import { t as registerGenerator } from "../bin-CR8sx_jS.js";
 //#region src/bin/ecto.ts
 registerGenerator("ecto");
 //#endregion

package/dist/bin/effect.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as registerGenerator } from "../bin-DLQOqGdU.js";
+import { t as registerGenerator } from "../bin-CR8sx_jS.js";
 //#region src/bin/effect.ts
 registerGenerator("effect");
 //#endregion

package/dist/bin/gorm.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as registerGenerator } from "../bin-DLQOqGdU.js";
+import { t as registerGenerator } from "../bin-CR8sx_jS.js";
 //#region src/bin/gorm.ts
 registerGenerator("gorm");
 //#endregion

package/dist/bin/mermaid-er.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as registerGenerator } from "../bin-DLQOqGdU.js";
+import { t as registerGenerator } from "../bin-CR8sx_jS.js";
 //#region src/bin/mermaid-er.ts
 registerGenerator("mermaid-er");
 //#endregion

package/dist/bin/sea-orm.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as registerGenerator } from "../bin-DLQOqGdU.js";
+import { t as registerGenerator } from "../bin-CR8sx_jS.js";
 //#region src/bin/sea-orm.ts
 registerGenerator("sea-orm");
 //#endregion

package/dist/bin/sqlalchemy.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as registerGenerator } from "../bin-DLQOqGdU.js";
+import { t as registerGenerator } from "../bin-CR8sx_jS.js";
 //#region src/bin/sqlalchemy.ts
 registerGenerator("sqlalchemy");
 //#endregion

package/dist/bin/typebox.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as registerGenerator } from "../bin-DLQOqGdU.js";
+import { t as registerGenerator } from "../bin-CR8sx_jS.js";
 //#region src/bin/typebox.ts
 registerGenerator("typebox");
 //#endregion

package/dist/bin/valibot.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as registerGenerator } from "../bin-DLQOqGdU.js";
+import { t as registerGenerator } from "../bin-CR8sx_jS.js";
 //#region src/bin/valibot.ts
 registerGenerator("valibot");
 //#endregion

package/dist/bin/zod.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as registerGenerator } from "../bin-DLQOqGdU.js";
+import { t as registerGenerator } from "../bin-CR8sx_jS.js";
 //#region src/bin/zod.ts
 registerGenerator("zod");
 //#endregion

package/dist/{bin-DLQOqGdU.js → bin-CR8sx_jS.js}

@@ -1043,13 +1043,15 @@ const getOutputTypes = (dmmfOutputTypes) => dmmfOutputTypes.map((outputType) =>
 	}))
 }));
 const getTypesData = (d) => {
+	const prismaInputTypes = d.schema.inputObjectTypes.prisma ?? [];
 	return {
-		inputTypes: getInputTypes(d.schema.inputObjectTypes.prisma ?? []),
+		inputTypes: getInputTypes(prismaInputTypes),
 		outputTypes: getOutputTypes([...d.schema.outputObjectTypes.model, ...d.schema.outputObjectTypes.prisma.filter((op) => op.name !== "Query" && op.name !== "Mutation")])
 	};
 };
 const createTypes = (d) => {
-	return /* @__PURE__ */ jsx(TypesSection, { data: getTypesData(d) });
+	const data = getTypesData(d);
+	return /* @__PURE__ */ jsx(TypesSection, { data });
 };
 //#endregion
 //#region src/helper/docs/generator/model.tsx
@@ -1414,7 +1416,8 @@ const getModels$1 = (dmmf) => dmmf.datamodel.models.map((model) => ({
 }));
 const getModelData = (d) => ({ models: getModels$1(d) });
 const createModels = (d) => {
-	return /* @__PURE__ */ jsx(ModelsSection, { data: getModelData(d) });
+	const data = getModelData(d);
+	return /* @__PURE__ */ jsx(ModelsSection, { data });
 };
 //#endregion
 //#region src/helper/docs/generator/toc.tsx
@@ -1543,7 +1546,8 @@ const getTOCData = (d) => ({
 	types: getTypes(d.schema)
 });
 const createTOC = (d) => {
-	return /* @__PURE__ */ jsx(TOCComponent, { data: getTOCData(d) });
+	const data = getTOCData(d);
+	return /* @__PURE__ */ jsx(TOCComponent, { data });
 };
 //#endregion
 //#region src/helper/docs/printer/index.tsx
@@ -1802,6 +1806,18 @@ function resolveVarNameByType(type, models) {
 function isFieldDefault(v) {
 	return typeof v === "object" && v !== null && "name" in v;
 }
+function enumIdentifier(enumName) {
+	return `${snakeToCamel(makeSnakeCase(enumName))}Enum`;
+}
+function makeEnumDeclarations(models, enums, provider, imports) {
+	if (provider !== "postgresql") return [];
+	const usedEnumNames = new Set(models.flatMap((m) => m.fields.filter((f) => f.kind === "enum").map((f) => f.type)));
+	return enums.filter((e) => usedEnumNames.has(e.name)).map((e) => {
+		imports.core.add("pgEnum");
+		const values = e.values.map((v) => `'${v.name}'`).join(", ");
+		return `export const ${enumIdentifier(e.name)} = pgEnum('${e.dbName ?? e.name}', [${values}])`;
+	});
+}
 function resolveScalarType(field, provider) {
 	if (field.nativeType && provider !== "sqlite") {
 		const [nativeName, nativeArgs] = field.nativeType;
@@ -1816,10 +1832,7 @@ function makeColumnExpr(field, provider, imports, enums) {
 	if (field.kind === "enum") {
 		const enumDef = enums.find((e) => e.name === field.type);
 		const enumValues = enumDef ? enumDef.values.map((v) => `'${v.name}'`).join(", ") : "";
-		if (provider === "postgresql") {
-			imports.core.add("pgEnum");
-			return `pgEnum('${enumDef?.dbName ?? field.type}', [${enumValues}])('${colName}')`;
-		}
+		if (provider === "postgresql") return `${enumIdentifier(field.type)}('${colName}')`;
 		if (provider === "mysql") {
 			imports.core.add("mysqlEnum");
 			return `mysqlEnum('${colName}', [${enumValues}])`;
@@ -1977,6 +1990,7 @@ function makeColumn(field, model, models, provider, imports, enums) {
 	const hasCompositePK = model.primaryKey !== null;
 	const colExpr = makeColumnExpr(field, provider, imports, enums);
 	const chain = [
+		field.isList && field.kind === "scalar" && provider === "postgresql" ? ".array()" : "",
 		field.isId && !hasCompositePK ? isAutoincrement && provider === "sqlite" ? ".primaryKey({ autoIncrement: true })" : ".primaryKey()" : "",
 		field.isRequired && !field.isId && !(isAutoincrement && provider === "postgresql") ? ".notNull()" : "",
 		field.isUnique ? ".unique()" : "",
@@ -1986,8 +2000,7 @@ function makeColumn(field, model, models, provider, imports, enums) {
 			if (r.needsSql) imports.orm.add("sql");
 			return r.chain;
 		})() : makeDefaultChain(field.default, field.type, provider, imports),
-		field.isUpdatedAt ? ".$onUpdate(() => new Date())" : "",
-		field.isList && field.kind === "scalar" && provider === "postgresql" ? ".array()" : ""
+		field.isUpdatedAt ? ".$onUpdate(() => new Date())" : ""
 	].join("");
 	return `${field.name}: ${colExpr}${chain}`;
 }
@@ -2055,6 +2068,7 @@ function makeRelations(models, imports) {
 function drizzleSchema(datamodel, provider, indexes) {
 	const db = resolveDbProvider(provider);
 	const imports = createImports();
+	const enumLines = makeEnumDeclarations(datamodel.models, datamodel.enums, db, imports);
 	const tableLines = datamodel.models.map((model) => makeTable(model, datamodel.models, db, imports, datamodel.enums, indexes));
 	const relationsLines = makeRelations(datamodel.models, imports);
 	const tableLinesWithGap = tableLines.flatMap((line, i) => i < tableLines.length - 1 ? [line, ""] : [line]);
@@ -2062,6 +2076,7 @@ function drizzleSchema(datamodel, provider, indexes) {
 	return [
 		generateImports(imports, db),
 		"",
+		...enumLines.length > 0 ? [...enumLines, ""] : [],
 		...tableLinesWithGap,
 		...relationsLinesWithGap.length > 0 ? ["", ...relationsLinesWithGap] : []
 	].join("\n");
@@ -2198,6 +2213,7 @@ function getAssociations$3(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) {
@@ -2213,7 +2229,15 @@ function getAssociations$3(model, allModels) {
 		const targetModel = allModels.find((m) => m.name === field.type);
 		if (!targetModel) continue;
 		if (field.isList) {
-			if (targetModel.fields.find((f) => f.relationName === field.relationName && f.kind === "object")?.isList) continue;
+			if (targetModel.fields.find((f) => f.relationName === field.relationName && f.kind === "object")?.isList) {
+				const [left, right] = model.name < field.type ? [model.name, field.type] : [field.type, model.name];
+				manyToMany.push({
+					name: field.name,
+					targetModel: field.type,
+					joinThrough: `_${left}To${right}`
+				});
+				continue;
+			}
 		}
 		const foreignKey = targetModel.fields.find((f) => f.relationName === field.relationName && f.relationFromFields && f.relationFromFields.length > 0)?.relationFromFields?.[0];
 		if (!foreignKey) continue;
@@ -2231,7 +2255,8 @@ function getAssociations$3(model, allModels) {
 	return {
 		belongsTo,
 		hasMany,
-		hasOne
+		hasOne,
+		manyToMany
 	};
 }
 function ectoSchemas(models, app, allModels, enums) {
@@ -2271,7 +2296,8 @@ function ectoSchemas(models, app, allModels, enums) {
 			}),
 			...associations.belongsTo.map((a) => `${makeSnakeCase(a.name)}: ${appName}.${a.targetModel}.t() | nil`),
 			...associations.hasOne.map((a) => `${makeSnakeCase(a.name)}: ${appName}.${a.targetModel}.t() | nil`),
-			...associations.hasMany.map((a) => `${makeSnakeCase(a.name)}: [${appName}.${a.targetModel}.t()]`)
+			...associations.hasMany.map((a) => `${makeSnakeCase(a.name)}: [${appName}.${a.targetModel}.t()]`),
+			...associations.manyToMany.map((a) => `${makeSnakeCase(a.name)}: [${appName}.${a.targetModel}.t()]`)
 		];
 		const typeSpecLines = [
 			"  @type t :: %__MODULE__{",
@@ -2294,7 +2320,8 @@ function ectoSchemas(models, app, allModels, enums) {
 			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}`;
+				if (typeof def === "number") return type === "float" && Number.isInteger(def) ? `default: ${def}.0` : `default: ${def}`;
+				if (typeof def === "boolean") return `default: ${def}`;
 				return null;
 			})(f.default);
 			return `    field(:${snakeName}, ${ectoType}${primary}${defaultOpt ? `, ${defaultOpt}` : ""}${sourceOpt})`;
@@ -2331,6 +2358,9 @@ function ectoSchemas(models, app, allModels, enums) {
 			const snakeFk = makeSnakeCase(a.foreignKey);
 			return `    has_many(:${makeSnakeCase(a.name)}, ${appName}.${a.targetModel}, foreign_key: :${snakeFk})`;
 		});
+		const manyToManyLines = associations.manyToMany.map((a) => {
+			return `    many_to_many(:${makeSnakeCase(a.name)}, ${appName}.${a.targetModel}, join_through: "${a.joinThrough}")`;
+		});
 		return [
 			`defmodule ${appName}.${model.name} do`,
 			"  use Ecto.Schema",
@@ -2351,6 +2381,7 @@ function ectoSchemas(models, app, allModels, enums) {
 			...belongsToLines,
 			...hasOneLines,
 			...hasManyLines,
+			...manyToManyLines,
 			...timestampsLine ? [timestampsLine] : [],
 			"  end",
 			"end"
@@ -2561,7 +2592,7 @@ 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;
+	if (typeof def === "string") return `'${def}'`;
 	return null;
 }
 function buildGormTags(field, isPk, isCompositePk, compositeIndexTags) {
@@ -2580,6 +2611,7 @@ function buildGormTags(field, isPk, isCompositePk, compositeIndexTags) {
 		field.isUnique ? "uniqueIndex" : null,
 		...compositeIndexTags,
 		includeNativeType ? `type:${nativeType}` : null,
+		field.isList && field.kind !== "object" ? "serializer:json" : null,
 		includeAutoCreate ? "autoCreateTime" : null,
 		defaultVal !== null ? `default:${defaultVal}` : null,
 		field.isUpdatedAt ? "autoUpdateTime" : null,
@@ -2587,14 +2619,16 @@ function buildGormTags(field, isPk, isCompositePk, compositeIndexTags) {
 	].filter((p) => p !== null).join(";")}" json:"${columnName}"\``;
 }
 function collectCompositeIndexTags(model, indexes) {
+	const tableName = model.dbName ?? makeSnakeCase(model.name);
 	const uniqueTags = model.uniqueFields.filter((fields) => fields.length > 1).flatMap((fields) => {
-		const idxName = `idx_${fields.map((f) => {
+		const cols = fields.map((f) => {
 			return model.fields.find((mf) => mf.name === f)?.dbName ?? makeSnakeCase(f);
-		}).join("_")}_unique`;
+		});
+		const idxName = `idx_${tableName}_${cols.join("_")}_unique`;
 		return fields.map((f) => [f, `uniqueIndex:${idxName}`]);
 	});
 	const indexTags = indexes.filter((idx) => idx.model === model.name && (idx.type === "normal" || idx.type === "fulltext")).flatMap((idx) => {
-		const idxName = idx.dbName ?? idx.name ?? `idx_${idx.fields.map((f) => makeSnakeCase(f.name)).join("_")}`;
+		const idxName = idx.dbName ?? idx.name ?? `idx_${tableName}_${idx.fields.map((f) => makeSnakeCase(f.name)).join("_")}`;
 		return idx.fields.map((f) => [f.name, `index:${idxName}`]);
 	});
 	return [...uniqueTags, ...indexTags].reduce((map, [fieldName, tag]) => {
@@ -2659,7 +2693,8 @@ function goFieldName(name) {
 }
 function generateStructField(field, isPk, isCompositePk, compositeIndexTags, _enumNames) {
 	const fieldName = goFieldName(field.name);
-	const goType = field.kind === "enum" ? field.isRequired ? "string" : "*string" : prismaTypeToGoType(field.type, field.isRequired);
+	const scalarType = field.kind === "enum" ? field.isRequired ? "string" : "*string" : prismaTypeToGoType(field.type, field.isRequired);
+	const goType = field.isList ? `[]${field.kind === "enum" ? "string" : prismaTypeToGoType(field.type, true)}` : scalarType;
 	const tag = buildGormTags(field, isPk, isCompositePk, compositeIndexTags);
 	return `\t${fieldName} ${goType}${tag ? ` ${tag}` : ""}`;
 }
@@ -2675,7 +2710,8 @@ function generateRelationFields(model, associations) {
 		const fkFieldName = goFieldName(assoc.foreignKey);
 		const refsFieldName = goFieldName(assoc.references);
 		const tagParts = [fieldName !== assoc.targetModel || associations.belongsTo.filter((a) => a.targetModel === assoc.targetModel).length > 1 ? `foreignKey:${fkFieldName}` : null, needsReferencesTag(assoc.references) ? `references:${refsFieldName}` : null].filter((p) => p !== null);
-		return tagParts.length > 0 ? `\t${fieldName} ${assoc.targetModel} ${buildRelationTag(tagParts)}` : `\t${fieldName} ${assoc.targetModel}`;
+		const targetType = assoc.targetModel === model.name ? `*${assoc.targetModel}` : assoc.targetModel;
+		return tagParts.length > 0 ? `\t${fieldName} ${targetType} ${buildRelationTag(tagParts)}` : `\t${fieldName} ${targetType}`;
 	});
 	const hasManyLines = associations.hasMany.map((assoc) => {
 		const tagParts = [`foreignKey:${goFieldName(assoc.foreignKey)}`, ...needsReferencesTag(assoc.references) ? [`references:${goFieldName(assoc.references)}`] : []];
@@ -2683,7 +2719,7 @@ function generateRelationFields(model, associations) {
 	});
 	const hasOneLines = associations.hasOne.map((assoc) => {
 		const tagParts = [`foreignKey:${goFieldName(assoc.foreignKey)}`, ...needsReferencesTag(assoc.references) ? [`references:${goFieldName(assoc.references)}`] : []];
-		return `\t${goFieldName(assoc.name)} ${assoc.targetModel} ${buildRelationTag(tagParts)}`;
+		return `\t${goFieldName(assoc.name)} *${assoc.targetModel} ${buildRelationTag(tagParts)}`;
 	});
 	const manyToManyLines = associations.manyToMany.map((assoc) => {
 		const [leftName, rightName] = model.name < assoc.targetModel ? [model.name, assoc.targetModel] : [assoc.targetModel, model.name];
@@ -2707,7 +2743,9 @@ function generateModelStruct(model, allModels, enums, indexes) {
 	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 isPk = field.isId || compositePkFieldNames.has(field.name);
+		const fieldIndexTags = compositeTagMap.get(field.name) ?? [];
+		return generateStructField(field, isPk, isCompositePk, fieldIndexTags, enumNames);
 	});
 	const relationLines = generateRelationFields(model, associations);
 	const tableNameMethod = tableName !== makeSnakeCase(model.name) ? [
@@ -2774,6 +2812,9 @@ const RELATIONSHIPS = {
 	"zero-many": "}o",
 	many: "}|"
 };
+function escapeComment(comment) {
+	return comment.replace(/\r?\n/g, " ").replace(/"/g, "#quot;");
+}
 function erRelationLine(relation, resolveName = (model) => model) {
 	return `    ${resolveName(relation.from.model)} ${RELATIONSHIPS[relation.from.cardinality]}--${RELATIONSHIPS[relation.to.cardinality]} ${resolveName(relation.to.model)} : "(${relation.from.field}) - (${relation.to.field})"`;
 }
@@ -2784,7 +2825,7 @@ function modelFields(model) {
 		const commentPart = stripAnnotations(field.documentation) ?? "";
 		const keyMarker = field.isId ? "PK" : fkFields.has(field.name) ? "FK" : "";
 		const keyPart = keyMarker ? ` ${keyMarker}` : "";
-		return `        ${field.type.toLowerCase()} ${field.name}${keyPart}${commentPart ? ` "${commentPart}"` : ""}`;
+		return `        ${field.type.toLowerCase()} ${field.name}${keyPart}${commentPart ? ` "${escapeComment(commentPart)}"` : ""}`;
 	}).filter((field) => field !== null);
 }
 function modelInfo(model) {
@@ -2845,6 +2886,80 @@ function prismaTypeToRustType(type, isRequired) {
 	if (!isRequired) return `Option<${base}>`;
 	return base;
 }
+const RUST_KEYWORDS = /* @__PURE__ */ new Set([
+	"as",
+	"break",
+	"const",
+	"continue",
+	"crate",
+	"dyn",
+	"else",
+	"enum",
+	"extern",
+	"false",
+	"fn",
+	"for",
+	"if",
+	"impl",
+	"in",
+	"let",
+	"loop",
+	"match",
+	"mod",
+	"move",
+	"mut",
+	"pub",
+	"ref",
+	"return",
+	"self",
+	"Self",
+	"static",
+	"struct",
+	"super",
+	"trait",
+	"true",
+	"type",
+	"unsafe",
+	"use",
+	"where",
+	"while",
+	"async",
+	"await",
+	"abstract",
+	"become",
+	"box",
+	"do",
+	"final",
+	"macro",
+	"override",
+	"priv",
+	"typeof",
+	"unsized",
+	"virtual",
+	"yield",
+	"try",
+	"gen"
+]);
+const RUST_NON_RAW = /* @__PURE__ */ new Set([
+	"self",
+	"Self",
+	"crate",
+	"super"
+]);
+function rustFieldIdent(snake) {
+	if (!RUST_KEYWORDS.has(snake)) return {
+		ident: snake,
+		derivedColumn: snake
+	};
+	if (RUST_NON_RAW.has(snake)) return {
+		ident: `${snake}_`,
+		derivedColumn: `${snake}_`
+	};
+	return {
+		ident: `r#${snake}`,
+		derivedColumn: snake
+	};
+}
 function resolveSeaOrmColumnType(field) {
 	if (!field.nativeType) return null;
 	const [nativeName, nativeArgs] = field.nativeType;
@@ -2887,7 +3002,7 @@ function formatRustDefault(def) {
 	if (typeof def === "string") return `"${def}"`;
 	return null;
 }
-function buildSeaOrmAttributes(field, isPk, isCompositePk) {
+function buildSeaOrmAttributes(field, isPk, isCompositePk, derivedColumn) {
 	const attrs = [];
 	if (isPk) {
 		const parts = ["primary_key"];
@@ -2897,7 +3012,7 @@ function buildSeaOrmAttributes(field, isPk, isCompositePk) {
 	if (field.isUnique) attrs.push("#[sea_orm(unique)]");
 	const columnParts = [];
 	const columnName = field.dbName ?? makeSnakeCase(field.name);
-	if (columnName !== makeSnakeCase(field.name)) columnParts.push(`column_name = "${columnName}"`);
+	if (columnName !== (derivedColumn ?? makeSnakeCase(field.name))) columnParts.push(`column_name = "${columnName}"`);
 	const colType = resolveSeaOrmColumnType(field);
 	if (colType) columnParts.push(`column_type = "${colType}"`);
 	if (!isPk || isCompositePk) {
@@ -2984,7 +3099,7 @@ function buildSerdeAttributes(opts) {
 }
 function generateEnum(e, serde = {}) {
 	const variants = e.values.map((v) => {
-		const pascalName = v.name.charAt(0).toUpperCase() + v.name.slice(1).toLowerCase();
+		const pascalName = v.name.split("_").filter((part) => part !== "").map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join("");
 		return `    #[sea_orm(string_value = "${v.name}")]\n    ${pascalName},`;
 	});
 	return [
@@ -3025,9 +3140,10 @@ function generateRelationEnum(_model, associations) {
 }
 function generateRelatedImpls(model, associations) {
 	const impls = [];
-	const m2mTargets = new Set(associations.manyToMany.map((a) => a.targetModel));
+	const emittedTargets = /* @__PURE__ */ new Set();
 	for (const assoc of associations.belongsTo) {
-		if (m2mTargets.has(assoc.targetModel)) continue;
+		if (emittedTargets.has(assoc.targetModel)) continue;
+		emittedTargets.add(assoc.targetModel);
 		const targetModule = toModuleName(assoc.targetModel);
 		impls.push([
 			`impl Related<super::${targetModule}::Entity> for Entity {`,
@@ -3038,7 +3154,8 @@ function generateRelatedImpls(model, associations) {
 		].join("\n"));
 	}
 	for (const assoc of associations.hasMany) {
-		if (m2mTargets.has(assoc.targetModel)) continue;
+		if (emittedTargets.has(assoc.targetModel)) continue;
+		emittedTargets.add(assoc.targetModel);
 		const targetModule = toModuleName(assoc.targetModel);
 		impls.push([
 			`impl Related<super::${targetModule}::Entity> for Entity {`,
@@ -3049,7 +3166,8 @@ function generateRelatedImpls(model, associations) {
 		].join("\n"));
 	}
 	for (const assoc of associations.hasOne) {
-		if (m2mTargets.has(assoc.targetModel)) continue;
+		if (emittedTargets.has(assoc.targetModel)) continue;
+		emittedTargets.add(assoc.targetModel);
 		const targetModule = toModuleName(assoc.targetModel);
 		impls.push([
 			`impl Related<super::${targetModule}::Entity> for Entity {`,
@@ -3060,6 +3178,8 @@ function generateRelatedImpls(model, associations) {
 		].join("\n"));
 	}
 	for (const assoc of associations.manyToMany) {
+		if (emittedTargets.has(assoc.targetModel)) continue;
+		emittedTargets.add(assoc.targetModel);
 		const targetModule = toModuleName(assoc.targetModel);
 		const [leftName, rightName] = model.name < assoc.targetModel ? [model.name, assoc.targetModel] : [assoc.targetModel, model.name];
 		const junctionModule = toSnakeCase(`${leftName}To${rightName}`);
@@ -3089,15 +3209,21 @@ function generateEntityFile(model, allModels, enums, serde = {}) {
 	const scalarFields = model.fields.filter((f) => f.kind !== "object");
 	const fieldLines = [];
 	for (const field of scalarFields) {
-		const attrs = buildSeaOrmAttributes(field, field.isId || compositePkFieldNames.has(field.name), isCompositePk);
-		const rustType = enumNames.has(field.type) ? field.isRequired ? field.type : `Option<${field.type}>` : prismaTypeToRustType(field.type, field.isRequired);
-		const fieldName = toSnakeCase(field.name);
+		const isPk = field.isId || compositePkFieldNames.has(field.name);
+		const { ident: fieldName, derivedColumn } = rustFieldIdent(toSnakeCase(field.name));
+		const attrs = buildSeaOrmAttributes(field, isPk, isCompositePk, derivedColumn);
+		const elemType = enumNames.has(field.type) ? field.type : prismaTypeToRustType(field.type, true);
+		const rustType = field.isList ? `Vec<${elemType}>` : enumNames.has(field.type) ? field.isRequired ? field.type : `Option<${field.type}>` : prismaTypeToRustType(field.type, field.isRequired);
 		for (const attr of attrs) fieldLines.push(`    ${attr}`);
 		fieldLines.push(`    pub ${fieldName}: ${rustType},`);
 	}
 	const relationEnum = generateRelationEnum(model, associations);
 	const relatedImpls = generateRelatedImpls(model, associations);
-	const useLines = ["use sea_orm::entity::prelude::*;", "use serde::{Deserialize, Serialize};"];
+	const useLines = [
+		"use sea_orm::entity::prelude::*;",
+		"use serde::{Deserialize, Serialize};",
+		...[...new Set(scalarFields.filter((f) => enumNames.has(f.type)).map((f) => f.type))].sort().map((name) => `use super::${toSnakeCase(name)}::${name};`)
+	];
 	const deriveModel = canDeriveEq(scalarFields) ? "#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel, Serialize, Deserialize)]" : "#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Serialize, Deserialize)]";
 	const serdeAttrs = buildSerdeAttributes(serde);
 	return [
@@ -3253,7 +3379,7 @@ const PRISMA_TO_PYTHON = {
 	Decimal: "Decimal",
 	Boolean: "bool",
 	DateTime: "datetime",
-	Json: "dict",
+	Json: "dict[str, Any]",
 	Bytes: "bytes"
 };
 const PRISMA_TO_SQLALCHEMY = {
@@ -3273,6 +3399,46 @@ function prismaTypeToSQLAlchemyType(type) {
 function prismaTypeToPythonType(type) {
 	return PRISMA_TO_PYTHON[type] ?? "str";
 }
+const PYTHON_KEYWORDS = /* @__PURE__ */ new Set([
+	"False",
+	"None",
+	"True",
+	"and",
+	"as",
+	"assert",
+	"async",
+	"await",
+	"break",
+	"class",
+	"continue",
+	"def",
+	"del",
+	"elif",
+	"else",
+	"except",
+	"finally",
+	"for",
+	"from",
+	"global",
+	"if",
+	"import",
+	"in",
+	"is",
+	"lambda",
+	"nonlocal",
+	"not",
+	"or",
+	"pass",
+	"raise",
+	"return",
+	"try",
+	"while",
+	"with",
+	"yield"
+]);
+function pythonAttrName(columnName) {
+	return PYTHON_KEYWORDS.has(columnName) ? `${columnName}_` : columnName;
+}
 function resolveNativeType(field) {
 	const baseType = prismaTypeToSQLAlchemyType(field.type);
 	if (!field.nativeType) return baseType;
@@ -3431,16 +3597,18 @@ function isAutoincrement(field) {
 function needsForeignKeysParam(targetModel, assocs) {
 	return assocs.filter((a) => a.targetModel === targetModel).length > 1;
 }
-function findBackPopulates(targetModelName, sourceModelName, foreignKey, allModels) {
+function findBackPopulates(targetModelName, sourceModelName, foreignKey, allModels, sourceFieldName) {
 	const targetModel = allModels.find((m) => m.name === targetModelName);
+	const sourceModel = allModels.find((m) => m.name === sourceModelName);
 	if (!targetModel) return makeSnakeCase(sourceModelName);
+	const relationName = (sourceModel?.fields.find((f) => f.kind === "object" && f.name === sourceFieldName))?.relationName;
 	const backField = targetModel.fields.find((f) => {
 		if (f.kind !== "object") return false;
 		if (f.type !== sourceModelName) return false;
+		if (targetModelName === sourceModelName && f.name === sourceFieldName) return false;
+		if (relationName !== void 0) return f.relationName === relationName;
 		if (f.relationFromFields?.includes(foreignKey)) return true;
-		const sourceModel = allModels.find((m) => m.name === sourceModelName);
-		if (!sourceModel) return false;
-		return sourceModel.fields.some((sf) => sf.relationName === f.relationName && sf.relationFromFields && sf.relationFromFields.includes(foreignKey));
+		return sourceModel ? sourceModel.fields.some((sf) => sf.relationName === f.relationName && sf.relationFromFields?.includes(foreignKey)) : false;
 	});
 	return backField ? makeSnakeCase(backField.name) : makeSnakeCase(sourceModelName);
 }
@@ -3451,15 +3619,19 @@ function findM2MBackPopulates(targetModelName, sourceModelName, relationName, al
 	return backField ? makeSnakeCase(backField.name) : makeSnakeCase(sourceModelName);
 }
 function generateColumn(field, isPk, isFk, associations, allModels, enumMap) {
-	const snakeName = field.dbName ?? makeSnakeCase(field.name);
-	const pythonType = field.kind === "enum" ? "str" : pythonTypeForNative(field);
-	const typeHint = field.isRequired ? pythonType : `Optional[${pythonType}]`;
+	const columnName = field.dbName ?? makeSnakeCase(field.name);
+	const attrName = pythonAttrName(columnName);
+	const elemPythonType = field.kind === "enum" ? "str" : pythonTypeForNative(field);
+	const pythonType = field.isList ? `list[${elemPythonType}]` : elemPythonType;
+	const typeHint = field.isList || field.isRequired ? pythonType : `Optional[${pythonType}]`;
 	const colArgs = [];
+	if (attrName !== columnName) colArgs.push(`"${columnName}"`);
 	if (field.kind === "enum") {
 		const values = enumMap.get(field.type);
-		const valuesStr = values ? values.map((v) => `"${v}"`).join(", ") : "";
-		colArgs.push(`Enum(${valuesStr}, name="${makeSnakeCase(field.type)}")`);
-	} else if (needsExplicitSaType(field)) colArgs.push(resolveNativeType(field));
+		const enumType = `Enum(${values ? values.map((v) => `"${v}"`).join(", ") : ""}, name="${makeSnakeCase(field.type)}")`;
+		colArgs.push(field.isList ? `ARRAY(${enumType})` : enumType);
+	} else if (field.isList) colArgs.push(`ARRAY(${prismaTypeToSQLAlchemyType(field.type)})`);
+	else if (needsExplicitSaType(field)) colArgs.push(resolveNativeType(field));
 	if (isFk) {
 		const assoc = associations.belongsTo.find((a) => a.foreignKey === field.name);
 		if (assoc) {
@@ -3477,8 +3649,8 @@ function generateColumn(field, isPk, isFk, associations, allModels, enumMap) {
 		if (defaultVal !== null && !isPk) colArgs.push(`default=${defaultVal}`);
 	}
 	if (field.isUpdatedAt) colArgs.push("onupdate=func.now()");
-	if (colArgs.length === 0) return `    ${snakeName}: Mapped[${typeHint}]`;
-	return `    ${snakeName}: Mapped[${typeHint}] = mapped_column(${colArgs.join(", ")})`;
+	if (colArgs.length === 0) return `    ${attrName}: Mapped[${typeHint}]`;
+	return `    ${attrName}: Mapped[${typeHint}] = mapped_column(${colArgs.join(", ")})`;
 }
 function generateTableArgs(model, indexes) {
 	const uniqueConstraints = model.uniqueFields.map((fields) => {
@@ -3504,15 +3676,17 @@ function generateBelongsToRelationships(associations, model, allModels) {
 	return associations.belongsTo.map((assoc) => {
 		const snakeName = makeSnakeCase(assoc.name);
 		const snakeFk = model.fields.find((f) => f.name === assoc.foreignKey)?.dbName ?? makeSnakeCase(assoc.foreignKey);
-		const backPop = findBackPopulates(assoc.targetModel, model.name, assoc.foreignKey, allModels);
+		const backPop = findBackPopulates(assoc.targetModel, model.name, assoc.foreignKey, allModels, assoc.name);
 		const fkClause = needsForeignKeysParam(assoc.targetModel, associations.belongsTo) ? `foreign_keys=[${snakeFk}], ` : "";
-		return `    ${snakeName}: Mapped["${assoc.targetModel}"] = relationship(${fkClause}back_populates="${backPop}")`;
+		const pkField = model.fields.find((f) => f.isId);
+		const remoteClause = assoc.targetModel === model.name && pkField ? `remote_side=[${pkField.dbName ?? makeSnakeCase(pkField.name)}], ` : "";
+		return `    ${snakeName}: Mapped["${assoc.targetModel}"] = relationship(${remoteClause}${fkClause}back_populates="${backPop}")`;
 	});
 }
 function generateHasManyRelationships(associations, model, allModels) {
 	return associations.hasMany.map((assoc) => {
 		const snakeName = makeSnakeCase(assoc.name);
-		const backPop = findBackPopulates(assoc.targetModel, model.name, assoc.foreignKey, allModels);
+		const backPop = findBackPopulates(assoc.targetModel, model.name, assoc.foreignKey, allModels, assoc.name);
 		const targetModel = allModels.find((m) => m.name === assoc.targetModel);
 		const needsFkParam = targetModel ? needsForeignKeysParam(model.name, getAssociations(targetModel, allModels).belongsTo) : false;
 		const targetFkSnake = makeSnakeCase(assoc.foreignKey);
@@ -3523,7 +3697,7 @@ function generateHasManyRelationships(associations, model, allModels) {
 function generateHasOneRelationships(associations, model, allModels) {
 	return associations.hasOne.map((assoc) => {
 		const snakeName = makeSnakeCase(assoc.name);
-		const backPop = findBackPopulates(assoc.targetModel, model.name, assoc.foreignKey, allModels);
+		const backPop = findBackPopulates(assoc.targetModel, model.name, assoc.foreignKey, allModels, assoc.name);
 		const targetModel = allModels.find((m) => m.name === assoc.targetModel);
 		const needsFkParam = targetModel ? needsForeignKeysParam(model.name, getAssociations(targetModel, allModels).belongsTo) : false;
 		const targetFkSnake = makeSnakeCase(assoc.foreignKey);
@@ -3575,6 +3749,8 @@ function collectGlobalImports(models, _enums, indexes, m2mTables) {
 	const needsOptional = models.some((m) => m.fields.some((f) => f.kind !== "object" && !f.isRequired));
 	const hasRelationship = models.some((m) => m.fields.some((f) => f.kind === "object"));
 	const needsFunc = models.some((m) => m.fields.some((f) => f.type === "DateTime" && isFunctionDefault(f.default) && f.default.name === "now" || f.isUpdatedAt));
+	const needsAny = models.some((m) => m.fields.some((f) => f.type === "Json"));
+	const needsArray = models.some((m) => m.fields.some((f) => f.kind !== "object" && f.isList));
 	const needsDecimal = models.some((m) => m.fields.some((f) => f.type === "Decimal"));
 	const needsDatetime = models.some((m) => m.fields.some((f) => f.type === "DateTime"));
 	const needsUuid = models.some((m) => m.fields.some((f) => {
@@ -3599,6 +3775,7 @@ function collectGlobalImports(models, _enums, indexes, m2mTables) {
 				saImports.add("Enum");
 				continue;
 			}
+			if (field.isList) saImports.add(prismaTypeToSQLAlchemyType(field.type));
 			if (needsExplicitSaType(field)) {
 				const resolved = resolveNativeType(field);
 				saImports.add(resolved.replace(/\(.*\)$/, ""));
@@ -3624,6 +3801,7 @@ function collectGlobalImports(models, _enums, indexes, m2mTables) {
 		}
 	}
 	if (needsFunc) saImports.add("func");
+	if (needsArray) saImports.add("ARRAY");
 	const lines = [];
 	const sortedSa = [...saImports].sort();
 	if (sortedSa.length > 0) lines.push(`from sqlalchemy import ${sortedSa.join(", ")}`);
@@ -3634,7 +3812,8 @@ function collectGlobalImports(models, _enums, indexes, m2mTables) {
 	];
 	if (hasRelationship) ormImports.push("relationship");
 	lines.push(`from sqlalchemy.orm import ${ormImports.sort().join(", ")}`);
-	if (needsOptional) lines.push("from typing import Optional");
+	const typingImports = [needsAny ? "Any" : null, needsOptional ? "Optional" : null].filter((i) => i !== null);
+	if (typingImports.length > 0) lines.push(`from typing import ${typingImports.join(", ")}`);
 	if (needsDecimal) lines.push("from decimal import Decimal as DecimalType");
 	const dtParts = [];
 	if (needsDatetime) dtParts.push("datetime");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hekireki",
-  "version": "0.8.6",
+  "version": "0.9.1",
   "description": "Hekireki is a tool that generates validation schemas for Zod, Valibot, ArkType, and Effect Schema, as well as ER diagrams and DBML, from Prisma schemas annotated with comments.",
   "keywords": [
     "ajv",
@@ -51,26 +51,24 @@
     "dist"
   ],
   "type": "module",
-  "publishConfig": {
-    "access": "public"
-  },
   "dependencies": {
     "@hono/node-server": "^2.0.6",
     "@prisma/generator-helper": "^7.8.0",
     "@resvg/resvg-js": "^2.6.2",
     "@softwaretechnik/dbml-renderer": "^1.0.31",
     "hono": "^4.12.27",
-    "oxfmt": "^0.56.0"
+    "oxfmt": "^0.57.0"
   },
   "devDependencies": {
     "@paralleldrive/cuid2": "^3.3.0",
     "@prisma/client": "^7.8.0",
     "@sinclair/typebox": "^0.34.49",
-    "@types/node": "^26.0.1",
-    "@typescript/native-preview": "7.0.0-dev.20260624.1",
+    "@types/node": "^26.1.0",
+    "@typescript/native-preview": "7.0.0-dev.20260701.1",
     "ajv": "^8.20.0",
-    "arktype": "^2.2.1",
-    "better-auth": "^1.6.20",
+    "arktype": "^2.2.2",
+    "better-auth": "^1.6.23",
+    "cuid": "^3.0.0",
     "drizzle-kit": "^0.31.10",
     "drizzle-orm": "^0.45.2",
     "effect": "^3.21.4",
@@ -79,13 +77,13 @@
     "tsdown": "^0.22.3",
     "tsx": "^4.22.4",
     "typescript": "^6.0.3",
-    "valibot": "1.4.1",
+    "valibot": "1.4.2",
     "zod": "^4.4.3"
   },
   "scripts": {
     "generate": "prisma generate",
     "deps": "rm -rf node_modules && pnpm install",
     "build": "tsdown",
-    "release": "npm pkg fix && pnpm build && npm publish"
+    "conformance": "pnpm build && bash conformance/check.sh"
   }
 }