hekireki 0.8.5 → 0.9.0

package/README.md

@@ -530,6 +530,26 @@ export const postRelations = relations(post, ({ one }) => ({
 }))
 ```
 
+#### ID default functions
+
+For Drizzle, Prisma `@default(...)` ID generators are emitted as client-side `$defaultFn` calls. Some require an extra package — install it in your project:
+
+| Prisma default                           | Generated call        | Package to install                             |
+| ---------------------------------------- | --------------------- | ---------------------------------------------- |
+| `@default(uuid())` / `@default(uuid(4))` | `crypto.randomUUID()` | — (Node/Web built-in)                          |
+| `@default(cuid())` / `@default(cuid(1))` | `cuid()`              | `npm i cuid`                                   |
+| `@default(cuid(2))`                      | `createId()`          | `npm i @paralleldrive/cuid2`                   |
+| `@default(nanoid())`                     | `nanoid()`            | `npm i nanoid` (>= 5.0.9, or >= 3.3.8 for CJS) |
+| `@default(ulid())`                       | `ulid()`              | `npm i ulidx`                                  |
+
+Notes:
+
+- **`cuid()` uses cuid v1**, which its author has deprecated in favor of cuid v2 ([npm `cuid`](https://www.npmjs.com/package/cuid)). It is emitted only when you explicitly write `@default(cuid())`; for new schemas prefer `@default(cuid(2))`.
+- **`ulid()` maps to [`ulidx`](https://www.npmjs.com/package/ulidx)** (an actively maintained, crypto-backed drop-in for `ulid`).
+- `@default(uuid(7))` is currently emitted as `crypto.randomUUID()` (UUID v4); native v7 support is planned.
+- `@default(nanoid(n))` length argument is not yet applied — the default length is used.
+- Inserts that bypass the ORM (raw SQL, bulk load) won't run `$defaultFn`; add a database-level `DEFAULT` for those paths.
+
 ### Mermaid
 
 ```mermaid

package/dist/bin/ajv.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as registerGenerator } from "../bin-Dcg9ZO7c.js";
+import { t as registerGenerator } from "../bin-Dh-MFTeu.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-Dcg9ZO7c.js";
+import { t as registerGenerator } from "../bin-Dh-MFTeu.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-Dcg9ZO7c.js";
+import { t as registerGenerator } from "../bin-Dh-MFTeu.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-Dcg9ZO7c.js";
+import { t as registerGenerator } from "../bin-Dh-MFTeu.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-Dcg9ZO7c.js";
+import { t as registerGenerator } from "../bin-Dh-MFTeu.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-Dcg9ZO7c.js";
+import { t as registerGenerator } from "../bin-Dh-MFTeu.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-Dcg9ZO7c.js";
+import { t as registerGenerator } from "../bin-Dh-MFTeu.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-Dcg9ZO7c.js";
+import { t as registerGenerator } from "../bin-Dh-MFTeu.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-Dcg9ZO7c.js";
+import { t as registerGenerator } from "../bin-Dh-MFTeu.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-Dcg9ZO7c.js";
+import { t as registerGenerator } from "../bin-Dh-MFTeu.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-Dcg9ZO7c.js";
+import { t as registerGenerator } from "../bin-Dh-MFTeu.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-Dcg9ZO7c.js";
+import { t as registerGenerator } from "../bin-Dh-MFTeu.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-Dcg9ZO7c.js";
+import { t as registerGenerator } from "../bin-Dh-MFTeu.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-Dcg9ZO7c.js";
+import { t as registerGenerator } from "../bin-Dh-MFTeu.js";
 //#region src/bin/zod.ts
 registerGenerator("zod");
 //#endregion

package/dist/{bin-Dcg9ZO7c.js → bin-Dh-MFTeu.js}

@@ -163,7 +163,7 @@ function parseDocumentWithoutAnnotations(documentation) {
 		"@t.",
 		"@j."
 	];
-	const annotationExact = new Set([
+	const annotationExact = /* @__PURE__ */ new Set([
 		"@z",
 		"@v",
 		"@a",
@@ -183,7 +183,7 @@ function stripAnnotations(doc) {
 		"@t.",
 		"@j."
 	];
-	const annotationExact = new Set([
+	const annotationExact = /* @__PURE__ */ new Set([
 		"@z",
 		"@v",
 		"@a",
@@ -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
@@ -1067,7 +1069,7 @@ const ModelAction = {
 function isFieldDefault$1(v) {
 	return typeof v === "object" && v !== null && "name" in v && "args" in v;
 }
-const fieldDirectiveMap = new Map([
+const fieldDirectiveMap = /* @__PURE__ */ new Map([
 	["isUnique", "@unique"],
 	["isId", "@id"],
 	["hasDefaultValue", "@default"],
@@ -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
@@ -1761,17 +1765,29 @@ function createImports() {
 		ext: /* @__PURE__ */ new Map()
 	};
 }
-function addExternal(imports, pkg, fn) {
-	const fns = imports.ext.get(pkg) ?? /* @__PURE__ */ new Set();
-	fns.add(fn);
-	imports.ext.set(pkg, fns);
+function applyImport(imports, req) {
+	if (req.pkg === "drizzle-orm") {
+		imports.orm.add(req.name);
+		return;
+	}
+	const entry = imports.ext.get(req.pkg) ?? { named: /* @__PURE__ */ new Set() };
+	const next = req.kind === "default" ? {
+		named: entry.named,
+		default: req.name
+	} : {
+		named: entry.named.add(req.name),
+		default: entry.default
+	};
+	imports.ext.set(req.pkg, next);
 }
 function generateImports(imports, provider) {
 	const mod = provider === "postgresql" ? "drizzle-orm/pg-core" : provider === "mysql" ? "drizzle-orm/mysql-core" : "drizzle-orm/sqlite-core";
 	return [
 		imports.core.size > 0 ? `import { ${[...imports.core].sort().join(", ")} } from '${mod}'` : "",
 		imports.orm.size > 0 ? `import { ${[...imports.orm].sort().join(", ")} } from 'drizzle-orm'` : "",
-		...[...imports.ext.entries()].map(([pkg, fns]) => `import { ${[...fns].sort().join(", ")} } from '${pkg}'`)
+		...[...imports.ext.entries()].map(([pkg, entry]) => {
+			return `import ${[entry.default, entry.named.size > 0 ? `{ ${[...entry.named].sort().join(", ")} }` : void 0].filter((c) => c !== void 0).join(", ")} from '${pkg}'`;
+		})
 	].filter(Boolean).join("\n");
 }
 function snakeToCamel(name) {
@@ -1790,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;
@@ -1804,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}])`;
@@ -1828,80 +1853,98 @@ function makeColumnExpr(field, provider, imports, enums) {
 	const rest = baseExpr.slice(parenIdx + 1);
 	return rest === ")" ? `${baseFnName}('${colName}')` : `${baseFnName}('${colName}', ${rest}`;
 }
+const SQL_IMPORT = {
+	pkg: "drizzle-orm",
+	kind: "named",
+	name: "sql"
+};
 function resolveDefaultValue(dflt, fieldType, provider) {
 	if (dflt === void 0 || dflt === null) return {
 		chain: "",
-		needsSql: false,
-		needsCuid: false
+		imports: []
 	};
 	if (isFieldDefault(dflt)) switch (dflt.name) {
 		case "autoincrement": return {
 			chain: "",
-			needsSql: false,
-			needsCuid: false
+			imports: []
 		};
 		case "now":
 			if (provider === "sqlite") return {
 				chain: ".default(sql`(unixepoch() * 1000)`)",
-				needsSql: true,
-				needsCuid: false
+				imports: [SQL_IMPORT]
 			};
 			if (provider === "mysql") return {
 				chain: ".default(sql`CURRENT_TIMESTAMP(3)`)",
-				needsSql: true,
-				needsCuid: false
+				imports: [SQL_IMPORT]
 			};
 			return {
 				chain: ".defaultNow()",
-				needsSql: false,
-				needsCuid: false
+				imports: []
 			};
 		case "uuid": return {
 			chain: ".$defaultFn(() => crypto.randomUUID())",
-			needsSql: false,
-			needsCuid: false
+			imports: []
 		};
-		case "cuid": return {
+		case "cuid": return dflt.args[0] === 2 ? {
 			chain: ".$defaultFn(() => createId())",
-			needsSql: false,
-			needsCuid: true
+			imports: [{
+				pkg: "@paralleldrive/cuid2",
+				kind: "named",
+				name: "createId"
+			}]
+		} : {
+			chain: ".$defaultFn(() => cuid())",
+			imports: [{
+				pkg: "cuid",
+				kind: "default",
+				name: "cuid"
+			}]
+		};
+		case "nanoid": return {
+			chain: ".$defaultFn(() => nanoid())",
+			imports: [{
+				pkg: "nanoid",
+				kind: "named",
+				name: "nanoid"
+			}]
+		};
+		case "ulid": return {
+			chain: ".$defaultFn(() => ulid())",
+			imports: [{
+				pkg: "ulidx",
+				kind: "named",
+				name: "ulid"
+			}]
 		};
 		case "dbgenerated":
 			if (typeof dflt.args[0] === "string") return {
 				chain: `.default(sql\`${dflt.args[0]}\`)`,
-				needsSql: true,
-				needsCuid: false
+				imports: [SQL_IMPORT]
 			};
 			return {
 				chain: "",
-				needsSql: false,
-				needsCuid: false
+				imports: []
 			};
 		default: return {
 			chain: "",
-			needsSql: false,
-			needsCuid: false
+			imports: []
 		};
 	}
 	if (typeof dflt === "string") return {
 		chain: `.default('${dflt}')`,
-		needsSql: false,
-		needsCuid: false
+		imports: []
 	};
 	if (typeof dflt === "number") return {
 		chain: fieldType === "Decimal" ? `.default('${dflt}')` : `.default(${dflt})`,
-		needsSql: false,
-		needsCuid: false
+		imports: []
 	};
 	if (typeof dflt === "boolean") return {
 		chain: `.default(${dflt})`,
-		needsSql: false,
-		needsCuid: false
+		imports: []
 	};
 	return {
 		chain: "",
-		needsSql: false,
-		needsCuid: false
+		imports: []
 	};
 }
 function resolveUpdatedAtDefault(provider) {
@@ -1920,8 +1963,7 @@ function resolveUpdatedAtDefault(provider) {
 }
 function makeDefaultChain(dflt, fieldType, provider, imports) {
 	const result = resolveDefaultValue(dflt, fieldType, provider);
-	if (result.needsSql) imports.orm.add("sql");
-	if (result.needsCuid) addExternal(imports, "@paralleldrive/cuid2", "createId");
+	for (const req of result.imports) applyImport(imports, req);
 	return result.chain;
 }
 const PRISMA_ACTION_MAP = {
@@ -1948,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()" : "",
@@ -1957,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}`;
 }
@@ -2026,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]);
@@ -2033,6 +2076,7 @@ function drizzleSchema(datamodel, provider, indexes) {
 	return [
 		generateImports(imports, db),
 		"",
+		...enumLines.length > 0 ? [...enumLines, ""] : [],
 		...tableLinesWithGap,
 		...relationsLinesWithGap.length > 0 ? ["", ...relationsLinesWithGap] : []
 	].join("\n");
@@ -2169,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) {
@@ -2184,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;
@@ -2202,7 +2255,8 @@ function getAssociations$3(model, allModels) {
 	return {
 		belongsTo,
 		hasMany,
-		hasOne
+		hasOne,
+		manyToMany
 	};
 }
 function ectoSchemas(models, app, allModels, enums) {
@@ -2242,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__{",
@@ -2265,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})`;
@@ -2302,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",
@@ -2322,6 +2381,7 @@ function ectoSchemas(models, app, allModels, enums) {
 			...belongsToLines,
 			...hasOneLines,
 			...hasManyLines,
+			...manyToManyLines,
 			...timestampsLine ? [timestampsLine] : [],
 			"  end",
 			"end"
@@ -2532,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) {
@@ -2551,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,
@@ -2558,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]) => {
@@ -2574,7 +2637,7 @@ function collectCompositeIndexTags(model, indexes) {
 		return map;
 	}, /* @__PURE__ */ new Map());
 }
-const GO_INITIALISMS = new Set([
+const GO_INITIALISMS = /* @__PURE__ */ new Set([
 	"acl",
 	"api",
 	"ascii",
@@ -2630,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}` : ""}`;
 }
@@ -2646,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)}`] : []];
@@ -2654,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];
@@ -2678,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) ? [
@@ -2816,6 +2883,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;
@@ -2858,7 +2999,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"];
@@ -2868,7 +3009,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) {
@@ -2943,7 +3084,7 @@ function toPascalCase(name) {
 function toModuleName(modelName) {
 	return toSnakeCase(modelName);
 }
-const NON_EQ_PRISMA_TYPES = new Set(["Float"]);
+const NON_EQ_PRISMA_TYPES = /* @__PURE__ */ new Set(["Float"]);
 function canDeriveEq(fields) {
 	return fields.filter((f) => f.kind !== "object").every((f) => !NON_EQ_PRISMA_TYPES.has(f.type));
 }
@@ -2955,7 +3096,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 [
@@ -2996,9 +3137,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 {`,
@@ -3009,7 +3151,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 {`,
@@ -3020,7 +3163,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 {`,
@@ -3031,6 +3175,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}`);
@@ -3060,15 +3206,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 [
@@ -3224,7 +3376,7 @@ const PRISMA_TO_PYTHON = {
 	Decimal: "Decimal",
 	Boolean: "bool",
 	DateTime: "datetime",
-	Json: "dict",
+	Json: "dict[str, Any]",
 	Bytes: "bytes"
 };
 const PRISMA_TO_SQLALCHEMY = {
@@ -3244,6 +3396,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;
@@ -3402,16 +3594,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);
 }
@@ -3422,15 +3616,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) {
@@ -3448,8 +3646,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) => {
@@ -3475,15 +3673,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);
@@ -3494,7 +3694,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);
@@ -3546,6 +3746,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) => {
@@ -3570,6 +3772,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(/\(.*\)$/, ""));
@@ -3595,6 +3798,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(", ")}`);
@@ -3605,7 +3809,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.5",
+  "version": "0.9.0",
   "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,41 +51,39 @@
     "dist"
   ],
   "type": "module",
-  "publishConfig": {
-    "access": "public"
-  },
   "dependencies": {
-    "@hono/node-server": "^2.0.4",
+    "@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.25",
-    "oxfmt": "^0.54.0"
+    "hono": "^4.12.27",
+    "oxfmt": "^0.57.0"
   },
   "devDependencies": {
     "@paralleldrive/cuid2": "^3.3.0",
     "@prisma/client": "^7.8.0",
     "@sinclair/typebox": "^0.34.49",
-    "@types/node": "^25.9.3",
-    "@typescript/native-preview": "7.0.0-dev.20260611.2",
+    "@types/node": "^26.1.0",
+    "@typescript/native-preview": "7.0.0-dev.20260701.1",
     "ajv": "^8.20.0",
-    "arktype": "^2.2.0",
-    "better-auth": "^1.6.17",
+    "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.3",
+    "effect": "^3.21.4",
     "json-schema-to-ts": "^3.1.1",
     "prisma": "^7.8.0",
-    "tsdown": "^0.22.2",
+    "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"
   }
 }