hekireki 0.7.0 → 0.7.2

package/dist/generator/sqlalchemy/index.js

@@ -0,0 +1,458 @@
+#!/usr/bin/env node
+import { d as mkdir, f as writeFile, o as makeSnakeCase } from "../../utils-COHZyQue.js";
+import path, { dirname } from "node:path";
+import pkg from "@prisma/generator-helper";
+
+//#region src/helper/sqlalchemy.ts
+const PRISMA_TO_PYTHON = {
+	String: "str",
+	Int: "int",
+	BigInt: "int",
+	Float: "float",
+	Decimal: "Decimal",
+	Boolean: "bool",
+	DateTime: "datetime",
+	Json: "dict",
+	Bytes: "bytes"
+};
+const PRISMA_TO_SQLALCHEMY = {
+	String: "String",
+	Int: "Integer",
+	BigInt: "BigInteger",
+	Float: "Float",
+	Decimal: "Numeric",
+	Boolean: "Boolean",
+	DateTime: "DateTime",
+	Json: "JSON",
+	Bytes: "LargeBinary"
+};
+function prismaTypeToSQLAlchemyType(type) {
+	return PRISMA_TO_SQLALCHEMY[type] ?? "String";
+}
+function prismaTypeToPythonType(type) {
+	return PRISMA_TO_PYTHON[type] ?? "str";
+}
+function resolveNativeType(field) {
+	const baseType = prismaTypeToSQLAlchemyType(field.type);
+	if (!field.nativeType) return baseType;
+	const [nativeName, nativeArgs] = field.nativeType;
+	const args = nativeArgs ?? [];
+	switch (nativeName) {
+		case "VarChar":
+		case "Char": return args.length > 0 ? `String(${args[0]})` : "String";
+		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 ? `Numeric(precision=${args[0]}, scale=${args[1]})` : "Numeric";
+		case "Uuid": return "Uuid";
+		case "Timestamp": return "DateTime";
+		case "Date": return "Date";
+		case "Time": return "Time";
+		case "JsonB": return "JSON";
+		case "Xml": return "String";
+		default: return baseType;
+	}
+}
+function needsExplicitSaType(field) {
+	if (field.kind === "enum") return true;
+	if (field.nativeType) {
+		if (resolveNativeType(field) !== prismaTypeToSQLAlchemyType(field.type)) return true;
+	}
+	return false;
+}
+function pythonTypeForNative(field) {
+	if (!field.nativeType) {
+		const raw = prismaTypeToPythonType(field.type);
+		return raw === "Decimal" ? "DecimalType" : raw;
+	}
+	const [nativeName] = field.nativeType;
+	if (nativeName === "Uuid") return "uuid_mod.UUID";
+	if (nativeName === "Date") return "date";
+	if (nativeName === "Time") return "time_type";
+	const raw = prismaTypeToPythonType(field.type);
+	return raw === "Decimal" ? "DecimalType" : raw;
+}
+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 foreignKey = targetModel.fields.find((f) => f.relationName === field.relationName && f.relationFromFields && f.relationFromFields.length > 0)?.relationFromFields?.[0];
+				if (!foreignKey) continue;
+				hasMany.push({
+					name: field.name,
+					targetModel: field.type,
+					foreignKey,
+					isList: true
+				});
+			}
+		} else {
+			const targetModel = allModels.find((m) => m.name === field.type);
+			if (!targetModel) continue;
+			const foreignKey = targetModel.fields.find((f) => f.relationName === field.relationName && f.relationFromFields && f.relationFromFields.length > 0)?.relationFromFields?.[0];
+			if (!foreignKey) continue;
+			hasOne.push({
+				name: field.name,
+				targetModel: field.type,
+				foreignKey,
+				isList: false
+			});
+		}
+	}
+	return {
+		belongsTo,
+		hasMany,
+		hasOne,
+		manyToMany
+	};
+}
+function collectManyToManyTables(allModels) {
+	const seen = /* @__PURE__ */ new Set();
+	const tables = [];
+	for (const model of allModels) for (const field of model.fields) {
+		if (field.kind !== "object" || !field.isList) continue;
+		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) continue;
+		const relationName = field.relationName ?? `${model.name}To${field.type}`;
+		if (seen.has(relationName)) continue;
+		seen.add(relationName);
+		const [leftName, rightName] = model.name < field.type ? [model.name, field.type] : [field.type, model.name];
+		const leftModelObj = allModels.find((m) => m.name === leftName);
+		const rightModelObj = allModels.find((m) => m.name === rightName);
+		tables.push({
+			tableName: `_${leftName}To${rightName}`,
+			varName: `${makeSnakeCase(leftName)}_to_${makeSnakeCase(rightName)}`,
+			leftModel: leftName,
+			leftTable: leftModelObj?.dbName ?? makeSnakeCase(leftName),
+			leftPkField: leftModelObj?.fields.find((f) => f.isId),
+			rightModel: rightName,
+			rightTable: rightModelObj?.dbName ?? makeSnakeCase(rightName),
+			rightPkField: rightModelObj?.fields.find((f) => f.isId)
+		});
+	}
+	return tables;
+}
+function generateAssociationTable(info) {
+	const leftSaType = info.leftPkField ? resolveNativeType(info.leftPkField) : "String";
+	const rightSaType = info.rightPkField ? resolveNativeType(info.rightPkField) : "String";
+	const leftPkCol = info.leftPkField?.dbName ?? (info.leftPkField ? makeSnakeCase(info.leftPkField.name) : "id");
+	const rightPkCol = info.rightPkField?.dbName ?? (info.rightPkField ? makeSnakeCase(info.rightPkField.name) : "id");
+	return [
+		`${info.varName} = Table(`,
+		`    "${info.tableName}",`,
+		"    Base.metadata,",
+		`    Column("A", ${leftSaType}, ForeignKey("${info.leftTable}.${leftPkCol}"), primary_key=True),`,
+		`    Column("B", ${rightSaType}, ForeignKey("${info.rightTable}.${rightPkCol}"), primary_key=True),`,
+		")"
+	].join("\n");
+}
+function formatDefault(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 isFunctionDefault(def) {
+	return def !== null && typeof def === "object" && "name" in def;
+}
+function isAutoincrement(field) {
+	return isFunctionDefault(field.default) && field.default.name === "autoincrement";
+}
+function needsForeignKeysParam(targetModel, assocs) {
+	return assocs.filter((a) => a.targetModel === targetModel).length > 1;
+}
+function findBackPopulates(targetModelName, sourceModelName, foreignKey, allModels) {
+	const targetModel = allModels.find((m) => m.name === targetModelName);
+	if (!targetModel) return makeSnakeCase(sourceModelName);
+	const backField = targetModel.fields.find((f) => {
+		if (f.kind !== "object") return false;
+		if (f.type !== sourceModelName) return false;
+		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 backField ? makeSnakeCase(backField.name) : makeSnakeCase(sourceModelName);
+}
+function findM2MBackPopulates(targetModelName, sourceModelName, relationName, allModels) {
+	const targetModel = allModels.find((m) => m.name === targetModelName);
+	if (!targetModel) return makeSnakeCase(sourceModelName);
+	const backField = targetModel.fields.find((f) => f.kind === "object" && f.type === sourceModelName && f.relationName === relationName);
+	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 colArgs = [];
+	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));
+	if (isFk) {
+		const assoc = associations.belongsTo.find((a) => a.foreignKey === field.name);
+		if (assoc) {
+			const targetTable = allModels.find((m) => m.name === assoc.targetModel)?.dbName ?? makeSnakeCase(assoc.targetModel);
+			const targetCol = makeSnakeCase(assoc.references);
+			colArgs.push(`ForeignKey("${targetTable}.${targetCol}")`);
+		}
+	}
+	if (isPk) colArgs.push("primary_key=True");
+	if (isPk && isAutoincrement(field)) colArgs.push("autoincrement=True");
+	if (field.isUnique) colArgs.push("unique=True");
+	if (field.type === "DateTime" && isFunctionDefault(field.default) && field.default.name === "now") colArgs.push("server_default=func.now()");
+	else if (!isPk || isAutoincrement(field)) {
+		const defaultVal = formatDefault(field.default);
+		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(", ")})`;
+}
+function generateTableArgs(model, indexes) {
+	const uniqueConstraints = model.uniqueFields.map((fields) => {
+		return `UniqueConstraint(${fields.map((f) => {
+			return `"${model.fields.find((mf) => mf.name === f)?.dbName ?? makeSnakeCase(f)}"`;
+		}).join(", ")})`;
+	});
+	const indexConstraints = indexes.filter((idx) => idx.model === model.name && (idx.type === "normal" || idx.type === "fulltext")).map((idx) => {
+		return `Index("${idx.dbName ?? idx.name ?? `idx_${idx.fields.map((f) => makeSnakeCase(f.name)).join("_")}`}", ${idx.fields.map((f) => {
+			return `"${model.fields.find((mf) => mf.name === f.name)?.dbName ?? makeSnakeCase(f.name)}"`;
+		}).join(", ")})`;
+	});
+	const allConstraints = [...uniqueConstraints, ...indexConstraints];
+	if (allConstraints.length === 0) return [];
+	return [
+		"",
+		"    __table_args__ = (",
+		...allConstraints.map((c) => `        ${c},`),
+		"    )"
+	];
+}
+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 fkClause = needsForeignKeysParam(assoc.targetModel, associations.belongsTo) ? `foreign_keys=[${snakeFk}], ` : "";
+		return `    ${snakeName}: Mapped["${assoc.targetModel}"] = relationship(${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 targetModel = allModels.find((m) => m.name === assoc.targetModel);
+		const needsFkParam = targetModel ? needsForeignKeysParam(model.name, getAssociations(targetModel, allModels).belongsTo) : false;
+		const targetFkSnake = makeSnakeCase(assoc.foreignKey);
+		const fkClause = needsFkParam ? `foreign_keys="${assoc.targetModel}.${targetFkSnake}", ` : "";
+		return `    ${snakeName}: Mapped[list["${assoc.targetModel}"]] = relationship(${fkClause}back_populates="${backPop}")`;
+	});
+}
+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 targetModel = allModels.find((m) => m.name === assoc.targetModel);
+		const needsFkParam = targetModel ? needsForeignKeysParam(model.name, getAssociations(targetModel, allModels).belongsTo) : false;
+		const targetFkSnake = makeSnakeCase(assoc.foreignKey);
+		const fkClause = needsFkParam ? `foreign_keys="${assoc.targetModel}.${targetFkSnake}", ` : "";
+		return `    ${snakeName}: Mapped["${assoc.targetModel}"] = relationship(${fkClause}back_populates="${backPop}", uselist=False)`;
+	});
+}
+function generateManyToManyRelationships(associations, model, allModels, m2mTables) {
+	return associations.manyToMany.map((assoc) => {
+		const snakeName = makeSnakeCase(assoc.name);
+		const backPop = findM2MBackPopulates(assoc.targetModel, model.name, assoc.relationName, allModels);
+		const [leftName, rightName] = model.name < assoc.targetModel ? [model.name, assoc.targetModel] : [assoc.targetModel, model.name];
+		const secondaryVar = m2mTables.find((t) => t.leftModel === leftName && t.rightModel === rightName)?.varName ?? `${makeSnakeCase(leftName)}_to_${makeSnakeCase(rightName)}`;
+		return `    ${snakeName}: Mapped[list["${assoc.targetModel}"]] = relationship(secondary=${secondaryVar}, back_populates="${backPop}")`;
+	});
+}
+function generateModelBody(model, allModels, enums, indexes, m2mTables) {
+	const idField = model.fields.find((f) => f.isId);
+	const compositePkFieldNames = new Set(model.primaryKey?.fields ?? []);
+	const isCompositePk = !idField && compositePkFieldNames.size > 0;
+	if (!(idField || isCompositePk)) return null;
+	const associations = getAssociations(model, allModels);
+	const belongsToFkFields = new Set(associations.belongsTo.map((a) => a.foreignKey));
+	const enumMap = new Map((enums ?? []).map((e) => [e.name, e.values.map((v) => v.name)]));
+	const tableName = model.dbName ?? makeSnakeCase(model.name);
+	const columnLines = model.fields.filter((f) => f.kind !== "object").map((field) => {
+		return generateColumn(field, field.isId || compositePkFieldNames.has(field.name), belongsToFkFields.has(field.name), associations, allModels, enumMap);
+	});
+	const tableArgsLines = generateTableArgs(model, indexes);
+	const relationLines = [
+		...generateBelongsToRelationships(associations, model, allModels),
+		...generateHasManyRelationships(associations, model, allModels),
+		...generateHasOneRelationships(associations, model, allModels),
+		...generateManyToManyRelationships(associations, model, allModels, m2mTables)
+	];
+	const hasRelations = relationLines.length > 0;
+	return [
+		`class ${model.name}(Base):`,
+		`    __tablename__ = "${tableName}"`,
+		"",
+		...columnLines,
+		...tableArgsLines,
+		...hasRelations ? [""] : [],
+		...relationLines
+	].join("\n");
+}
+function collectGlobalImports(models, _enums, indexes, m2mTables) {
+	const saImports = /* @__PURE__ */ new Set();
+	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 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) => {
+		if (!f.nativeType) return false;
+		const [n] = f.nativeType;
+		return n === "Uuid";
+	}));
+	const needsDate = models.some((m) => m.fields.some((f) => {
+		if (!f.nativeType) return false;
+		const [n] = f.nativeType;
+		return n === "Date";
+	}));
+	const needsTime = models.some((m) => m.fields.some((f) => {
+		if (!f.nativeType) return false;
+		const [n] = f.nativeType;
+		return n === "Time";
+	}));
+	for (const model of models) {
+		for (const field of model.fields) {
+			if (field.kind === "object") continue;
+			if (field.kind === "enum") {
+				saImports.add("Enum");
+				continue;
+			}
+			if (needsExplicitSaType(field)) {
+				const resolved = resolveNativeType(field);
+				saImports.add(resolved.replace(/\(.*\)$/, ""));
+			}
+		}
+		const associations = getAssociations(model, models);
+		if (associations.belongsTo.length > 0) saImports.add("ForeignKey");
+		if (!model.fields.find((f) => f.isId) && (model.primaryKey?.fields ?? []).length > 0) {
+			if (associations.belongsTo.length > 0) saImports.add("ForeignKey");
+		}
+		if (model.uniqueFields.length > 0) saImports.add("UniqueConstraint");
+		if (indexes.some((idx) => idx.model === model.name && (idx.type === "normal" || idx.type === "fulltext"))) saImports.add("Index");
+	}
+	if (m2mTables.length > 0) {
+		saImports.add("Column");
+		saImports.add("ForeignKey");
+		saImports.add("Table");
+		for (const info of m2mTables) {
+			const leftType = info.leftPkField ? resolveNativeType(info.leftPkField) : "String";
+			const rightType = info.rightPkField ? resolveNativeType(info.rightPkField) : "String";
+			saImports.add(leftType.replace(/\(.*\)$/, ""));
+			saImports.add(rightType.replace(/\(.*\)$/, ""));
+		}
+	}
+	if (needsFunc) saImports.add("func");
+	const lines = [];
+	const sortedSa = [...saImports].sort();
+	if (sortedSa.length > 0) lines.push(`from sqlalchemy import ${sortedSa.join(", ")}`);
+	const ormImports = [
+		"DeclarativeBase",
+		"Mapped",
+		"mapped_column"
+	];
+	if (hasRelationship) ormImports.push("relationship");
+	lines.push(`from sqlalchemy.orm import ${ormImports.sort().join(", ")}`);
+	if (needsOptional) lines.push("from typing import Optional");
+	if (needsDecimal) lines.push("from decimal import Decimal as DecimalType");
+	const dtParts = [];
+	if (needsDatetime) dtParts.push("datetime");
+	if (needsDate) dtParts.push("date");
+	if (needsTime) dtParts.push("time as time_type");
+	if (dtParts.length > 0) lines.push(`from datetime import ${dtParts.join(", ")}`);
+	if (needsUuid) lines.push("import uuid as uuid_mod");
+	return lines;
+}
+function generateSingleFile(models, enums, indexes) {
+	const idx = indexes ?? [];
+	const m2mTables = collectManyToManyTables(models);
+	const importLines = collectGlobalImports(models, enums, idx, m2mTables);
+	const m2mLines = m2mTables.length > 0 ? m2mTables.flatMap((t, i) => i === 0 ? ["", generateAssociationTable(t)] : ["", generateAssociationTable(t)]) : [];
+	const modelBodies = models.map((model) => generateModelBody(model, models, enums, idx, m2mTables)).filter((body) => body !== null);
+	return [
+		...importLines,
+		"",
+		"",
+		"class Base(DeclarativeBase):",
+		"    pass",
+		...m2mLines,
+		"",
+		"",
+		...modelBodies.join("\n\n").split("\n"),
+		""
+	].join("\n");
+}
+async function writeSQLAlchemyFile(models, outPath, enums, indexes) {
+	const mkdirResult = await mkdir(dirname(outPath));
+	if (!mkdirResult.ok) return mkdirResult;
+	const writeResult = await writeFile(outPath, generateSingleFile(models, enums, indexes));
+	if (!writeResult.ok) return writeResult;
+	console.log(`wrote ${outPath}`);
+	return {
+		ok: true,
+		value: void 0
+	};
+}
+
+//#endregion
+//#region src/generator/sqlalchemy/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-SQLAlchemy. Please specify output in your generator config.");
+	const output = options.generator.output.value;
+	const resolved = path.extname(output) ? output : path.join(output, "models.py");
+	const enums = options.dmmf.datamodel.enums;
+	const indexes = options.dmmf.datamodel.indexes;
+	const result = await writeSQLAlchemyFile(options.dmmf.datamodel.models, resolved, enums, indexes);
+	if (!result.ok) throw new Error(`Failed to write SQLAlchemy models: ${result.error}`);
+}
+generatorHandler({
+	onManifest() {
+		return {
+			defaultOutput: ".",
+			prettyName: "Hekireki-SQLAlchemy"
+		};
+	},
+	onGenerate: main
+});
+
+//#endregion
+export { main };

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

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

package/dist/generator/typebox/index.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+import { t as fmt } from "../../format-CzXgkLDe.js";
+import { c as parseDocumentWithoutAnnotations, d as mkdir, f as writeFile, l as schemaFromFields, s as makeValidationExtractor, t as getBool } from "../../utils-COHZyQue.js";
+import { n as validationSchemas, t as makeRelationsOnly } from "../../prisma-ChsFqlYX.js";
+import path from "node:path";
+import pkg from "@prisma/generator-helper";
+
+//#region src/helper/typebox.ts
+function makeTypeBoxInfer(modelName) {
+	return `export type ${modelName} = Static<typeof ${modelName}Schema>`;
+}
+function makeTypeBoxSchema(modelName, fields) {
+	return `export const ${modelName}Schema = Type.Object({\n${fields}\n})`;
+}
+function makeTypeBoxProperties(fields, comment) {
+	return fields.map((field) => {
+		const commentLines = comment && field.comment.length > 0 ? `${field.comment.map((c) => `  /** ${c} */`).join("\n")}\n` : "";
+		const expr = field.validation ?? "Type.Unknown()";
+		const wrapped = field.isRequired ? expr : `Type.Optional(${expr})`;
+		return `${commentLines}  ${field.fieldName}: ${wrapped},`;
+	}).join("\n");
+}
+function makeTypeBoxEnumExpression(values) {
+	return `Type.Union([${values.map((v) => `Type.Literal('${v}')`).join(", ")}])`;
+}
+const PRISMA_TO_TYPEBOX = {
+	String: "Type.String()",
+	Int: "Type.Integer()",
+	Float: "Type.Number()",
+	Boolean: "Type.Boolean()",
+	DateTime: "Type.Date()",
+	BigInt: "Type.BigInt()",
+	Decimal: "Type.Number()",
+	Json: "Type.Unknown()",
+	Bytes: "Type.Any()"
+};
+function makeTypeBoxSchemas(modelFields, comment) {
+	return schemaFromFields(modelFields, comment, makeTypeBoxSchema, makeTypeBoxProperties);
+}
+function makeTypeBoxRelations(model, relProps, options) {
+	if (relProps.length === 0) return null;
+	const base = `  ...${model.name}Schema.properties,`;
+	const rels = relProps.map((r) => `  ${r.key}: ${r.isMany ? `Type.Array(${r.targetModel}Schema)` : `${r.targetModel}Schema`},`).join("\n");
+	const typeLine = options?.includeType ? `\n\nexport type ${model.name}Relations = Static<typeof ${model.name}RelationsSchema>` : "";
+	return `export const ${model.name}RelationsSchema = Type.Object({\n${base}\n${rels}\n})${typeLine}`;
+}
+function typebox(models, type, comment, enums) {
+	return validationSchemas(models, type, comment, {
+		importStatement: type ? `import { type Static, Type } from '@sinclair/typebox'` : `import { Type } from '@sinclair/typebox'`,
+		annotationPrefix: "@t.",
+		parseDocument: parseDocumentWithoutAnnotations,
+		extractValidation: makeValidationExtractor("@t."),
+		inferType: makeTypeBoxInfer,
+		schemas: makeTypeBoxSchemas,
+		typeMapping: PRISMA_TO_TYPEBOX,
+		enums,
+		formatEnum: makeTypeBoxEnumExpression
+	});
+}
+
+//#endregion
+//#region src/generator/typebox/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-TypeBox. Please specify output in your generator config.");
+	const output = options.generator.output.value;
+	const resolved = path.extname(output) ? {
+		dir: path.dirname(output),
+		file: output
+	} : {
+		dir: output,
+		file: path.join(output, "index.ts")
+	};
+	const enableRelation = getBool(options.generator.config?.relation);
+	const fmtResult = await fmt([typebox(options.dmmf.datamodel.models, getBool(options.generator.config?.type), getBool(options.generator.config?.comment), options.dmmf.datamodel.enums), enableRelation ? makeRelationsOnly(options.dmmf, getBool(options.generator.config?.type), makeTypeBoxRelations) : ""].filter(Boolean).join("\n\n"));
+	if (!fmtResult.ok) throw new Error(`Format error: ${fmtResult.error}`);
+	const mkdirResult = await mkdir(resolved.dir);
+	if (!mkdirResult.ok) throw new Error(`Failed to create directory: ${mkdirResult.error}`);
+	const writeResult = await writeFile(resolved.file, fmtResult.value);
+	if (!writeResult.ok) throw new Error(`Failed to write file: ${writeResult.error}`);
+}
+generatorHandler({
+	onManifest() {
+		return {
+			defaultOutput: ".",
+			prettyName: "Hekireki-TypeBox"
+		};
+	},
+	onGenerate: main
+});
+
+//#endregion
+export { main };

package/dist/generator/valibot/index.js

@@ -1,11 +1,20 @@
 #!/usr/bin/env node
 import { t as fmt } from "../../format-CzXgkLDe.js";
-import { C as makeValibotSchema, N as mkdir, O as parseDocumentWithoutAnnotations, P as writeFile, S as makeValibotInfer, a as getBool, j as schemaFromFields, v as makePropertiesGenerator, w as makeValidationExtractor, x as makeValibotEnumExpression } from "../../utils-DeZn2r_T.js";
-import { n as validationSchemas, t as makeRelationsOnly } from "../../prisma-Cc0YxSiO.js";
+import { a as makePropertiesGenerator, c as parseDocumentWithoutAnnotations, d as mkdir, f as writeFile, l as schemaFromFields, s as makeValidationExtractor, t as getBool } from "../../utils-COHZyQue.js";
+import { n as validationSchemas, t as makeRelationsOnly } from "../../prisma-ChsFqlYX.js";
 import path from "node:path";
 import pkg from "@prisma/generator-helper";
 
 //#region src/helper/valibot.ts
+function makeValibotInfer(modelName) {
+	return `export type ${modelName} = v.InferInput<typeof ${modelName}Schema>`;
+}
+function makeValibotSchema(modelName, fields) {
+	return `export const ${modelName}Schema = v.object({\n${fields}\n})`;
+}
+function makeValibotEnumExpression(values) {
+	return `picklist([${values.map((v) => `'${v}'`).join(", ")}])`;
+}
 const PRISMA_TO_VALIBOT = {
 	String: "string()",
 	Int: "number()",
@@ -22,9 +31,10 @@ function makeValibotSchemas(modelFields, comment) {
 }
 function makeValibotRelations(model, relProps, options) {
 	if (relProps.length === 0) return null;
-	const fields = `${`  ...${model.name}Schema.entries,`}\n${relProps.map((r) => `  ${r.key}: ${r.isMany ? `v.array(${r.targetModel}Schema)` : `${r.targetModel}Schema`},`).join("\n")}`;
+	const base = `  ...${model.name}Schema.entries,`;
+	const rels = relProps.map((r) => `  ${r.key}: ${r.isMany ? `v.array(${r.targetModel}Schema)` : `${r.targetModel}Schema`},`).join("\n");
 	const typeLine = options?.includeType ? `\n\nexport type ${model.name}Relations = v.InferInput<typeof ${model.name}RelationsSchema>` : "";
-	return `export const ${model.name}RelationsSchema = v.object({\n${fields}\n})${typeLine}`;
+	return `export const ${model.name}RelationsSchema = v.object({\n${base}\n${rels}\n})${typeLine}`;
 }
 function valibot(models, type, comment, enums) {
 	return validationSchemas(models, type, comment, {
@@ -53,7 +63,7 @@ async function main(options) {
 		dir: output,
 		file: path.join(output, "index.ts")
 	};
-	const enableRelation = options.generator.config?.relation === "true" || Array.isArray(options.generator.config?.relation) && options.generator.config?.relation[0] === "true";
+	const enableRelation = getBool(options.generator.config?.relation);
 	const fmtResult = await fmt([valibot(options.dmmf.datamodel.models, getBool(options.generator.config?.type), getBool(options.generator.config?.comment), options.dmmf.datamodel.enums), enableRelation ? makeRelationsOnly(options.dmmf, getBool(options.generator.config?.type), makeValibotRelations) : ""].filter(Boolean).join("\n\n"));
 	if (!fmtResult.ok) throw new Error(`Format error: ${fmtResult.error}`);
 	const mkdirResult = await mkdir(resolved.dir);

package/dist/generator/zod/index.js

@@ -1,11 +1,20 @@
 #!/usr/bin/env node
 import { t as fmt } from "../../format-CzXgkLDe.js";
-import { D as makeZodSchema, E as makeZodInfer, N as mkdir, O as parseDocumentWithoutAnnotations, P as writeFile, T as makeZodEnumExpression, a as getBool, j as schemaFromFields, o as getString, v as makePropertiesGenerator, w as makeValidationExtractor } from "../../utils-DeZn2r_T.js";
-import { n as validationSchemas, t as makeRelationsOnly } from "../../prisma-Cc0YxSiO.js";
+import { a as makePropertiesGenerator, c as parseDocumentWithoutAnnotations, d as mkdir, f as writeFile, l as schemaFromFields, n as getString, s as makeValidationExtractor, t as getBool } from "../../utils-COHZyQue.js";
+import { n as validationSchemas, t as makeRelationsOnly } from "../../prisma-ChsFqlYX.js";
 import path from "node:path";
 import pkg from "@prisma/generator-helper";
 
 //#region src/helper/zod.ts
+function makeZodInfer(modelName) {
+	return `export type ${modelName} = z.infer<typeof ${modelName}Schema>`;
+}
+function makeZodSchema(modelName, fields) {
+	return `export const ${modelName}Schema = z.object({\n${fields}\n})`;
+}
+function makeZodEnumExpression(values) {
+	return `enum([${values.map((v) => `'${v}'`).join(", ")}])`;
+}
 const PRISMA_TO_ZOD = {
 	String: "string()",
 	Int: "number()",
@@ -22,9 +31,10 @@ function makeZodSchemas(modelFields, comment) {
 }
 function makeZodRelations(model, relProps, options) {
 	if (relProps.length === 0) return null;
-	const fields = `${`  ...${model.name}Schema.shape,`}\n${relProps.map((r) => `  ${r.key}: ${r.isMany ? `z.array(${r.targetModel}Schema)` : `${r.targetModel}Schema`},`).join("\n")}`;
+	const base = `  ...${model.name}Schema.shape,`;
+	const rels = relProps.map((r) => `  ${r.key}: ${r.isMany ? `z.array(${r.targetModel}Schema)` : `${r.targetModel}Schema`},`).join("\n");
 	const typeLine = options?.includeType ? `\n\nexport type ${model.name}Relations = z.infer<typeof ${model.name}RelationsSchema>` : "";
-	return `export const ${model.name}RelationsSchema = z.object({\n${fields}\n})${typeLine}`;
+	return `export const ${model.name}RelationsSchema = z.object({\n${base}\n${rels}\n})${typeLine}`;
 }
 function zod(models, type, comment, zodVersion, enums) {
 	return validationSchemas(models, type, comment, {
@@ -54,7 +64,7 @@ async function main(options) {
 		file: path.join(output, "index.ts")
 	};
 	const zodVersion = getString(options.generator.config?.zod, "v4");
-	const enableRelation = options.generator.config?.relation === "true" || Array.isArray(options.generator.config?.relation) && options.generator.config?.relation[0] === "true";
+	const enableRelation = getBool(options.generator.config?.relation);
 	const fmtResult = await fmt([zod(options.dmmf.datamodel.models, getBool(options.generator.config?.type), getBool(options.generator.config?.comment), zodVersion, options.dmmf.datamodel.enums), enableRelation ? makeRelationsOnly(options.dmmf, getBool(options.generator.config?.type), makeZodRelations) : ""].filter(Boolean).join("\n\n"));
 	if (!fmtResult.ok) throw new Error(`Format error: ${fmtResult.error}`);
 	const mkdirResult = await mkdir(resolved.dir);