hekireki 0.4.1 → 0.5.0

package/dist/generator/valibot/index.js

@@ -1,53 +1,99 @@
 #!/usr/bin/env node
-import fsp from 'node:fs/promises';
-import path from 'node:path';
-import pkg from '@prisma/generator-helper';
-import { fmt } from '../../shared/format/index.js';
-import { collectRelationProps } from '../../shared/helper/relations.js';
-import { buildValibotRelations } from './generator/schema.js';
-import { valibot } from './generator/valibot.js';
+import { a as getString, i as getBool, n as validationSchemas, o as fmt, r as parseDocumentWithoutAnnotations, t as schemaFromFields } from "../../utils-CXBzdZih.js";
+import { n as writeFile, t as mkdir } from "../../fsp-DYtOxLN_.js";
+import { t as collectRelationProps } from "../../relations-CxeKj9KD.js";
+import path from "node:path";
+import pkg from "@prisma/generator-helper";
+import { makePropertiesGenerator, makeValibotInfer, makeValidationExtractor } from "utils-lab";
+
+//#region src/generator/valibot/generator/schema.ts
+function buildValibotRelations(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 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}`;
+}
+/**
+* Generate Valibot schema
+* @param modelName - The name of the model
+* @param fields - The fields of the model
+* @returns The generated Valibot schema
+*/
+function schema(modelName, fields) {
+	return `export const ${modelName}Schema = v.object({\n${fields}\n})`;
+}
+
+//#endregion
+//#region src/generator/valibot/generator/schemas.ts
+/**
+* Creates Valibot schemas from model fields.
+*
+* @param modelFields - The fields of the model
+* @param comment - Whether to include comments in the generated code
+* @returns The generated Valibot schemas
+*/
+function schemas(modelFields, comment) {
+	return schemaFromFields(modelFields, comment, schema, makePropertiesGenerator("v"));
+}
+
+//#endregion
+//#region src/generator/valibot/generator/valibot.ts
+/**
+* Creates Valibot schemas and types from models.
+*
+* @param models - The models to generate the Valibot schemas and types for
+* @param type - Whether to generate types
+* @param comment - Whether to include comments in the generated code
+* @returns The generated Valibot schemas and types
+*/
+function valibot(models, type, comment) {
+	return validationSchemas(models, type, comment, {
+		importStatement: `import * as v from 'valibot'`,
+		annotationPrefix: "@v.",
+		parseDocument: parseDocumentWithoutAnnotations,
+		extractValidation: makeValidationExtractor("@v."),
+		inferType: makeValibotInfer,
+		schemas
+	});
+}
+
+//#endregion
+//#region src/generator/valibot/index.ts
 const { generatorHandler } = pkg;
 const buildRelationsOnly = (dmmf, includeType) => {
-    const models = dmmf.datamodel.models;
-    const relIndex = collectRelationProps(models);
-    const relByModel = relIndex.reduce((acc, r) => {
-        if (!acc[r.model])
-            acc[r.model] = [];
-        acc[r.model].push(r);
-        return acc;
-    }, {});
-    return models
-        .map((model) => buildValibotRelations(model, (relByModel[model.name] ?? []).map(({ key, targetModel, isMany }) => ({
-        key,
-        targetModel,
-        isMany,
-    })), { includeType }))
-        .filter((code) => Boolean(code))
-        .join('\n\n');
+	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) => buildValibotRelations(model, (relByModel[model.name] ?? []).map(({ key, targetModel, isMany }) => ({
+		key,
+		targetModel,
+		isMany
+	})), { includeType })).filter((code) => Boolean(code)).join("\n\n");
 };
-const getString = (v, fallback) => typeof v === 'string' ? v : Array.isArray(v) ? (v[0] ?? fallback) : fallback;
-const getBool = (v, fallback = false) => v === true || v === 'true' || (Array.isArray(v) && v[0] === 'true') ? true : fallback;
 const emit = async (options, enableRelation) => {
-    const outDir = options.generator.output?.value ?? './valibot';
-    const file = getString(options.generator.config?.file, 'index.ts') ?? 'index.ts';
-    const base = valibot(options.dmmf.datamodel.models, getBool(options.generator.config?.type), getBool(options.generator.config?.comment));
-    const relations = enableRelation
-        ? buildRelationsOnly(options.dmmf, getBool(options.generator.config?.type))
-        : '';
-    const full = [base, relations].filter(Boolean).join('\n\n');
-    const code = await fmt(full);
-    await fsp.mkdir(outDir, { recursive: true });
-    await fsp.writeFile(path.join(outDir, file), code, 'utf8');
+	const outDir = options.generator.output?.value ?? "./valibot";
+	const file = getString(options.generator.config?.file, "index.ts") ?? "index.ts";
+	const fmtResult = await fmt([valibot(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"));
+	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}`);
 };
-export const onGenerate = (options) => emit(options, options.generator.config?.relation === 'true' ||
-    (Array.isArray(options.generator.config?.relation) &&
-        options.generator.config?.relation[0] === 'true'));
+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 {
-            defaultOutput: './valibot/',
-            prettyName: 'Hekireki-Valibot',
-        };
-    },
-    onGenerate,
+	onManifest() {
+		return {
+			defaultOutput: "./valibot/",
+			prettyName: "Hekireki-Valibot"
+		};
+	},
+	onGenerate
 });
+
+//#endregion
+export { onGenerate };

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

@@ -1,3 +1,6 @@
-#!/usr/bin/env node
-import type { GeneratorOptions } from '@prisma/generator-helper';
-export declare const onGenerate: (options: GeneratorOptions) => Promise<void>;
+import { GeneratorOptions } from "@prisma/generator-helper";
+
+//#region src/generator/zod/index.d.ts
+declare const onGenerate: (options: GeneratorOptions) => Promise<void>;
+//#endregion
+export { onGenerate };

package/dist/generator/zod/index.js

@@ -1,64 +1,106 @@
 #!/usr/bin/env node
-import fsp from 'node:fs/promises';
-import path from 'node:path';
-import pkg from '@prisma/generator-helper';
-import { fmt } from '../../shared/format/index.js';
-import { collectRelationProps } from '../../shared/helper/relations.js';
-import { buildZodRelations } from './generator/schema.js';
-import { zod } from './generator/zod.js';
+import { a as getString, i as getBool, n as validationSchemas, o as fmt, r as parseDocumentWithoutAnnotations, t as schemaFromFields } from "../../utils-CXBzdZih.js";
+import { n as writeFile, t as mkdir } from "../../fsp-DYtOxLN_.js";
+import { t as collectRelationProps } from "../../relations-CxeKj9KD.js";
+import path from "node:path";
+import pkg from "@prisma/generator-helper";
+import { makePropertiesGenerator, makeValidationExtractor, makeZodInfer } from "utils-lab";
+
+//#region src/generator/zod/generator/schema.ts
+function buildZodRelations(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 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}`;
+}
+/**
+* Generate Zod schema
+* @param modelName - The name of the model
+* @param fields - The fields of the model
+* @param config - The configuration for the generator
+* @returns The generated Zod schema
+*/
+function schema(modelName, fields) {
+	return `export const ${modelName}Schema = z.object({\n${fields}\n})`;
+}
+
+//#endregion
+//#region src/generator/zod/generator/schemas.ts
+/**
+* Creates Zod schemas from model fields.
+*
+* @param modelFields - The fields of the model
+* @param comment - Whether to include comments in the generated code
+* @returns The generated Zod schemas
+*/
+function schemas(modelFields, comment) {
+	return schemaFromFields(modelFields, comment, schema, makePropertiesGenerator("z"));
+}
+
+//#endregion
+//#region src/generator/zod/generator/zod.ts
+/**
+* Creates Zod schemas and types from models.
+*
+* @param models - The models to generate the Zod schemas and types for
+* @param type - Whether to generate types
+* @param comment - Whether to include comments in the generated code
+* @param zodVersion - The Zod version/variant to use
+* @returns The generated Zod schemas and types
+*/
+function zod(models, type, comment, zodVersion) {
+	return validationSchemas(models, type, comment, {
+		importStatement: zodVersion === "mini" ? `import * as z from 'zod/mini'` : zodVersion === "@hono/zod-openapi" ? `import { z } from '@hono/zod-openapi'` : `import * as z from 'zod'`,
+		annotationPrefix: "@z.",
+		parseDocument: parseDocumentWithoutAnnotations,
+		extractValidation: makeValidationExtractor("@z."),
+		inferType: makeZodInfer,
+		schemas
+	});
+}
+
+//#endregion
+//#region src/generator/zod/index.ts
 const { generatorHandler } = pkg;
 const buildRelationsOnly = (dmmf, includeType) => {
-    const models = dmmf.datamodel.models;
-    const relIndex = collectRelationProps(models);
-    const relByModel = relIndex.reduce((acc, r) => {
-        if (!acc[r.model])
-            acc[r.model] = [];
-        acc[r.model].push(r);
-        return acc;
-    }, {});
-    const blocks = models
-        .map((model) => {
-        const relProps = (relByModel[model.name] ?? []).map(({ key, targetModel, isMany }) => ({
-            key,
-            targetModel,
-            isMany,
-        }));
-        if (relProps.length === 0)
-            return '';
-        const schema = buildZodRelations(model, relProps);
-        const typeLine = includeType
-            ? `\n\nexport type ${model.name}Relations = z.infer<typeof ${model.name}RelationsSchema>`
-            : '';
-        return `${schema}${typeLine}`;
-    })
-        .filter(Boolean);
-    return blocks.join('\n\n');
+	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) => {
+		const relProps = (relByModel[model.name] ?? []).map(({ key, targetModel, isMany }) => ({
+			key,
+			targetModel,
+			isMany
+		}));
+		if (relProps.length === 0) return "";
+		return `${buildZodRelations(model, relProps)}${includeType ? `\n\nexport type ${model.name}Relations = z.infer<typeof ${model.name}RelationsSchema>` : ""}`;
+	}).filter(Boolean).join("\n\n");
 };
-const getString = (v, fallback) => typeof v === 'string' ? v : Array.isArray(v) ? (v[0] ?? fallback) : fallback;
-const getBool = (v, fallback = false) => v === true || v === 'true' || (Array.isArray(v) && v[0] === 'true') ? true : fallback;
 const emit = async (options, enableRelation) => {
-    const outDir = options.generator.output?.value ?? './zod';
-    const file = getString(options.generator.config?.file, 'index.ts') ?? 'index.ts';
-    const zodVersion = getString(options.generator.config?.zod, 'v4');
-    const base = zod(options.dmmf.datamodel.models, getBool(options.generator.config?.type), getBool(options.generator.config?.comment), zodVersion);
-    // Respect the `type` flag when generating relation schemas
-    const relations = enableRelation
-        ? buildRelationsOnly(options.dmmf, getBool(options.generator.config?.type))
-        : '';
-    const full = [base, relations].filter(Boolean).join('\n\n');
-    const code = await fmt(full);
-    await fsp.mkdir(outDir, { recursive: true });
-    await fsp.writeFile(path.join(outDir, file), code, 'utf8');
+	const outDir = options.generator.output?.value ?? "./zod";
+	const file = getString(options.generator.config?.file, "index.ts") ?? "index.ts";
+	const zodVersion = getString(options.generator.config?.zod, "v4");
+	const fmtResult = await fmt([zod(options.dmmf.datamodel.models, getBool(options.generator.config?.type), getBool(options.generator.config?.comment), zodVersion), enableRelation ? buildRelationsOnly(options.dmmf, getBool(options.generator.config?.type)) : ""].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}`);
 };
-export const onGenerate = (options) => emit(options, options.generator.config?.relation === 'true' ||
-    (Array.isArray(options.generator.config?.relation) &&
-        options.generator.config?.relation[0] === 'true'));
+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 {
-            defaultOutput: './zod/',
-            prettyName: 'Hekireki-Zod',
-        };
-    },
-    onGenerate,
+	onManifest() {
+		return {
+			defaultOutput: "./zod/",
+			prettyName: "Hekireki-Zod"
+		};
+	},
+	onGenerate
 });
+
+//#endregion
+export { onGenerate };

package/dist/relations-CxeKj9KD.js

@@ -0,0 +1,12 @@
+//#region src/shared/helper/relations.ts
+function collectRelationProps(models) {
+	return models.flatMap((m) => m.fields.filter((f) => f.kind === "object").map((f) => ({
+		model: m.name,
+		key: f.name,
+		targetModel: f.type,
+		isMany: f.isList
+	})));
+}
+
+//#endregion
+export { collectRelationProps as t };

package/dist/utils-CXBzdZih.js

@@ -0,0 +1,134 @@
+import path from "node:path";
+import { format } from "oxfmt";
+
+//#region src/shared/format/index.ts
+async function fmt(input) {
+	const { code, errors } = await format("<stdin>.ts", input, {
+		printWidth: 100,
+		singleQuote: true,
+		semi: false
+	});
+	if (errors.length > 0) return {
+		ok: false,
+		error: errors.map((e) => e.message).join("\n")
+	};
+	return {
+		ok: true,
+		value: code
+	};
+}
+
+//#endregion
+//#region src/shared/generator/index.ts
+/**
+* Extract a string value from generator config.
+* Handles both single string and array of strings.
+*/
+const getString = (v, fallback) => typeof v === "string" ? v : Array.isArray(v) ? v[0] ?? fallback : fallback;
+/**
+* Extract a boolean value from generator config.
+* Accepts true, 'true', or ['true'] as truthy values.
+*/
+const getBool = (v, fallback = false) => v === true || v === "true" || Array.isArray(v) && v[0] === "true" ? true : fallback;
+
+//#endregion
+//#region src/shared/helper/document-parser.ts
+/**
+* All annotation prefixes used by hekireki generators.
+*/
+const ANNOTATION_PREFIXES = [
+	"@z.",
+	"@v.",
+	"@a.",
+	"@e."
+];
+/**
+* Parse documentation and filter out all annotation lines.
+* This ensures that annotations from other libraries don't appear in comments.
+*
+* @param documentation - The documentation string from Prisma field
+* @returns Array of comment lines without any annotations
+*/
+function parseDocumentWithoutAnnotations(documentation) {
+	if (!documentation) return [];
+	return documentation.split("\n").map((line) => line.trim()).filter((line) => {
+		return !ANNOTATION_PREFIXES.some((prefix) => line.startsWith(prefix));
+	}).filter((line) => line.length > 0);
+}
+
+//#endregion
+//#region src/shared/utils/index.ts
+/**
+* Group valid fields by their model name.
+*
+* @param validFields - An array of field objects with validation metadata.
+* @returns An object mapping each model name to its corresponding array of fields.
+*/
+function groupByModel(validFields) {
+	const grouped = {};
+	for (const field of validFields) {
+		if (!grouped[field.modelName]) grouped[field.modelName] = [];
+		grouped[field.modelName] = [...grouped[field.modelName], field];
+	}
+	return grouped;
+}
+/**
+* Extract fields with validation from a nested array of model fields.
+*
+* @param modelFields - A nested array of model field definitions.
+* @returns A flat array of fields that include a non-null `validation` property.
+*/
+function isFields(modelFields) {
+	return modelFields.flat().filter((field) => field.validation !== null);
+}
+/**
+* Creates schema from model fields.
+*
+* @param modelFields - The list of model fields with metadata.
+* @param comment - Whether to include documentation comments.
+* @param schemaBuilder - Function to build the schema from modelName and fields.
+* @returns The generated schema string.
+*/
+function schemaFromFields(modelFields, comment, schemaBuilder, propertiesGenerator) {
+	const modelName = modelFields[0].modelName;
+	const modelDoc = modelFields[0].documentation || "";
+	const fields = propertiesGenerator(modelFields, comment);
+	if (!(modelDoc || !comment)) return schemaBuilder(modelName, fields);
+	return schemaBuilder(modelName, fields);
+}
+/**
+* Creates validation schemas for models.
+*
+* @param models - The models to generate schemas for
+* @param type - Whether to generate types
+* @param comment - Whether to include comments
+* @param config - Configuration for the specific library
+* @returns The generated schemas and types
+*/
+function validationSchemas(models, type, comment, config) {
+	const modelFields = models.map((model) => ({
+		documentation: model.documentation ?? "",
+		name: model.name,
+		fields: model.fields
+	})).map((model) => {
+		return model.fields.map((field) => ({
+			documentation: model.documentation,
+			modelName: model.name,
+			fieldName: field.name,
+			comment: config.parseDocument(field.documentation),
+			validation: config.extractValidation(field.documentation)
+		}));
+	});
+	const schemaResults = Object.values(groupByModel(isFields(modelFields))).map((fields) => ({
+		schema: config.schemas(fields, comment),
+		inferType: type ? config.inferType(fields[0].modelName) : ""
+	}));
+	return [
+		config.importStatement,
+		"",
+		schemaResults.flatMap(({ schema, inferType }) => [schema, inferType].filter(Boolean)).join("\n\n")
+	].join("\n");
+}
+
+//#endregion
+export { getString as a, getBool as i, validationSchemas as n, fmt as o, parseDocumentWithoutAnnotations as r, schemaFromFields as t };

package/package.json

@@ -1,15 +1,18 @@
 {
   "name": "hekireki",
   "type": "module",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "license": "MIT",
-  "description": "Hekireki is a tool that generates validation schemas for Zod and Valibot, as well as ER diagrams, from Prisma schemas annotated with comments.",
+  "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": [
     "prisma",
     "zod",
     "valibot",
+    "arktype",
+    "effect",
     "mermaid",
-    "ecto"
+    "ecto",
+    "dbml"
   ],
   "homepage": "https://github.com/nakita628/hekireki",
   "publishConfig": {
@@ -22,8 +25,6 @@
   "bugs": {
     "url": "https://github.com/nakita628/hekireki/issues"
   },
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
   "files": [
     "dist"
   ],
@@ -31,29 +32,40 @@
     "hekireki-zod": "dist/generator/zod/index.js",
     "hekireki-valibot": "dist/generator/valibot/index.js",
     "hekireki-mermaid-er": "dist/generator/mermaid-er/index.js",
-    "hekireki-ecto": "dist/generator/ecto/index.js"
+    "hekireki-ecto": "dist/generator/ecto/index.js",
+    "hekireki-arktype": "dist/generator/arktype/index.js",
+    "hekireki-effect": "dist/generator/effect/index.js",
+    "hekireki-dbml": "dist/generator/dbml/index.js",
+    "hekireki-svg": "dist/generator/svg/index.js"
   },
   "scripts": {
     "generate": "prisma generate",
     "deps": "rm -rf node_modules && pnpm install",
-    "build": "rm -rf ./dist/* && tsc",
+    "build": "tsdown",
     "typecheck": "tsc --noEmit",
     "test": "vitest run",
     "coverage": "vitest run --coverage",
     "release": "npm pkg fix && pnpm build && npm publish"
   },
   "dependencies": {
-    "@prisma/generator-helper": "^6.10.1",
-    "prettier": "^3.6.2"
+    "@prisma/generator-helper": "^7.0.1",
+    "@resvg/resvg-js": "^2.6.2",
+    "@softwaretechnik/dbml-renderer": "^1.0.31",
+    "oxfmt": "^0.27.0",
+    "utils-lab": "^0.0.2"
   },
   "devDependencies": {
-    "@prisma/client": "^6.10.1",
-    "@types/node": "^22.18.0",
-    "@vitest/coverage-v8": "^3.2.4",
-    "prisma": "^6.10.1",
-    "tsx": "^4.20.3",
-    "valibot": "1.1.0",
-    "vitest": "^3.2.4",
-    "zod": "^4.0.5"
+    "@prisma/client": "^7.0.1",
+    "@types/node": "^24.10.1",
+    "@typescript/native-preview": "7.0.0-dev.20260130.1",
+    "@vitest/coverage-v8": "^4.0.14",
+    "arktype": "^2.1.29",
+    "effect": "^3.19.15",
+    "prisma": "^7.0.1",
+    "tsdown": "^0.20.1",
+    "tsx": "^4.20.6",
+    "valibot": "1.2.0",
+    "vitest": "^4.0.14",
+    "zod": "^4.1.13"
   }
 }

package/dist/generator/ecto/generator/ecto.d.ts

@@ -1,3 +0,0 @@
-import type { DMMF } from '@prisma/generator-helper';
-export declare function ectoSchemas(models: readonly DMMF.Model[], app: string | string[]): string;
-export declare function writeEctoSchemasToFiles(models: readonly DMMF.Model[], app: string | string[], outDir: string): Promise<void>;