hekireki 0.7.6 → 0.7.7

package/dist/generator/drizzle/index.js

@@ -5,6 +5,14 @@ import path from "node:path";
 import pkg from "@prisma/generator-helper";
 
 //#region src/helper/drizzle.ts
+function resolveDbProvider(provider) {
+	switch (provider) {
+		case "postgresql":
+		case "cockroachdb": return "postgresql";
+		case "mysql": return "mysql";
+		case "sqlite": return "sqlite";
+	}
+}
 const PG_SCALAR_MAP = {
 	String: "text()",
 	Int: "integer()",
@@ -97,34 +105,26 @@ function mysqlNativeType(name, args) {
 		default: return null;
 	}
 }
-var ImportTracker = class {
-	coreFns = /* @__PURE__ */ new Set();
-	ormFns = /* @__PURE__ */ new Set();
-	extPkgs = /* @__PURE__ */ new Map();
-	provider;
-	constructor(provider) {
-		this.provider = provider;
-	}
-	addCore(fn) {
-		this.coreFns.add(fn);
-	}
-	addOrm(fn) {
-		this.ormFns.add(fn);
-	}
-	addExternal(pkg, fn) {
-		const fns = this.extPkgs.get(pkg) ?? /* @__PURE__ */ new Set();
-		fns.add(fn);
-		this.extPkgs.set(pkg, fns);
-	}
-	generate() {
-		const mod = this.provider === "postgresql" ? "drizzle-orm/pg-core" : this.provider === "mysql" ? "drizzle-orm/mysql-core" : "drizzle-orm/sqlite-core";
-		return [
-			this.coreFns.size > 0 ? `import { ${[...this.coreFns].sort().join(", ")} } from '${mod}'` : "",
-			this.ormFns.size > 0 ? `import { ${[...this.ormFns].sort().join(", ")} } from 'drizzle-orm'` : "",
-			...[...this.extPkgs.entries()].map(([pkg, fns]) => `import { ${[...fns].sort().join(", ")} } from '${pkg}'`)
-		].filter(Boolean).join("\n");
-	}
-};
+function createImports() {
+	return {
+		core: /* @__PURE__ */ new Set(),
+		orm: /* @__PURE__ */ new Set(),
+		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 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}'`)
+	].filter(Boolean).join("\n");
+}
 function toCamelCase(name) {
 	return name.charAt(0).toLowerCase() + name.slice(1);
 }
@@ -146,23 +146,23 @@ function makeColumnExpr(field, provider, imports, enums) {
 		const enumDef = enums.find((e) => e.name === field.type);
 		const enumValues = enumDef ? enumDef.values.map((v) => `'${v.name}'`).join(", ") : "";
 		if (provider === "postgresql") {
-			imports.addCore("pgEnum");
+			imports.core.add("pgEnum");
 			return `pgEnum('${enumDef?.dbName ?? field.type}', [${enumValues}])('${colName}')`;
 		}
 		if (provider === "mysql") {
-			imports.addCore("mysqlEnum");
+			imports.core.add("mysqlEnum");
 			return `mysqlEnum('${colName}', [${enumValues}])`;
 		}
-		imports.addCore("text");
+		imports.core.add("text");
 		return `text('${colName}', { enum: [${enumValues}] })`;
 	}
 	if (isAutoincrement && provider === "postgresql") {
-		imports.addCore("serial");
+		imports.core.add("serial");
 		return `serial('${colName}')`;
 	}
 	const baseExpr = resolveScalarType(field, provider);
 	const fnName = baseExpr.match(/^(\w+)/)?.[1];
-	if (fnName) imports.addCore(fnName);
+	if (fnName) imports.core.add(fnName);
 	const parenIdx = baseExpr.indexOf("(");
 	if (parenIdx === -1) return baseExpr;
 	const baseFnName = baseExpr.slice(0, parenIdx);
@@ -261,8 +261,8 @@ function resolveUpdatedAtDefault(provider) {
 }
 function makeDefaultChain(dflt, fieldType, provider, imports) {
 	const result = resolveDefaultValue(dflt, fieldType, provider);
-	if (result.needsSql) imports.addOrm("sql");
-	if (result.needsCuid) imports.addExternal("@paralleldrive/cuid2", "createId");
+	if (result.needsSql) imports.orm.add("sql");
+	if (result.needsCuid) addExternal(imports, "@paralleldrive/cuid2", "createId");
 	return result.chain;
 }
 const PRISMA_ACTION_MAP = {
@@ -275,6 +275,7 @@ const PRISMA_ACTION_MAP = {
 function makeFkReference(field, model) {
 	const relField = model.fields.find((f) => f.kind === "object" && f.relationFromFields && f.relationFromFields.includes(field.name));
 	if (!(relField?.relationFromFields && relField.relationToFields)) return "";
+	if (relField.type === model.name) return "";
 	const targetVar = toCamelCase(relField.type);
 	const toCol = relField.relationToFields[0] ?? "id";
 	const onDelete = relField.relationOnDelete;
@@ -294,7 +295,7 @@ function makeColumn(field, model, provider, imports, enums) {
 		makeFkReference(field, model),
 		isAutoincrement ? provider === "mysql" ? ".autoincrement()" : "" : field.isUpdatedAt && (field.default === void 0 || field.default === null) ? (() => {
 			const r = resolveUpdatedAtDefault(provider);
-			if (r.needsSql) imports.addOrm("sql");
+			if (r.needsSql) imports.orm.add("sql");
 			return r.chain;
 		})() : makeDefaultChain(field.default, field.type, provider, imports),
 		field.isUpdatedAt ? ".$onUpdate(() => new Date())" : "",
@@ -304,15 +305,15 @@ function makeColumn(field, model, provider, imports, enums) {
 }
 function makeCompositeConstraints(model, imports, indexes, tableName) {
 	const pkLine = model.primaryKey ? (() => {
-		imports.addCore("primaryKey");
+		imports.core.add("primaryKey");
 		return `primaryKey({ columns: [${model.primaryKey.fields.map((f) => `table.${f}`).join(", ")}] })`;
 	})() : null;
 	const uniqueLines = model.uniqueFields.filter((fields) => fields.length > 1).map((fields) => {
-		imports.addCore("unique");
+		imports.core.add("unique");
 		return `unique().on(${fields.map((f) => `table.${f}`).join(", ")})`;
 	});
 	const indexLines = indexes.filter((idx) => idx.model === model.name && (idx.type === "normal" || idx.type === "fulltext")).map((idx) => {
-		imports.addCore("index");
+		imports.core.add("index");
 		return `index('${idx.dbName ?? idx.name ?? `idx_${tableName}_${idx.fields.map((f) => f.name).join("_")}`}').on(${idx.fields.map((f) => `table.${f.name}`).join(", ")})`;
 	});
 	const all = [
@@ -324,7 +325,7 @@ function makeCompositeConstraints(model, imports, indexes, tableName) {
 }
 function makeTable(model, provider, imports, enums, indexes) {
 	const tableFunc = provider === "postgresql" ? "pgTable" : provider === "mysql" ? "mysqlTable" : "sqliteTable";
-	imports.addCore(tableFunc);
+	imports.core.add(tableFunc);
 	const varName = toCamelCase(model.name);
 	const tableName = model.dbName ?? makeSnakeCase(model.name);
 	const columns = model.fields.map((field) => makeColumn(field, model, provider, imports, enums)).filter((c) => c !== null).join(", ");
@@ -351,7 +352,7 @@ function makeRelationField(field, model, _models, relFields) {
 function makeRelations(models, imports) {
 	const modelsWithRels = models.filter((model) => model.fields.some((f) => f.kind === "object"));
 	if (modelsWithRels.length === 0) return [];
-	imports.addOrm("relations");
+	imports.orm.add("relations");
 	return modelsWithRels.map((model) => {
 		const relFields = model.fields.filter((f) => f.kind === "object");
 		const fieldLines = relFields.map((field) => makeRelationField(field, model, models, relFields)).join(", ");
@@ -362,22 +363,14 @@ function makeRelations(models, imports) {
 	});
 }
 function drizzleSchema(datamodel, provider, indexes) {
-	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 db = resolveDbProvider(provider);
+	const imports = createImports();
 	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]);
 	const relationsLinesWithGap = relationsLines.flatMap((line, i) => i < relationsLines.length - 1 ? [line, ""] : [line]);
 	return [
-		imports.generate(),
+		generateImports(imports, db),
 		"",
 		...tableLinesWithGap,
 		...relationsLinesWithGap.length > 0 ? ["", ...relationsLinesWithGap] : []
@@ -387,6 +380,10 @@ function drizzleSchema(datamodel, provider, indexes) {
 //#endregion
 //#region src/generator/drizzle/index.ts
 const { generatorHandler } = pkg;
+function parsePrismaProvider(raw) {
+	if (raw === "postgresql" || raw === "cockroachdb" || raw === "mysql" || raw === "sqlite") return raw;
+	throw new Error(`Unsupported provider: ${raw}`);
+}
 async function main(options) {
 	if (!(options.generator.isCustomOutput && options.generator.output?.value)) throw new Error("output is required for Hekireki-Drizzle. Please specify output in your generator config.");
 	const output = options.generator.output.value;
@@ -397,7 +394,7 @@ async function main(options) {
 		dir: output,
 		file: path.join(output, "schema.ts")
 	};
-	const provider = options.datasources[0]?.activeProvider ?? "postgresql";
+	const provider = parsePrismaProvider(options.datasources[0]?.activeProvider ?? "postgresql");
 	const formatted = await fmt(drizzleSchema(options.dmmf.datamodel, provider, options.dmmf.datamodel.indexes));
 	await mkdir(resolved.dir);
 	await writeFile(resolved.file, formatted);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hekireki",
-  "version": "0.7.6",
+  "version": "0.7.7",
   "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",