hekireki 0.4.2 → 0.5.0

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

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

package/dist/generator/ecto/index.js

@@ -1,18 +1,155 @@
 #!/usr/bin/env node
-import pkg from '@prisma/generator-helper';
-import { writeEctoSchemasToFiles } from './generator/ecto.js';
+import { n as writeFile, t as mkdir } from "../../fsp-DYtOxLN_.js";
+import { join } from "node:path";
+import pkg from "@prisma/generator-helper";
+import { makeSnakeCase } from "utils-lab";
+
+//#region src/generator/ecto/utils/prisma-type-to-ecto-type.ts
+function prismaTypeToEctoType(type) {
+	if (type === "Int") return "integer";
+	if (type === "String") return "string";
+	if (type === "Boolean") return "boolean";
+	if (type === "DateTime") return "utc_datetime";
+	return "string";
+}
+
+//#endregion
+//#region src/generator/ecto/generator/ecto.ts
+function getPrimaryKeyConfig(field) {
+	if (field.type === "String" && field.default && typeof field.default === "object" && "name" in field.default && field.default.name === "uuid") return {
+		line: "@primary_key {:id, :binary_id, autogenerate: true}",
+		typeSpec: "Ecto.UUID.t()",
+		omitIdFieldInSchema: true
+	};
+	return {
+		line: "@primary_key false",
+		typeSpec: "String.t()",
+		omitIdFieldInSchema: false
+	};
+}
+function getFieldDefaultOption(field) {
+	const def = field.default;
+	if (def === void 0 || def === null) return null;
+	if (typeof def === "string") return `default: "${def}"`;
+	if (typeof def === "number" || typeof def === "boolean") return `default: ${def}`;
+	return null;
+}
+function ectoTypeToTypespec(type) {
+	switch (type) {
+		case "string": return "String.t()";
+		case "integer": return "integer()";
+		case "float": return "float()";
+		case "boolean": return "boolean()";
+		case "binary_id": return "Ecto.UUID.t()";
+		case "naive_datetime": return "NaiveDateTime.t()";
+		case "utc_datetime": return "DateTime.t()";
+		default: return "term()";
+	}
+}
+function buildTimestampsLine(fields) {
+	const insertedAliases = [
+		"inserted_at",
+		"created_at",
+		"createdAt"
+	];
+	const updatedAliases = [
+		"updated_at",
+		"modified_at",
+		"updatedAt",
+		"modifiedAt"
+	];
+	const inserted = fields.find((f) => insertedAliases.includes(f.name));
+	const updated = fields.find((f) => updatedAliases.includes(f.name));
+	const exclude = /* @__PURE__ */ new Set();
+	if (inserted) exclude.add(inserted.name);
+	if (updated) exclude.add(updated.name);
+	if (!(inserted || updated)) return {
+		line: null,
+		exclude
+	};
+	if (inserted?.name === "inserted_at" && updated?.name === "updated_at") return {
+		line: "    timestamps()",
+		exclude
+	};
+	return {
+		line: `    timestamps(inserted_at: :${inserted?.name ?? "inserted_at"}, updated_at: :${updated?.name ?? "updated_at"})`,
+		exclude
+	};
+}
+function ectoSchemas(models, app) {
+	return models.map((model) => {
+		const idField = model.fields.find((f) => f.isId);
+		if (!idField) return "";
+		const pk = getPrimaryKeyConfig(idField);
+		const fields = model.fields.map((f) => ({ ...f }));
+		const { line: timestampsLine, exclude: timestampsExclude } = buildTimestampsLine(fields);
+		const schemaFieldsRaw = fields.filter((f) => !(f.relationName || f.isId && pk.omitIdFieldInSchema || timestampsExclude.has(f.name)));
+		const typeSpecFields = [`id: ${pk.typeSpec}`, ...schemaFieldsRaw.map((f) => `${f.name}: ${ectoTypeToTypespec(prismaTypeToEctoType(f.type))}`)];
+		const typeSpecLines = [
+			"  @type t :: %__MODULE__{",
+			...typeSpecFields.map((line, i) => {
+				return `          ${line}${i === typeSpecFields.length - 1 ? "" : ","}`;
+			}),
+			"        }"
+		];
+		const schemaFields = schemaFieldsRaw.map((f) => {
+			const type = f.isId ? "binary_id" : prismaTypeToEctoType(f.type);
+			const primary = f.isId && !pk.omitIdFieldInSchema ? ", primary_key: true" : "";
+			const defaultOpt = getFieldDefaultOption(f);
+			const defaultClause = defaultOpt ? `, ${defaultOpt}` : "";
+			return `    field(:${f.name}, :${type}${primary}${defaultClause})`;
+		});
+		return [
+			`defmodule ${app}.${model.name} do`,
+			"  use Ecto.Schema",
+			"",
+			`  ${pk.line}`,
+			"",
+			...typeSpecLines,
+			"",
+			`  schema "${makeSnakeCase(model.name)}" do`,
+			...schemaFields,
+			...timestampsLine ? [timestampsLine] : [],
+			"  end",
+			"end"
+		].join("\n");
+	}).filter(Boolean).join("\n\n");
+}
+async function writeEctoSchemasToFiles(models, app, outDir) {
+	const mkdirResult = await mkdir(outDir);
+	if (!mkdirResult.ok) return mkdirResult;
+	for (const model of models) {
+		const code = ectoSchemas([model], app);
+		if (!code.trim()) continue;
+		const filePath = join(outDir, `${makeSnakeCase(model.name)}.ex`);
+		const writeResult = await writeFile(filePath, code);
+		if (!writeResult.ok) return writeResult;
+		console.log(`✅ wrote ${filePath}`);
+	}
+	return {
+		ok: true,
+		value: void 0
+	};
+}
+
+//#endregion
+//#region src/generator/ecto/index.ts
 const { generatorHandler } = pkg;
-export async function main(options) {
-    const output = options.generator.output?.value ?? './ecto';
-    const app = options.generator.config?.app ?? 'MyApp';
-    await writeEctoSchemasToFiles(options.dmmf.datamodel.models, app, output);
+async function main(options) {
+	const output = options.generator.output?.value ?? "./ecto";
+	const app = options.generator.config?.app ?? "MyApp";
+	const result = await writeEctoSchemasToFiles(options.dmmf.datamodel.models, app, output);
+	if (!result.ok) throw new Error(`Failed to write Ecto schemas: ${result.error}`);
 }
 generatorHandler({
-    onManifest() {
-        return {
-            defaultOutput: './ecto/',
-            prettyName: 'Hekireki-Ecto',
-        };
-    },
-    onGenerate: main,
+	onManifest() {
+		return {
+			defaultOutput: "./ecto/",
+			prettyName: "Hekireki-Ecto"
+		};
+	},
+	onGenerate: main
 });
+
+//#endregion
+export { main };

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

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

package/dist/generator/effect/index.js

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+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 path from "node:path";
+import pkg from "@prisma/generator-helper";
+import { makeValidationExtractor } from "utils-lab";
+
+//#region src/generator/effect/generator/schema.ts
+/**
+* Generate Effect Schema
+* @param modelName - The name of the model
+* @param fields - The fields of the model
+* @returns The generated Effect Schema
+*/
+function schema(modelName, fields) {
+	return `export const ${modelName}Schema = Schema.Struct({\n${fields}\n})`;
+}
+
+//#endregion
+//#region src/generator/effect/generator/schemas.ts
+/**
+* Generate properties for Effect Schema.
+*/
+function effectPropertiesGenerator(fields, comment) {
+	return fields.map((field) => {
+		return `${comment && field.comment.length > 0 ? `${field.comment.map((c) => `  /** ${c} */`).join("\n")}\n` : ""}  ${field.fieldName}: ${field.validation ?? "Schema.Unknown"},`;
+	}).join("\n");
+}
+/**
+* Creates Effect schemas from model fields.
+*
+* @param modelFields - The fields of the model
+* @param comment - Whether to include comments in the generated code
+* @returns The generated Effect schemas
+*/
+function schemas(modelFields, comment) {
+	return schemaFromFields(modelFields, comment, schema, effectPropertiesGenerator);
+}
+
+//#endregion
+//#region src/generator/effect/generator/effect.ts
+/**
+* Generate Effect Schema infer type statement.
+* @param modelName - The name of the model
+* @returns The generated type inference statement
+*/
+function makeEffectInfer(modelName) {
+	return `export type ${modelName} = Schema.Schema.Type<typeof ${modelName}Schema>`;
+}
+/**
+* Creates Effect schemas and types from models.
+*
+* @param models - The models to generate the Effect schemas and types for
+* @param type - Whether to generate types
+* @param comment - Whether to include comments in the generated code
+* @returns The generated Effect schemas and types
+*/
+function effect(models, type, comment) {
+	return validationSchemas(models, type, comment, {
+		importStatement: `import { Schema } from 'effect'`,
+		annotationPrefix: "@e.",
+		parseDocument: parseDocumentWithoutAnnotations,
+		extractValidation: makeValidationExtractor("@e."),
+		inferType: makeEffectInfer,
+		schemas
+	});
+}
+
+//#endregion
+//#region src/generator/effect/index.ts
+const { generatorHandler } = pkg;
+const emit = async (options) => {
+	const outDir = options.generator.output?.value ?? "./effect";
+	const file = getString(options.generator.config?.file, "index.ts") ?? "index.ts";
+	const fmtResult = await fmt(effect(options.dmmf.datamodel.models, getBool(options.generator.config?.type), getBool(options.generator.config?.comment)));
+	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);
+generatorHandler({
+	onManifest() {
+		return {
+			defaultOutput: "./effect/",
+			prettyName: "Hekireki-Effect"
+		};
+	},
+	onGenerate
+});
+
+//#endregion
+export { onGenerate };

package/dist/generator/mermaid-er/index.d.ts

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

package/dist/generator/mermaid-er/index.js

@@ -1,26 +1,141 @@
 #!/usr/bin/env node
-import fsp from 'node:fs/promises';
-import pkg from '@prisma/generator-helper';
-import { erContent } from './generator/er-content.js';
+import { n as writeFile, t as mkdir } from "../../fsp-DYtOxLN_.js";
+import pkg from "@prisma/generator-helper";
+
+//#region src/generator/mermaid-er/helper/extract-relations-from-dmmf.ts
+const RELATIONSHIPS = {
+	"zero-one": "|o",
+	one: "||",
+	"zero-many": "}o",
+	many: "}|"
+};
+/**
+* Extract Mermaid ER diagram relation lines from Prisma DMMF models.
+* This function automatically detects relations from field definitions.
+*
+* @param models - The list of Prisma DMMF models.
+* @returns An array of Mermaid ER diagram relation lines.
+*/
+function extractRelationsFromDmmf(models) {
+	const relations = [];
+	for (const model of models) for (const field of model.fields) {
+		if (field.kind !== "object" || !field.relationFromFields || field.relationFromFields.length === 0) continue;
+		const toModel = model.name;
+		const fromModel = field.type;
+		const toField = field.relationFromFields[0];
+		const fromField = field.relationToFields?.[0] ?? "id";
+		const fromCardinality = "one";
+		const inverseField = models.find((m) => m.name === fromModel)?.fields.find((f) => f.relationName === field.relationName && f.name !== field.name);
+		let toCardinality;
+		if (inverseField?.isList) toCardinality = field.isRequired ? "many" : "zero-many";
+		else toCardinality = field.isRequired ? "one" : "zero-one";
+		const relationLine = `    ${fromModel} ${RELATIONSHIPS[fromCardinality]}--${RELATIONSHIPS[toCardinality]} ${toModel} : "(${fromField}) - (${toField})"`;
+		relations.push(relationLine);
+	}
+	return relations;
+}
+
+//#endregion
+//#region src/generator/mermaid-er/utils/index.ts
+/**
+* Remove duplicate relation lines from an array of Mermaid ER diagram relations.
+*
+* @param relations - An array of relation lines (e.g., generated from `relationLine`).
+* @returns A new array with duplicates removed, preserving insertion order.
+*/
+function removeDuplicateRelations(relations) {
+	return [...new Set(relations)];
+}
+
+//#endregion
+//#region src/generator/mermaid-er/generator/model-fields.ts
+const ZOD_ANNOTATION = "@z.";
+const VALIBOT_ANNOTATION = "@v.";
+const RELATION_ANNOTATION = "@relation";
+/**
+* Convert Prisma type to lowercase Mermaid ER type.
+*/
+function toMermaidType(prismaType) {
+	return prismaType.toLowerCase();
+}
+/**
+* Generate Mermaid ER field lines from a Prisma model.
+*
+* @param model - A Prisma DMMF model definition.
+* @returns An array of strings representing each field in Mermaid ER syntax, excluding relation fields and annotations.
+*/
+function modelFields(model) {
+	const fkFields = new Set(model.fields.filter((f) => f.relationFromFields && f.relationFromFields.length > 0).flatMap((f) => f.relationFromFields ?? []));
+	return model.fields.map((field) => {
+		if (field.relationName) return null;
+		const commentPart = field.documentation ? field.documentation.split("\n").filter((line) => !(line.includes(ZOD_ANNOTATION) || line.includes(VALIBOT_ANNOTATION) || line.includes(RELATION_ANNOTATION))).join("\n").trim() : "";
+		const keyMarker = field.isId ? "PK" : fkFields.has(field.name) ? "FK" : "";
+		const keyPart = keyMarker ? ` ${keyMarker}` : "";
+		return `        ${toMermaidType(field.type)} ${field.name}${keyPart}${commentPart ? ` "${commentPart}"` : ""}`;
+	}).filter((field) => field !== null);
+}
+
+//#endregion
+//#region src/generator/mermaid-er/generator/model-info.ts
+/**
+* Generate Mermaid ER diagram model block from a Prisma model.
+*
+* @param model - A Prisma DMMF model definition.
+* @returns An array of strings representing the model block in Mermaid ER syntax.
+*/
+function modelInfo(model) {
+	return [
+		`    ${model.name} {`,
+		...modelFields(model),
+		"    }"
+	];
+}
+
+//#endregion
+//#region src/generator/mermaid-er/generator/er-content.ts
+const ER_HEADER = ["```mermaid", "erDiagram"];
+const ER_FOOTER = ["```"];
+/**
+* Generate Mermaid ER diagram content from Prisma models.
+*
+* @param models - The list of Prisma DMMF models.
+* @returns An array of Mermaid ER diagram lines.
+*/
+function erContent(models) {
+	const uniqueRelations = removeDuplicateRelations(extractRelationsFromDmmf(models));
+	const modelInfos = models.flatMap(modelInfo);
+	return [
+		...ER_HEADER,
+		...uniqueRelations,
+		...modelInfos,
+		...ER_FOOTER
+	];
+}
+
+//#endregion
+//#region src/generator/mermaid-er/index.ts
 const { generatorHandler } = pkg;
-export async function main(options) {
-    const content = erContent(options.dmmf.datamodel.models);
-    const output = options.generator.output?.value ?? './mermaid-er';
-    const file = options.generator.config?.file ?? 'ER.md';
-    // Handle case where output is a file path (contains extension)
-    const isOutputFile = output.includes('.');
-    const outputDir = isOutputFile ? '.' : output;
-    const outputFile = isOutputFile ? output : `${output}/${file}`;
-    await fsp.mkdir(outputDir, { recursive: true });
-    await fsp.writeFile(outputFile, content.join('\n'), { encoding: 'utf-8' });
+async function main(options) {
+	const content = erContent(options.dmmf.datamodel.models);
+	const output = options.generator.output?.value ?? "./mermaid-er";
+	const file = options.generator.config?.file ?? "ER.md";
+	const isOutputFile = output.includes(".");
+	const outputDir = isOutputFile ? "." : output;
+	const outputFile = isOutputFile ? output : `${output}/${file}`;
+	const mkdirResult = await mkdir(outputDir);
+	if (!mkdirResult.ok) throw new Error(`Failed to create directory: ${mkdirResult.error}`);
+	const writeResult = await writeFile(outputFile, content.join("\n"));
+	if (!writeResult.ok) throw new Error(`Failed to write file: ${writeResult.error}`);
 }
-// prisma generator handler
 generatorHandler({
-    onManifest() {
-        return {
-            defaultOutput: './mermaid-er',
-            prettyName: 'Hekireki-ER',
-        };
-    },
-    onGenerate: main,
+	onManifest() {
+		return {
+			defaultOutput: "./mermaid-er",
+			prettyName: "Hekireki-ER"
+		};
+	},
+	onGenerate: main
 });
+
+//#endregion
+export { main };

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

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

package/dist/generator/svg/index.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+import { n as writeFile, r as writeFileBinary, t as mkdir } from "../../fsp-DYtOxLN_.js";
+import { t as dbmlContent } from "../../dbml-content-D3ioOw2D.js";
+import pkg from "@prisma/generator-helper";
+import { Resvg } from "@resvg/resvg-js";
+import { run } from "@softwaretechnik/dbml-renderer";
+
+//#region src/generator/svg/index.ts
+const { generatorHandler } = pkg;
+/**
+* Get string value from config
+*/
+function getStringValue(value) {
+	if (value === void 0) return void 0;
+	return Array.isArray(value) ? value[0] : value;
+}
+/**
+* Get boolean option from config
+*/
+function getBoolOption(config, key, defaultValue) {
+	const value = getStringValue(config[key]);
+	if (value === void 0) return defaultValue;
+	return value.toLowerCase() !== "false";
+}
+/**
+* Get file extension for format
+*/
+function getExtension(format) {
+	switch (format) {
+		case "png": return "png";
+		case "dot": return "dot";
+		default: return "svg";
+	}
+}
+async function main(options) {
+	const { config } = options.generator;
+	const mapToDbSchema = getBoolOption(config, "mapToDbSchema", false);
+	const includeRelationFields = getBoolOption(config, "includeRelationFields", false);
+	const format = getStringValue(config.format)?.toLowerCase() || "png";
+	const dbml = dbmlContent(options.dmmf.datamodel, mapToDbSchema, includeRelationFields);
+	const output = options.generator.output?.value ?? "./docs";
+	const defaultFile = `er-diagram.${getExtension(format)}`;
+	const file = getStringValue(config.file) ?? defaultFile;
+	const isOutputFile = output.includes(".");
+	const outputDir = isOutputFile ? "." : output;
+	const outputFile = isOutputFile ? output : `${output}/${file}`;
+	const mkdirResult = await mkdir(outputDir);
+	if (!mkdirResult.ok) throw new Error(`Failed to create directory: ${mkdirResult.error}`);
+	if (format === "dot") {
+		const writeResult = await writeFile(outputFile, run(dbml, "dot"));
+		if (!writeResult.ok) throw new Error(`Failed to write file: ${writeResult.error}`);
+	} else {
+		const svg = run(dbml, "svg");
+		if (format === "png") {
+			const writeResult = await writeFileBinary(outputFile, new Resvg(svg, { font: { loadSystemFonts: true } }).render().asPng());
+			if (!writeResult.ok) throw new Error(`Failed to write file: ${writeResult.error}`);
+		} else {
+			const writeResult = await writeFile(outputFile, svg);
+			if (!writeResult.ok) throw new Error(`Failed to write file: ${writeResult.error}`);
+		}
+	}
+}
+generatorHandler({
+	onManifest() {
+		return {
+			defaultOutput: "./docs",
+			prettyName: "Hekireki-SVG"
+		};
+	},
+	onGenerate: main
+});
+
+//#endregion
+export { main };

package/dist/generator/valibot/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/valibot/index.d.ts
+declare const onGenerate: (options: GeneratorOptions) => Promise<void>;
+//#endregion
+export { onGenerate };