hekireki 0.0.1

package/dist/generator/valibot/index.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+const generator_helper_1 = require("@prisma/generator-helper");
+const generate_valibot_1 = require("./generator/generate-valibot");
+const prettier_1 = require("prettier");
+const node_fs_1 = __importDefault(require("node:fs"));
+const DEFAULT_CONFIG = {
+    output: "./valibot",
+    file: "index.ts",
+    schemaName: "PascalCase",
+    typeName: "PascalCase",
+    type: false,
+    comment: false,
+};
+async function main(options) {
+    const config = {
+        output: options.generator.output?.value ?? DEFAULT_CONFIG.output,
+        file: options.generator.config?.file ?? DEFAULT_CONFIG.file,
+        schemaName: options.generator.config?.schemaName ?? DEFAULT_CONFIG.schemaName,
+        typeName: options.generator.config?.typeName ?? DEFAULT_CONFIG.typeName,
+        type: options.generator.config?.type ?? DEFAULT_CONFIG.type,
+        comment: options.generator.config?.comment === "true",
+    };
+    const content = (0, generate_valibot_1.generateValibot)(options.dmmf.datamodel.models, config);
+    const code = await (0, prettier_1.format)(content, {
+        parser: "typescript",
+        printWidth: 100,
+        singleQuote: true,
+        semi: false,
+    });
+    if (!config.output) {
+        throw new Error("output is required");
+    }
+    if (!node_fs_1.default.existsSync(config.output)) {
+        node_fs_1.default.mkdirSync(config.output, { recursive: true });
+    }
+    const file = config.file ?? "index.ts";
+    const filePath = `${config.output}/${file}`;
+    node_fs_1.default.writeFileSync(filePath, code);
+}
+(0, generator_helper_1.generatorHandler)({
+    onManifest() {
+        return {
+            defaultOutput: "./valibot/",
+            prettyName: "Hekireki-Valibot",
+        };
+    },
+    onGenerate: main,
+});

package/dist/generator/valibot/validator/is-valibot-documentation.d.ts

@@ -0,0 +1 @@
+export declare function isValibotDocumentValidation(documentation?: string): string[];

package/dist/generator/valibot/validator/is-valibot-documentation.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValibotDocumentValidation = isValibotDocumentValidation;
+const VALIDATION_PATTERNS = ["@v."];
+function isValibotDocumentValidation(documentation) {
+    if (!documentation)
+        return [];
+    return documentation
+        .split("\n")
+        .filter((line) => !VALIDATION_PATTERNS.some((pattern) => line.includes(pattern)))
+        .map((line) => line.trim())
+        .filter(Boolean);
+}

package/dist/generator/valibot/validator/is-valibot-validation.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Check if the documentation is a Valibot validation
+ * @function isValibotValidation
+ * @param documentation
+ * @returns string | null
+ */
+export declare function isValibotValidation(documentation?: string): string | null;

package/dist/generator/valibot/validator/is-valibot-validation.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValibotValidation = isValibotValidation;
+/**
+ * Check if the documentation is a Valibot validation
+ * @function isValibotValidation
+ * @param documentation
+ * @returns string | null
+ */
+function isValibotValidation(documentation) {
+    if (!documentation)
+        return null;
+    const match = documentation.match(/@v\.(.+?)(?:\n|$)/);
+    return match ? match[1].trim() : null;
+}

package/dist/generator/zod/generator/generate-zod-infer.d.ts

@@ -0,0 +1,8 @@
+import type { Config } from "..";
+/**
+ * Generate Zod infer
+ * @param modelName - The name of the model
+ * @param config - The configuration for the generator
+ * @returns The generated Zod infer
+ */
+export declare function generateZodInfer(modelName: string, config: Config): string;

package/dist/generator/zod/generator/generate-zod-infer.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateZodInfer = generateZodInfer;
+const get_variable_name_helper_1 = require("../../../common/helper/get-variable-name-helper");
+const get_variable_schema_name_helper_1 = require("../../../common/helper/get-variable-schema-name-helper");
+/**
+ * Generate Zod infer
+ * @param modelName - The name of the model
+ * @param config - The configuration for the generator
+ * @returns The generated Zod infer
+ */
+function generateZodInfer(modelName, config) {
+    const typeName = (0, get_variable_name_helper_1.getVariableNameHelper)(modelName, config);
+    const schemaName = (0, get_variable_schema_name_helper_1.getVariableSchemaNameHelper)(modelName, config);
+    return `export type ${typeName} = z.infer<typeof ${schemaName}>`;
+}

package/dist/generator/zod/generator/generate-zod-properties.d.ts

@@ -0,0 +1,14 @@
+import type { Config } from "..";
+/**
+ * Generate Zod properties
+ * @param modelFields - The fields of the model
+ * @param config - The configuration for the generator
+ * @returns The generated Zod properties
+ */
+export declare function generateZodProperties(modelFields: {
+    documentation: string;
+    modelName: string;
+    fieldName: string;
+    validation: string | null;
+    comment: string[];
+}[], config?: Config): string;

package/dist/generator/zod/generator/generate-zod-properties.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateZodProperties = generateZodProperties;
+/**
+ * Generate Zod properties
+ * @param modelFields - The fields of the model
+ * @param config - The configuration for the generator
+ * @returns The generated Zod properties
+ */
+function generateZodProperties(modelFields, config) {
+    const fields = modelFields
+        .filter((field) => field.validation)
+        .map((field) => {
+        // @relation, @v, @z exclude
+        const cleanDoc = field.comment
+            .filter((line) => !(line.includes("@relation") ||
+            line.includes("@v") ||
+            line.includes("@z")))
+            .join("\n")
+            .trim();
+        const docComment = config?.comment && cleanDoc ? `  /**\n   * ${cleanDoc}\n   */\n` : "";
+        return `${docComment}  ${field.fieldName}: z.${field.validation}`;
+    })
+        .join(",\n");
+    return fields;
+}

package/dist/generator/zod/generator/generate-zod-schema.d.ts

@@ -0,0 +1,9 @@
+import type { Config } from "..";
+/**
+ * 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
+ */
+export declare function generateZodSchema(modelName: string, fields: string, config: Config): string;

package/dist/generator/zod/generator/generate-zod-schema.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateZodSchema = generateZodSchema;
+const get_variable_schema_name_helper_1 = require("../../../common/helper/get-variable-schema-name-helper");
+/**
+ * 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 generateZodSchema(modelName, fields, config) {
+    const schemaName = (0, get_variable_schema_name_helper_1.getVariableSchemaNameHelper)(modelName, config);
+    return `export const ${schemaName} = z.object({\n${fields}\n})`;
+}

package/dist/generator/zod/generator/generate-zod-schemas.d.ts

@@ -0,0 +1,14 @@
+import type { Config } from "..";
+/**
+ * Generate Zod schemas
+ * @param modelFields - The fields of the model
+ * @param config - The configuration for the generator
+ * @returns The generated Zod schemas
+ */
+export declare function generateZodSchemas(modelFields: {
+    documentation: string;
+    modelName: string;
+    fieldName: string;
+    validation: string | null;
+    comment: string[];
+}[], config: Config): string;

package/dist/generator/zod/generator/generate-zod-schemas.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateZodSchemas = generateZodSchemas;
+const generate_zod_properties_1 = require("./generate-zod-properties");
+const generate_zod_schema_1 = require("./generate-zod-schema");
+/**
+ * Generate Zod schemas
+ * @param modelFields - The fields of the model
+ * @param config - The configuration for the generator
+ * @returns The generated Zod schemas
+ */
+function generateZodSchemas(modelFields, config) {
+    const modelName = modelFields[0].modelName;
+    const modelDoc = modelFields[0].documentation || "";
+    const fields = (0, generate_zod_properties_1.generateZodProperties)(modelFields, config);
+    if (!(modelDoc || !config?.comment)) {
+        return (0, generate_zod_schema_1.generateZodSchema)(modelName, fields, config);
+    }
+    return `${(0, generate_zod_schema_1.generateZodSchema)(modelName, fields, config)}`;
+}

package/dist/generator/zod/generator/generate-zod.d.ts

@@ -0,0 +1,9 @@
+import type { Config } from "..";
+import type { Model } from "../../../common/type";
+/**
+ * Generate Zod schemas and types
+ * @param models - The models to generate the Zod schemas and types for
+ * @param config - The configuration for the generator
+ * @returns The generated Zod schemas and types
+ */
+export declare function generateZod(models: readonly Model[], config: Config): string;

package/dist/generator/zod/generator/generate-zod.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateZod = generateZod;
+const is_zod_documentation_1 = require("../validator/is-zod-documentation");
+const is_zod_validation_1 = require("../validator/is-zod-validation");
+const is_fields_validation_1 = require("../../../common/validator/is-fields-validation");
+const group_by_model_helper_1 = require("../../../common/helper/group-by-model-helper");
+const generate_zod_schemas_1 = require("./generate-zod-schemas");
+const generate_zod_infer_1 = require("./generate-zod-infer");
+const ZOD_IMPORT = `import { z } from 'zod'\n`;
+/**
+ * Generate Zod schemas and types
+ * @param models - The models to generate the Zod schemas and types for
+ * @param config - The configuration for the generator
+ * @returns The generated Zod schemas and types
+ */
+function generateZod(models, config) {
+    const modelInfos = models.map((model) => {
+        return {
+            documentation: model.documentation ?? "",
+            name: model.name,
+            fields: model.fields,
+        };
+    });
+    const modelFields = modelInfos.map((model) => {
+        const fields = model.fields.map((field) => ({
+            documentation: model.documentation,
+            modelName: model.name,
+            fieldName: field.name,
+            comment: (0, is_zod_documentation_1.isZodDocumentValidation)(field.documentation),
+            validation: (0, is_zod_validation_1.isZodValidation)(field.documentation),
+        }));
+        return fields;
+    });
+    // null exclude
+    const validFields = (0, is_fields_validation_1.isFieldsValidation)(modelFields);
+    // group by model
+    const groupedByModel = (0, group_by_model_helper_1.groupByModelHelper)(validFields);
+    const zods = Object.values(groupedByModel).map((fields) => {
+        return {
+            generateZodSchema: (0, generate_zod_schemas_1.generateZodSchemas)(fields, config),
+            generateZodInfer: config.type === "true"
+                ? (0, generate_zod_infer_1.generateZodInfer)(fields[0].modelName, config)
+                : "",
+        };
+    });
+    return [
+        ZOD_IMPORT,
+        "",
+        zods
+            .flatMap(({ generateZodSchema, generateZodInfer }) => [generateZodSchema, generateZodInfer].filter(Boolean))
+            .join("\n\n"),
+    ].join("\n");
+}

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

@@ -0,0 +1,10 @@
+import type { GeneratorOptions } from "@prisma/generator-helper";
+export type Config = {
+    output?: string;
+    file?: string | string[];
+    schemaName?: "PascalCase" | "camelCase" | string | string[];
+    typeName?: "PascalCase" | "camelCase" | string | string[];
+    type?: boolean | string | string[];
+    comment?: boolean | string | string[];
+};
+export declare function main(options: GeneratorOptions): Promise<void>;

package/dist/generator/zod/index.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+const generator_helper_1 = require("@prisma/generator-helper");
+const generate_zod_1 = require("./generator/generate-zod");
+const prettier_1 = require("prettier");
+const node_fs_1 = __importDefault(require("node:fs"));
+const DEFAULT_CONFIG = {
+    output: "./zod",
+    file: "index.ts",
+    schemaName: "PascalCase",
+    typeName: "PascalCase",
+    type: false,
+    comment: false,
+};
+async function main(options) {
+    const config = {
+        output: options.generator.output?.value ?? DEFAULT_CONFIG.output,
+        file: options.generator.config?.file ?? DEFAULT_CONFIG.file,
+        schemaName: options.generator.config?.schemaName ?? DEFAULT_CONFIG.schemaName,
+        typeName: options.generator.config?.typeName ?? DEFAULT_CONFIG.typeName,
+        type: options.generator.config?.type ?? DEFAULT_CONFIG.type,
+        comment: options.generator.config?.comment === "true",
+    };
+    const content = (0, generate_zod_1.generateZod)(options.dmmf.datamodel.models, config);
+    const code = await (0, prettier_1.format)(content, {
+        parser: "typescript",
+        printWidth: 100,
+        singleQuote: true,
+        semi: false,
+    });
+    if (!config.output) {
+        throw new Error("output is required");
+    }
+    if (!node_fs_1.default.existsSync(config.output)) {
+        node_fs_1.default.mkdirSync(config.output, { recursive: true });
+    }
+    const file = config.file ?? "index.ts";
+    const filePath = `${config.output}/${file}`;
+    node_fs_1.default.writeFileSync(filePath, code);
+}
+(0, generator_helper_1.generatorHandler)({
+    onManifest() {
+        return {
+            defaultOutput: "./zod/",
+            prettyName: "Hekireki-Zod",
+        };
+    },
+    onGenerate: main,
+});

package/dist/generator/zod/validator/is-zod-documentation.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Is Zod documentation
+ * @param documentation - The documentation of the field
+ * @returns The Zod documentation
+ */
+export declare function isZodDocumentValidation(documentation?: string): string[];

package/dist/generator/zod/validator/is-zod-documentation.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isZodDocumentValidation = isZodDocumentValidation;
+const VALIDATION_PATTERNS = ["@z."];
+/**
+ * Is Zod documentation
+ * @param documentation - The documentation of the field
+ * @returns The Zod documentation
+ */
+function isZodDocumentValidation(documentation) {
+    if (!documentation)
+        return [];
+    return documentation
+        .split("\n")
+        .filter((line) => !VALIDATION_PATTERNS.some((pattern) => line.includes(pattern)))
+        .map((line) => line.trim())
+        .filter(Boolean);
+}

package/dist/generator/zod/validator/is-zod-validation.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Is Zod validation
+ * @param documentation - The documentation of the field
+ * @returns The Zod validation
+ */
+export declare function isZodValidation(documentation?: string): string | null;

package/dist/generator/zod/validator/is-zod-validation.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isZodValidation = isZodValidation;
+/**
+ * Is Zod validation
+ * @param documentation - The documentation of the field
+ * @returns The Zod validation
+ */
+function isZodValidation(documentation) {
+    if (!documentation)
+        return null;
+    const match = documentation.match(/@z\.(.+?)(?:\n|$)/);
+    return match ? match[1].trim() : null;
+}

package/package.json

@@ -0,0 +1,56 @@
+{
+	"name": "hekireki",
+	"version": "0.0.1",
+	"license": "MIT",
+	"description": "Prisma generator that creates Zod and Valibot schemas with Mermaid ER diagrams from your Prisma schema.",
+	"keywords": [
+		"prisma",
+		"zod",
+		"valibot",
+		"mermaid"
+	],
+	"homepage": "https://github.com/nakita628/hekireki",
+	"publishConfig": {
+		"access": "public"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/nakita628/hekireki.git"
+	},
+	"bugs": {
+		"url": "https://github.com/nakita628/hekireki/issues"
+	},
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"files": [
+		"dist"
+	],
+	"bin": {
+		"hekireki-zod": "dist/generator/zod/index.js",
+		"hekireki-valibot": "dist/generator/valibot/index.js",
+		"hekireki-mermaid-er": "dist/generator/mermaid/index.js"
+	},
+	"scripts": {
+		"generate": "prisma generate",
+		"deps": "rm -rf node_modules && pnpm install",
+		"build": "tsc",
+		"typecheck": "tsc --noEmit",
+		"test": "vitest run",
+		"coverage": "vitest run --coverage",
+		"release": "npm pkg fix && npm publish"
+	},
+	"devDependencies": {
+		"@types/node": "^22.13.10",
+		"@vitest/coverage-v8": "^3.0.8",
+		"prisma": "^6.5.0",
+		"@prisma/client": "6.5.0",
+		"tsx": "^4.19.3",
+		"valibot": "1.0.0-rc.3",
+		"vitest": "^3.0.8",
+		"zod": "^3.24.2"
+	},
+	"dependencies": {
+		"@prisma/generator-helper": "^6.5.0",
+		"prettier": "^3.5.3"
+	}
+}