hekireki 0.7.0 → 0.7.2

package/dist/generator/sea-orm/index.js

@@ -0,0 +1,444 @@
+#!/usr/bin/env node
+import { d as mkdir, f as writeFile, n as getString, o as makeSnakeCase } from "../../utils-COHZyQue.js";
+import { join } from "node:path";
+import pkg from "@prisma/generator-helper";
+
+//#region src/helper/sea-orm.ts
+const PRISMA_TO_RUST = {
+	String: "String",
+	Int: "i32",
+	BigInt: "i64",
+	Float: "f64",
+	Decimal: "Decimal",
+	Boolean: "bool",
+	DateTime: "DateTimeUtc",
+	Json: "Json",
+	Bytes: "Vec<u8>"
+};
+function prismaTypeToRustType(type, isRequired) {
+	const base = PRISMA_TO_RUST[type] ?? "String";
+	if (!isRequired) return `Option<${base}>`;
+	return base;
+}
+function resolveSeaOrmColumnType(field) {
+	if (!field.nativeType) return null;
+	const [nativeName, nativeArgs] = field.nativeType;
+	const args = nativeArgs ?? [];
+	switch (nativeName) {
+		case "VarChar":
+		case "Char": return args.length > 0 ? `String(StringLen::N(${args[0]}))` : null;
+		case "Text":
+		case "MediumText":
+		case "LongText":
+		case "TinyText": return "Text";
+		case "SmallInt":
+		case "TinyInt": return "SmallInteger";
+		case "MediumInt": return "Integer";
+		case "DoublePrecision":
+		case "Double":
+		case "Real": return "Double";
+		case "Decimal":
+		case "Money": return args.length >= 2 ? `Decimal(Some((${args[0]}, ${args[1]})))` : "Decimal(None)";
+		case "Uuid": return "Uuid";
+		case "Timestamp":
+		case "Timestamptz": return "TimestampWithTimeZone";
+		case "Date": return "Date";
+		case "Time":
+		case "Timetz": return "Time";
+		case "JsonB": return "JsonBinary";
+		default: return null;
+	}
+}
+function isFunctionDefault(def) {
+	return def !== null && typeof def === "object" && "name" in def;
+}
+function isAutoincrement(field) {
+	return isFunctionDefault(field.default) && field.default.name === "autoincrement";
+}
+function formatRustDefault(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 buildSeaOrmAttributes(field, isPk, isCompositePk) {
+	const attrs = [];
+	if (isPk) {
+		const parts = ["primary_key"];
+		if (!isAutoincrement(field)) parts.push("auto_increment = false");
+		attrs.push(`#[sea_orm(${parts.join(", ")})]`);
+	}
+	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}"`);
+	const colType = resolveSeaOrmColumnType(field);
+	if (colType) columnParts.push(`column_type = "${colType}"`);
+	if (!isPk || isCompositePk) {
+		if (!(field.type === "DateTime" && isFunctionDefault(field.default) && field.default.name === "now" || field.isUpdatedAt)) {
+			const defaultVal = formatRustDefault(field.default);
+			if (defaultVal !== null) columnParts.push(`default_value = ${defaultVal}`);
+		}
+	}
+	if (columnParts.length > 0) attrs.push(`#[sea_orm(${columnParts.join(", ")})]`);
+	return attrs;
+}
+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 toSnakeCase(name) {
+	return makeSnakeCase(name);
+}
+function toPascalCase(name) {
+	return name.charAt(0).toUpperCase() + name.slice(1);
+}
+function toModuleName(modelName) {
+	return toSnakeCase(modelName);
+}
+const NON_EQ_PRISMA_TYPES = new Set(["Float"]);
+function canDeriveEq(fields) {
+	return fields.filter((f) => f.kind !== "object").every((f) => !NON_EQ_PRISMA_TYPES.has(f.type));
+}
+function buildSerdeAttributes(opts) {
+	const parts = [];
+	if (opts.renameAll) parts.push(`rename_all = "${opts.renameAll}"`);
+	if (parts.length === 0) return [];
+	return [`#[serde(${parts.join(", ")})]`];
+}
+function generateEnum(e, serde = {}) {
+	const variants = e.values.map((v) => {
+		const pascalName = v.name.charAt(0).toUpperCase() + v.name.slice(1).toLowerCase();
+		return `    #[sea_orm(string_value = "${v.name}")]\n    ${pascalName},`;
+	});
+	return [
+		"#[derive(Debug, Clone, PartialEq, Eq, EnumIter, DeriveActiveEnum, Serialize, Deserialize)]",
+		...buildSerdeAttributes(serde),
+		"#[sea_orm(rs_type = \"String\", db_type = \"String(StringLen::None)\")]",
+		`pub enum ${e.name} {`,
+		...variants,
+		"}"
+	].join("\n");
+}
+function generateRelationEnum(_model, associations) {
+	if (!(associations.belongsTo.length > 0 || associations.hasMany.length > 0 || associations.hasOne.length > 0)) return ["#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]", "pub enum Relation {}"].join("\n");
+	const variants = [];
+	for (const assoc of associations.belongsTo) {
+		const variantName = toPascalCase(assoc.name);
+		const targetModule = toModuleName(assoc.targetModel);
+		const fromCol = toPascalCase(assoc.foreignKey);
+		const toCol = toPascalCase(assoc.references);
+		variants.push(`    #[sea_orm(\n        belongs_to = "super::${targetModule}::Entity",\n        from = "Column::${fromCol}",\n        to = "super::${targetModule}::Column::${toCol}"\n    )]\n    ${variantName},`);
+	}
+	for (const assoc of associations.hasMany) {
+		const variantName = toPascalCase(assoc.name);
+		const targetModule = toModuleName(assoc.targetModel);
+		variants.push(`    #[sea_orm(has_many = "super::${targetModule}::Entity")]\n    ${variantName},`);
+	}
+	for (const assoc of associations.hasOne) {
+		const variantName = toPascalCase(assoc.name);
+		const targetModule = toModuleName(assoc.targetModel);
+		variants.push(`    #[sea_orm(has_one = "super::${targetModule}::Entity")]\n    ${variantName},`);
+	}
+	return [
+		"#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]",
+		"pub enum Relation {",
+		...variants,
+		"}"
+	].join("\n");
+}
+function generateRelatedImpls(model, associations) {
+	const impls = [];
+	const m2mTargets = new Set(associations.manyToMany.map((a) => a.targetModel));
+	for (const assoc of associations.belongsTo) {
+		if (m2mTargets.has(assoc.targetModel)) continue;
+		const targetModule = toModuleName(assoc.targetModel);
+		impls.push([
+			`impl Related<super::${targetModule}::Entity> for Entity {`,
+			"    fn to() -> RelationDef {",
+			`        Relation::${toPascalCase(assoc.name)}.def()`,
+			"    }",
+			"}"
+		].join("\n"));
+	}
+	for (const assoc of associations.hasMany) {
+		if (m2mTargets.has(assoc.targetModel)) continue;
+		const targetModule = toModuleName(assoc.targetModel);
+		impls.push([
+			`impl Related<super::${targetModule}::Entity> for Entity {`,
+			"    fn to() -> RelationDef {",
+			`        Relation::${toPascalCase(assoc.name)}.def()`,
+			"    }",
+			"}"
+		].join("\n"));
+	}
+	for (const assoc of associations.hasOne) {
+		if (m2mTargets.has(assoc.targetModel)) continue;
+		const targetModule = toModuleName(assoc.targetModel);
+		impls.push([
+			`impl Related<super::${targetModule}::Entity> for Entity {`,
+			"    fn to() -> RelationDef {",
+			`        Relation::${toPascalCase(assoc.name)}.def()`,
+			"    }",
+			"}"
+		].join("\n"));
+	}
+	for (const assoc of associations.manyToMany) {
+		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}`);
+		const junctionRelToTarget = toPascalCase(assoc.targetModel);
+		const junctionRelToSelf = toPascalCase(model.name);
+		impls.push([
+			`impl Related<super::${targetModule}::Entity> for Entity {`,
+			"    fn to() -> RelationDef {",
+			`        super::${junctionModule}::Relation::${junctionRelToTarget}.def()`,
+			"    }",
+			"    fn via() -> Option<RelationDef> {",
+			`        Some(super::${junctionModule}::Relation::${junctionRelToSelf}.def().rev())`,
+			"    }",
+			"}"
+		].join("\n"));
+	}
+	return impls;
+}
+function generateEntityFile(model, allModels, enums, serde = {}) {
+	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 "";
+	const tableName = model.dbName ?? toSnakeCase(model.name);
+	const associations = getAssociations(model, allModels);
+	const enumNames = new Set(enums.map((e) => e.name));
+	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);
+		let rustType;
+		if (enumNames.has(field.type)) rustType = field.isRequired ? field.type : `Option<${field.type}>`;
+		else rustType = prismaTypeToRustType(field.type, field.isRequired);
+		const fieldName = toSnakeCase(field.name);
+		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 deriveModel = canDeriveEq(scalarFields) ? "#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel, Serialize, Deserialize)]" : "#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Serialize, Deserialize)]";
+	const serdeAttrs = buildSerdeAttributes(serde);
+	return [
+		...useLines,
+		"",
+		deriveModel,
+		...serdeAttrs,
+		`#[sea_orm(table_name = "${tableName}")]`,
+		"pub struct Model {",
+		...fieldLines,
+		"}",
+		"",
+		relationEnum,
+		"",
+		...relatedImpls.map((impl) => `${impl}\n`),
+		"impl ActiveModelBehavior for ActiveModel {}"
+	].join("\n");
+}
+function generateM2MEntity(leftModel, rightModel, _allModels, serde = {}) {
+	const [sortedLeft, sortedRight] = leftModel < rightModel ? [leftModel, rightModel] : [rightModel, leftModel];
+	const tableName = `_${sortedLeft}To${sortedRight}`;
+	const leftModule = toModuleName(sortedLeft);
+	const rightModule = toModuleName(sortedRight);
+	const leftFk = `${toSnakeCase(sortedLeft)}_id`;
+	const rightFk = `${toSnakeCase(sortedRight)}_id`;
+	const leftCol = toPascalCase(`${toSnakeCase(sortedLeft)}Id`);
+	const rightCol = toPascalCase(`${toSnakeCase(sortedRight)}Id`);
+	const useLines = ["use sea_orm::entity::prelude::*;", "use serde::{Deserialize, Serialize};"];
+	const deriveModel = "#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel, Serialize, Deserialize)]";
+	const serdeAttrs = buildSerdeAttributes(serde);
+	return [
+		...useLines,
+		"",
+		deriveModel,
+		...serdeAttrs,
+		`#[sea_orm(table_name = "${tableName}")]`,
+		"pub struct Model {",
+		"    #[sea_orm(primary_key, auto_increment = false)]",
+		`    pub ${leftFk}: String,`,
+		"    #[sea_orm(primary_key, auto_increment = false)]",
+		`    pub ${rightFk}: String,`,
+		"}",
+		"",
+		"#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]",
+		"pub enum Relation {",
+		"    #[sea_orm(",
+		`        belongs_to = "super::${leftModule}::Entity",`,
+		`        from = "Column::${leftCol}",`,
+		`        to = "super::${leftModule}::Column::Id"`,
+		"    )]",
+		`    ${sortedLeft},`,
+		"    #[sea_orm(",
+		`        belongs_to = "super::${rightModule}::Entity",`,
+		`        from = "Column::${rightCol}",`,
+		`        to = "super::${rightModule}::Column::Id"`,
+		"    )]",
+		`    ${sortedRight},`,
+		"}",
+		"",
+		"impl ActiveModelBehavior for ActiveModel {}"
+	].join("\n");
+}
+function generateModRs(moduleNames) {
+	return `${moduleNames.map((m) => `pub mod ${m};`).join("\n")}\n`;
+}
+function generatePreludeRs(models) {
+	return `${models.map((m) => {
+		return `pub use super::${toModuleName(m.name)}::Entity as ${m.name};`;
+	}).join("\n")}\n`;
+}
+async function writeSeaOrmFiles(models, outDir, enums, serde = {}) {
+	const mkdirResult = await mkdir(outDir);
+	if (!mkdirResult.ok) return mkdirResult;
+	const moduleNames = [];
+	const m2mJunctions = /* @__PURE__ */ new Set();
+	const m2mPairs = [];
+	for (const model of models) {
+		const associations = getAssociations(model, models);
+		for (const assoc of associations.manyToMany) {
+			const [left, right] = model.name < assoc.targetModel ? [model.name, assoc.targetModel] : [assoc.targetModel, model.name];
+			const key = `${left}_${right}`;
+			if (!m2mJunctions.has(key)) {
+				m2mJunctions.add(key);
+				m2mPairs.push({
+					left,
+					right
+				});
+			}
+		}
+	}
+	for (const e of enums) {
+		const moduleName = toSnakeCase(e.name);
+		const code = [
+			...["use sea_orm::entity::prelude::*;", "use serde::{Deserialize, Serialize};"],
+			"",
+			generateEnum(e, serde),
+			""
+		].join("\n");
+		const filePath = join(outDir, `${moduleName}.rs`);
+		const writeResult = await writeFile(filePath, code);
+		if (!writeResult.ok) return writeResult;
+		moduleNames.push(moduleName);
+		console.log(`wrote ${filePath}`);
+	}
+	for (const model of models) {
+		const code = generateEntityFile(model, models, enums, serde);
+		if (!code.trim()) continue;
+		const moduleName = toModuleName(model.name);
+		const filePath = join(outDir, `${moduleName}.rs`);
+		const writeResult = await writeFile(filePath, code);
+		if (!writeResult.ok) return writeResult;
+		moduleNames.push(moduleName);
+		console.log(`wrote ${filePath}`);
+	}
+	for (const pair of m2mPairs) {
+		const moduleName = toSnakeCase(`${pair.left}To${pair.right}`);
+		const code = generateM2MEntity(pair.left, pair.right, models, serde);
+		const filePath = join(outDir, `${moduleName}.rs`);
+		const writeResult = await writeFile(filePath, code);
+		if (!writeResult.ok) return writeResult;
+		moduleNames.push(moduleName);
+		console.log(`wrote ${filePath}`);
+	}
+	const preludeCode = generatePreludeRs(models);
+	const preludePath = join(outDir, "prelude.rs");
+	const preludeResult = await writeFile(preludePath, preludeCode);
+	if (!preludeResult.ok) return preludeResult;
+	moduleNames.push("prelude");
+	console.log(`wrote ${preludePath}`);
+	moduleNames.sort();
+	const modCode = generateModRs(moduleNames);
+	const modPath = join(outDir, "mod.rs");
+	const modResult = await writeFile(modPath, modCode);
+	if (!modResult.ok) return modResult;
+	console.log(`wrote ${modPath}`);
+	return {
+		ok: true,
+		value: void 0
+	};
+}
+
+//#endregion
+//#region src/generator/sea-orm/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-SeaORM. Please specify output in your generator config.");
+	const output = options.generator.output.value;
+	const serde = { renameAll: getString(options.generator.config?.renameAll) };
+	const enums = options.dmmf.datamodel.enums;
+	const result = await writeSeaOrmFiles(options.dmmf.datamodel.models, output, enums, serde);
+	if (!result.ok) throw new Error(`Failed to write SeaORM entities: ${result.error}`);
+}
+generatorHandler({
+	onManifest() {
+		return {
+			defaultOutput: ".",
+			prettyName: "Hekireki-SeaORM"
+		};
+	},
+	onGenerate: main
+});
+
+//#endregion
+export { main };

package/dist/generator/sqlalchemy/index.d.ts

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