hekireki 0.5.1 → 0.6.0

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

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

package/dist/generator/arktype/index.js

@@ -1,73 +1,16 @@
 #!/usr/bin/env node
-import { a as getBool, i as collectRelationProps, n as validationSchemas, o as getString, r as parseDocumentWithoutAnnotations, s as fmt, t as schemaFromFields } from "../../utils-BHGDO4qk.js";
-import { n as writeFile, t as mkdir } from "../../fsp-FOfmtPYd.js";
+import { n as validationSchemas, r as fmt, t as makeRelationsOnly } from "../../prisma-vPHUnYiY.js";
+import { C as parseDocumentWithoutAnnotations, O as mkdir, b as makeValidationExtractor, k as writeFile, l as getBool, m as makeArktypeSchemas, p as makeArktypeInfer, u as getString } from "../../utils-0nIzqFtt.js";
 import path from "node:path";
 import pkg from "@prisma/generator-helper";
-import { makeValidationExtractor } from "utils-lab";
 
-//#region src/generator/arktype/generator/schema.ts
-/**
-* Generate ArkType schema
-* @param modelName - The name of the model
-* @param fields - The fields of the model
-* @returns The generated ArkType schema
-*/
-function schema(modelName, fields) {
-	return `export const ${modelName}Schema = type({\n${fields}\n})`;
-}
-/**
-* Make ArkType relations schema for a model.
-* @param model - The DMMF model
-* @param relProps - The relation properties
-* @param options - Options for the relation generation
-* @returns The generated ArkType relations schema or null if no relations
-*/
+//#region src/helper/arktype.ts
 function makeArktypeRelations(model, relProps, options) {
 	if (relProps.length === 0) return null;
 	const fields = `${`...${model.name}Schema.t,`}${relProps.map((r) => `${r.key}:${r.isMany ? `${r.targetModel}Schema.array()` : `${r.targetModel}Schema`},`).join("")}`;
 	const typeLine = options?.includeType ? `\n\nexport type ${model.name}Relations = typeof ${model.name}RelationsSchema.infer` : "";
 	return `export const ${model.name}RelationsSchema = type({${fields}})${typeLine}`;
 }
-
-//#endregion
-//#region src/generator/arktype/generator/schemas.ts
-/**
-* Generate properties for ArkType schema.
-*/
-function arktypePropertiesGenerator(fields, comment) {
-	return fields.map((field) => {
-		return `${comment && field.comment.length > 0 ? `${field.comment.map((c) => `  /** ${c} */`).join("\n")}\n` : ""}  ${field.fieldName}: ${field.validation ?? "\"unknown\""},`;
-	}).join("\n");
-}
-/**
-* Creates ArkType schemas from model fields.
-*
-* @param modelFields - The fields of the model
-* @param comment - Whether to include comments in the generated code
-* @returns The generated ArkType schemas
-*/
-function schemas(modelFields, comment) {
-	return schemaFromFields(modelFields, comment, schema, arktypePropertiesGenerator);
-}
-
-//#endregion
-//#region src/generator/arktype/generator/arktype.ts
-/**
-* Generate ArkType infer type statement.
-* @param modelName - The name of the model
-* @returns The generated type inference statement
-*/
-function makeArktypeInfer(modelName) {
-	return `export type ${modelName} = typeof ${modelName}Schema.infer`;
-}
-/**
-* Creates ArkType schemas and types from models.
-*
-* @param models - The models to generate the ArkType schemas and types for
-* @param type - Whether to generate types
-* @param comment - Whether to include comments in the generated code
-* @returns The generated ArkType schemas and types
-*/
 function arktype(models, type, comment) {
 	return validationSchemas(models, type, comment, {
 		importStatement: `import { type } from 'arktype'`,
@@ -75,38 +18,24 @@ function arktype(models, type, comment) {
 		parseDocument: parseDocumentWithoutAnnotations,
 		extractValidation: makeValidationExtractor("@a."),
 		inferType: makeArktypeInfer,
-		schemas
+		schemas: makeArktypeSchemas
 	});
 }
 
 //#endregion
 //#region src/generator/arktype/index.ts
 const { generatorHandler } = pkg;
-const buildRelationsOnly = (dmmf, includeType) => {
-	const models = dmmf.datamodel.models;
-	const relIndex = collectRelationProps(models);
-	const relByModel = {};
-	for (const r of relIndex) {
-		const existing = relByModel[r.model] ?? [];
-		relByModel[r.model] = [...existing, r];
-	}
-	return models.map((model) => makeArktypeRelations(model, (relByModel[model.name] ?? []).map(({ key, targetModel, isMany }) => ({
-		key,
-		targetModel,
-		isMany
-	})), { includeType })).filter((code) => Boolean(code)).join("\n\n");
-};
-const emit = async (options, enableRelation) => {
+async function main(options) {
 	const outDir = options.generator.output?.value ?? "./arktype";
 	const file = getString(options.generator.config?.file, "index.ts") ?? "index.ts";
-	const fmtResult = await fmt([arktype(options.dmmf.datamodel.models, getBool(options.generator.config?.type), getBool(options.generator.config?.comment)), enableRelation ? buildRelationsOnly(options.dmmf, getBool(options.generator.config?.type)) : ""].filter(Boolean).join("\n\n"));
+	const enableRelation = options.generator.config?.relation === "true" || Array.isArray(options.generator.config?.relation) && options.generator.config?.relation[0] === "true";
+	const fmtResult = await fmt([arktype(options.dmmf.datamodel.models, getBool(options.generator.config?.type), getBool(options.generator.config?.comment)), enableRelation ? makeRelationsOnly(options.dmmf, getBool(options.generator.config?.type), makeArktypeRelations) : ""].filter(Boolean).join("\n\n"));
 	if (!fmtResult.ok) throw new Error(`Format error: ${fmtResult.error}`);
 	const mkdirResult = await mkdir(outDir);
 	if (!mkdirResult.ok) throw new Error(`Failed to create directory: ${mkdirResult.error}`);
 	const writeResult = await writeFile(path.join(outDir, file), fmtResult.value);
 	if (!writeResult.ok) throw new Error(`Failed to write file: ${writeResult.error}`);
-};
-const onGenerate = (options) => emit(options, options.generator.config?.relation === "true" || Array.isArray(options.generator.config?.relation) && options.generator.config?.relation[0] === "true");
+}
 generatorHandler({
 	onManifest() {
 		return {
@@ -114,8 +43,8 @@ generatorHandler({
 			prettyName: "Hekireki-ArkType"
 		};
 	},
-	onGenerate
+	onGenerate: main
 });
 
 //#endregion
-export { onGenerate };
+export { main };

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

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

package/dist/generator/dbml/index.js

@@ -1,80 +1,42 @@
 #!/usr/bin/env node
-import { n as writeFile, r as writeFileBinary, t as mkdir } from "../../fsp-FOfmtPYd.js";
+import { A as writeFileBinary, D as stripAnnotations, O as mkdir, T as quote, a as generateEnum, c as generateRef, k as writeFile, o as generateIndex, r as escapeNote, s as generatePrismaColumn, t as combineKeys, u as getString } from "../../utils-0nIzqFtt.js";
 import pkg from "@prisma/generator-helper";
-import { escapeNote, formatConstraints, generateEnum, generateIndex, generateRef, quote } from "utils-lab";
 import { Resvg } from "@resvg/resvg-js";
 import { run } from "@softwaretechnik/dbml-renderer";
 
-//#region src/generator/dbml/generator/dbml-content.ts
-/**
-* Strip validation annotations (@z.*, @v.*, @a.*, @e.*) and relation annotations (@relation) from documentation
-*/
-function stripAnnotations(doc) {
-	if (!doc) return void 0;
-	const result = doc.split("\n").filter((line) => {
-		const trimmed = line.trim();
-		return !(trimmed.startsWith("@z.") || trimmed.startsWith("@v.") || trimmed.startsWith("@a.") || trimmed.startsWith("@e.") || trimmed.startsWith("@relation"));
-	}).join("\n").trim();
-	return result.length > 0 ? result : void 0;
+//#region src/helper/dbml.ts
+function resolveFieldType(field, models, mapToDbSchema) {
+	const baseType = mapToDbSchema ? models.find((m) => m.name === field.type)?.dbName ?? field.type : field.type;
+	return field.isList && !field.relationName ? `${baseType}[]` : baseType;
+}
+function resolveDefaultValue(field) {
+	const defaultDef = field.default;
+	if (defaultDef?.name === "autoincrement") return void 0;
+	if (defaultDef?.name === "now") return "`now()`";
+	if (field.hasDefaultValue && typeof field.default !== "object") return field.type === "String" || field.type === "Json" || field.kind === "enum" ? `'${field.default}'` : String(field.default);
 }
-/**
-* Convert Prisma field to DBMLColumn
-*/
 function toDBMLColumn(field, models, mapToDbSchema) {
-	let fieldType = field.type;
-	if (mapToDbSchema) {
-		const relatedModel = models.find((m) => m.name === field.type);
-		if (relatedModel?.dbName) fieldType = relatedModel.dbName;
-	}
-	if (field.isList && !field.relationName) fieldType = `${fieldType}[]`;
-	let defaultValue;
 	const defaultDef = field.default;
-	if (defaultDef?.name === "autoincrement") {} else if (defaultDef?.name === "now") defaultValue = "`now()`";
-	else if (field.hasDefaultValue && typeof field.default !== "object") if (field.type === "String" || field.type === "Json" || field.kind === "enum") defaultValue = `'${field.default}'`;
-	else defaultValue = String(field.default);
 	return {
 		name: field.name,
-		type: fieldType,
+		type: resolveFieldType(field, models, mapToDbSchema),
 		isPrimaryKey: field.isId,
 		isIncrement: defaultDef?.name === "autoincrement",
 		isUnique: field.isUnique,
 		isNotNull: field.isRequired && !field.isId,
-		defaultValue,
+		defaultValue: resolveDefaultValue(field),
 		note: stripAnnotations(field.documentation)
 	};
 }
-/**
-* Generate custom column line with Prisma-specific formatting
-*/
-function generatePrismaColumn(column) {
-	const constraints = [];
-	if (column.isPrimaryKey) constraints.push("pk");
-	if (column.isIncrement) constraints.push("increment");
-	if (column.defaultValue !== void 0) constraints.push(`default: ${column.defaultValue}`);
-	if (column.isUnique) constraints.push("unique");
-	if (column.isNotNull) constraints.push("not null");
-	if (column.note) constraints.push(`note: ${quote(column.note)}`);
-	return `  ${column.name} ${column.type}${formatConstraints(constraints)}`;
-}
-/**
-* Generate table indexes block
-*/
 function generateTableIndexes(model) {
-	const indexes = [];
-	const primaryFields = model.primaryKey?.fields;
-	if (primaryFields && primaryFields.length > 0) indexes.push({
-		columns: primaryFields,
+	return [...model.primaryKey?.fields && model.primaryKey.fields.length > 0 ? [{
+		columns: model.primaryKey.fields,
 		isPrimaryKey: true
-	});
-	for (const composite of model.uniqueFields) if (composite.length > 1) indexes.push({
-		columns: composite,
+	}] : [], ...model.uniqueFields.filter((c) => c.length > 1).map((c) => ({
+		columns: c,
 		isUnique: true
-	});
-	return indexes;
+	}))];
 }
-/**
-* Generate table definitions
-*/
 function generateTables(models, mapToDbSchema = false, includeRelationFields = true) {
 	return models.map((model) => {
 		const modelName = mapToDbSchema && model.dbName ? model.dbName : model.name;
@@ -85,9 +47,6 @@ function generateTables(models, mapToDbSchema = false, includeRelationFields = t
 		return `Table ${modelName} {\n${columnLines}${indexBlock}${strippedNote ? `\n\n  Note: ${quote(escapeNote(strippedNote))}` : ""}\n}`;
 	});
 }
-/**
-* Generate enum definitions
-*/
 function generateEnums(enums) {
 	return enums.map((e) => {
 		return generateEnum({
@@ -96,51 +55,30 @@ function generateEnums(enums) {
 		});
 	});
 }
-/**
-* Get relation operator based on cardinality
-*/
 function getRelationOperator(models, from, to) {
 	return (models.find((m) => m.name === to)?.fields.find((f) => f.type === from))?.isList ? ">" : "-";
 }
-/**
-* Combine keys for composite foreign keys
-*/
-function combineKeys(keys) {
-	return keys.length > 1 ? `(${keys.join(", ")})` : keys[0];
-}
-/**
-* Generate foreign key references
-*/
 function generateRelations(models, mapToDbSchema = false) {
-	const refs = [];
-	for (const model of models) {
-		const relFields = model.fields.filter((field) => field.relationName && field.relationToFields?.length && field.relationFromFields?.length);
-		for (const field of relFields) {
-			const relationFrom = model.name;
-			const relationTo = field.type;
-			const operator = getRelationOperator(models, relationFrom, relationTo);
-			const relationFromName = mapToDbSchema && model.dbName ? model.dbName : model.name;
-			const relatedModel = models.find((m) => m.name === relationTo);
-			const relationToName = mapToDbSchema && relatedModel?.dbName ? relatedModel.dbName : relationTo;
-			const fromColumn = combineKeys(field.relationFromFields ?? []);
-			const toColumn = combineKeys(field.relationToFields ?? []);
-			const ref = {
-				name: `${relationFromName}_${fromColumn}_fk`,
-				fromTable: relationFromName,
-				fromColumn,
-				toTable: relationToName,
-				toColumn,
-				type: operator,
-				onDelete: field.relationOnDelete
-			};
-			refs.push(generateRef(ref));
-		}
-	}
-	return refs;
+	return models.flatMap((model) => model.fields.filter((field) => field.relationName && field.relationToFields?.length && field.relationFromFields?.length).map((field) => {
+		const relationFrom = model.name;
+		const relationTo = field.type;
+		const operator = getRelationOperator(models, relationFrom, relationTo);
+		const relationFromName = mapToDbSchema && model.dbName ? model.dbName : model.name;
+		const relatedModel = models.find((m) => m.name === relationTo);
+		const relationToName = mapToDbSchema && relatedModel?.dbName ? relatedModel.dbName : relationTo;
+		const fromColumn = combineKeys(field.relationFromFields ?? []);
+		const toColumn = combineKeys(field.relationToFields ?? []);
+		return generateRef({
+			name: `${relationFromName}_${fromColumn}_fk`,
+			fromTable: relationFromName,
+			fromColumn,
+			toTable: relationToName,
+			toColumn,
+			type: operator,
+			onDelete: field.relationOnDelete
+		});
+	}));
 }
-/**
-* Generate complete DBML content from Prisma DMMF
-*/
 function dbmlContent(datamodel, mapToDbSchema = false, includeRelationFields = true) {
 	const tables = generateTables(datamodel.models, mapToDbSchema, includeRelationFields);
 	const enums = generateEnums(datamodel.enums);
@@ -151,25 +89,7 @@ function dbmlContent(datamodel, mapToDbSchema = false, includeRelationFields = t
 		...refs
 	].join("\n\n");
 }
-
-//#endregion
-//#region src/generator/dbml/index.ts
-const { generatorHandler } = pkg;
-/**
-* Get string value from config
-*/
-const getStringValue = (value) => value === void 0 ? void 0 : Array.isArray(value) ? value[0] : value;
-/**
-* Get boolean option from config
-*/
-const getBoolOption = (config, key, defaultValue) => {
-	const value = getStringValue(config[key]);
-	return value === void 0 ? defaultValue : value.toLowerCase() !== "false";
-};
-/**
-* Generate DBML file
-*/
-const generateDbml = async (outputDir, content, fileName) => {
+const generateDbmlFile = async (outputDir, content, fileName) => {
 	const writeResult = await writeFile(`${outputDir}/${fileName}`, content);
 	if (!writeResult.ok) return {
 		ok: false,
@@ -177,9 +97,6 @@ const generateDbml = async (outputDir, content, fileName) => {
 	};
 	return { ok: true };
 };
-/**
-* Generate PNG from DBML
-*/
 const generatePng = async (outputDir, dbml, fileName) => {
 	const pngBuffer = new Resvg(run(dbml, "svg"), { font: { loadSystemFonts: true } }).render().asPng();
 	const writeResult = await writeFileBinary(`${outputDir}/${fileName}`, pngBuffer);
@@ -189,24 +106,25 @@ const generatePng = async (outputDir, dbml, fileName) => {
 	};
 	return { ok: true };
 };
-/**
-* Main generator function
-*/
-const main = async (options) => {
+
+//#endregion
+//#region src/generator/dbml/index.ts
+const { generatorHandler } = pkg;
+async function main(options) {
 	const { config } = options.generator;
-	const mapToDbSchema = getBoolOption(config, "mapToDbSchema", true);
-	const includeRelationFields = getBoolOption(config, "includeRelationFields", true);
+	const mapToDbSchema = getString(config?.mapToDbSchema) !== "false";
+	const includeRelationFields = getString(config?.includeRelationFields) !== "false";
 	const content = dbmlContent(options.dmmf.datamodel, mapToDbSchema, includeRelationFields);
 	const output = options.generator.output?.value ?? "./dbml";
-	const dbmlFile = getStringValue(config.file) ?? "schema.dbml";
-	const pngFile = getStringValue(config.pngFile) ?? "er-diagram.png";
+	const dbmlFile = getString(config?.file, "schema.dbml") ?? "schema.dbml";
+	const pngFile = getString(config?.pngFile, "er-diagram.png") ?? "er-diagram.png";
 	const mkdirResult = await mkdir(output);
-	if (!mkdirResult.ok) throw new Error(`❌ Failed to create directory: ${mkdirResult.error}`);
-	const dbmlResult = await generateDbml(output, content, dbmlFile);
-	if (!dbmlResult.ok) throw new Error(`❌ ${dbmlResult.error}`);
+	if (!mkdirResult.ok) throw new Error(`Failed to create directory: ${mkdirResult.error}`);
+	const dbmlResult = await generateDbmlFile(output, content, dbmlFile);
+	if (!dbmlResult.ok) throw new Error(dbmlResult.error);
 	const pngResult = await generatePng(output, content, pngFile);
-	if (!pngResult.ok) throw new Error(`❌ ${pngResult.error}`);
-};
+	if (!pngResult.ok) throw new Error(pngResult.error);
+}
 generatorHandler({
 	onManifest() {
 		return {