hekireki 0.0.4 → 0.0.6

package/dist/generator/mermaid/validator/extract-relations.js

@@ -5,24 +5,21 @@ const generate_relation_line_1 = require("../generator/generate-relation-line");
 const parse_relation_1 = require("./parse-relation");
 /**
  * extract relations from model
- * @function extractRelations
- * @param model
- * @returns
+ * @param { Model } model
+ * @returns { readonly string[] }
  */
 function extractRelations(model) {
-	const relations = [];
-	// @r annotation
-	if (model.documentation) {
-		const annotationRelations = model.documentation
-			.split("\n")
-			.map((line) => {
-				const relation = (0, parse_relation_1.parseRelation)(line);
-				return relation
-					? (0, generate_relation_line_1.generateRelationLine)(relation)
-					: null;
-			})
-			.filter((line) => line !== null);
-		relations.push(...annotationRelations);
-	}
-	return relations;
+    const relations = [];
+    // @relation annotation
+    if (model.documentation) {
+        const annotationRelations = model.documentation
+            .split("\n")
+            .map((line) => {
+            const relation = (0, parse_relation_1.parseRelation)(line);
+            return relation ? (0, generate_relation_line_1.generateRelationLine)(relation) : null;
+        })
+            .filter((line) => line !== null);
+        relations.push(...annotationRelations);
+    }
+    return relations;
 }

package/dist/generator/mermaid/validator/is-relation.d.ts

@@ -1,2 +1,7 @@
 import type { RelationType } from "../type";
+/**
+ * check if the value is a valid relation
+ * @param { unknown } value
+ * @returns { boolean }
+ */
 export declare function isRelation(value: unknown): value is RelationType;

package/dist/generator/mermaid/validator/is-relation.js

@@ -2,31 +2,36 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isRelation = isRelation;
 const VALID_RELATIONS = new Set([
-	"one-to-one",
-	"one-to-many",
-	"many-to-one",
-	"many-to-many",
-	"one-to-zero-one",
-	"zero-one-to-one",
-	"zero-to-one",
-	"zero-to-zero-one",
-	"zero-to-many",
-	"zero-one-to-many",
-	"many-to-zero-one",
-	"one-to-one-optional",
-	"one-to-many-optional",
-	"many-to-one-optional",
-	"many-to-many-optional",
-	"one-to-zero-one-optional",
-	"zero-one-to-one-optional",
-	"zero-to-one-optional",
-	"zero-to-many-optional",
-	"zero-one-to-many-optional",
-	"many-to-zero-one-optional",
-	"many-to-zero-many",
-	"zero-many-to-many",
-	"zero-many-to-zero-many",
+    "one-to-one",
+    "one-to-many",
+    "many-to-one",
+    "many-to-many",
+    "one-to-zero-one",
+    "zero-one-to-one",
+    "zero-to-one",
+    "zero-to-zero-one",
+    "zero-to-many",
+    "zero-one-to-many",
+    "many-to-zero-one",
+    "one-to-one-optional",
+    "one-to-many-optional",
+    "many-to-one-optional",
+    "many-to-many-optional",
+    "one-to-zero-one-optional",
+    "zero-one-to-one-optional",
+    "zero-to-one-optional",
+    "zero-to-many-optional",
+    "zero-one-to-many-optional",
+    "many-to-zero-one-optional",
+    "many-to-zero-many",
+    "zero-many-to-many",
+    "zero-many-to-zero-many",
 ]);
+/**
+ * check if the value is a valid relation
+ * @param { unknown } value
+ * @returns { boolean }
+ */
 function isRelation(value) {
-	return typeof value === "string" && VALID_RELATIONS.has(value);
+    return typeof value === "string" && VALID_RELATIONS.has(value);
 }

package/dist/generator/mermaid/validator/parse-relation.js

@@ -9,21 +9,20 @@ const is_relation_1 = require("./is-relation");
  * @returns
  */
 function parseRelation(line) {
-	const relationRegex =
-		/^@relation\s+(\w+)\.(\w+)\s+(\w+)\.(\w+)\s+(\w+-to-\w+)$/;
-	const match = line.trim().match(relationRegex);
-	if (!match) {
-		return null;
-	}
-	const [, fromModel, fromField, toModel, toField, relationType] = match;
-	if (!(0, is_relation_1.isRelation)(relationType)) {
-		return null;
-	}
-	return {
-		fromModel,
-		fromField,
-		toModel,
-		toField,
-		type: relationType,
-	};
+    const relationRegex = /^@relation\s+(\w+)\.(\w+)\s+(\w+)\.(\w+)\s+(\w+-to-\w+)$/;
+    const match = line.trim().match(relationRegex);
+    if (!match) {
+        return null;
+    }
+    const [, fromModel, fromField, toModel, toField, relationType] = match;
+    if (!(0, is_relation_1.isRelation)(relationType)) {
+        return null;
+    }
+    return {
+        fromModel,
+        fromField,
+        toModel,
+        toField,
+        type: relationType,
+    };
 }

package/dist/generator/mermaid/validator/remove-duplicate-relations.d.ts

@@ -1,9 +1,6 @@
 /**
  * remove duplicate relations
- * @function removeDuplicateRelations
- * @param relations
- * @returns
+ * @param { readonly string[] } relations
+ * @returns { readonly string[] }
  */
-export declare function removeDuplicateRelations(
-	relations: readonly string[],
-): readonly string[];
+export declare function removeDuplicateRelations(relations: readonly string[]): readonly string[];

package/dist/generator/mermaid/validator/remove-duplicate-relations.js

@@ -3,10 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.removeDuplicateRelations = removeDuplicateRelations;
 /**
  * remove duplicate relations
- * @function removeDuplicateRelations
- * @param relations
- * @returns
+ * @param { readonly string[] } relations
+ * @returns { readonly string[] }
  */
 function removeDuplicateRelations(relations) {
-	return [...new Set(relations)];
+    return [...new Set(relations)];
 }

package/dist/generator/valibot/generator/generate-valibot-infer-input.d.ts

@@ -5,7 +5,4 @@ import type { Config } from "..";
  * @param config - The configuration for the generator
  * @returns The generated infer input type
  */
-export declare function generateValibotInferInput(
-	modelName: string,
-	config: Config,
-): string;
+export declare function generateValibotInferInput(modelName: string, config: Config): string;

package/dist/generator/valibot/generator/generate-valibot-infer-input.js

@@ -10,14 +10,7 @@ const get_variable_schema_name_helper_1 = require("../../../common/helper/get-va
  * @returns The generated infer input type
  */
 function generateValibotInferInput(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} = v.InferInput<typeof ${schemaName}>`;
+    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} = v.InferInput<typeof ${schemaName}>`;
 }

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

@@ -1,11 +1,8 @@
 import type { Config } from "..";
-export declare function generateValibotProperties(
-	modelFields: {
-		documentation: string;
-		modelName: string;
-		fieldName: string;
-		validation: string | null;
-		comment: string[];
-	}[],
-	config?: Config,
-): string;
+export declare function generateValibotProperties(modelFields: {
+    documentation: string;
+    modelName: string;
+    fieldName: string;
+    validation: string | null;
+    comment: string[];
+}[], config?: Config): string;

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

@@ -2,25 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateValibotProperties = generateValibotProperties;
 function generateValibotProperties(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}: v.${field.validation}`;
-		})
-		.join(",\n");
-	return fields;
+    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}: v.${field.validation}`;
+    })
+        .join(",\n");
+    return fields;
 }

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

@@ -6,8 +6,4 @@ import type { Config } from "..";
  * @param config - The configuration for the generator
  * @returns The generated Valibot schema
  */
-export declare function generateValibotSchema(
-	modelName: string,
-	fields: string,
-	config: Config,
-): string;
+export declare function generateValibotSchema(modelName: string, fields: string, config: Config): string;

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

@@ -10,10 +10,6 @@ const get_variable_schema_name_helper_1 = require("../../../common/helper/get-va
  * @returns The generated Valibot schema
  */
 function generateValibotSchema(modelName, fields, config) {
-	const schemaName = (0,
-	get_variable_schema_name_helper_1.getVariableSchemaNameHelper)(
-		modelName,
-		config,
-	);
-	return `export const ${schemaName} = v.object({\n${fields}\n})`;
+    const schemaName = (0, get_variable_schema_name_helper_1.getVariableSchemaNameHelper)(modelName, config);
+    return `export const ${schemaName} = v.object({\n${fields}\n})`;
 }

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

@@ -6,13 +6,10 @@ import type { Config } from "..";
  * @param config
  * @returns
  */
-export declare function generateValibotSchemas(
-	modelFields: {
-		documentation: string;
-		modelName: string;
-		fieldName: string;
-		validation: string | null;
-		comment: string[];
-	}[],
-	config: Config,
-): string;
+export declare function generateValibotSchemas(modelFields: {
+    documentation: string;
+    modelName: string;
+    fieldName: string;
+    validation: string | null;
+    comment: string[];
+}[], config: Config): string;

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

@@ -11,18 +11,11 @@ const generate_valibot_schema_1 = require("./generate-valibot-schema");
  * @returns
  */
 function generateValibotSchemas(modelFields, config) {
-	const modelName = modelFields[0].modelName;
-	const modelDoc = modelFields[0].documentation || "";
-	const fields = (0, generate_valibot_properties_1.generateValibotProperties)(
-		modelFields,
-		config,
-	);
-	if (!(modelDoc || !config?.comment)) {
-		return (0, generate_valibot_schema_1.generateValibotSchema)(
-			modelName,
-			fields,
-			config,
-		);
-	}
-	return `${(0, generate_valibot_schema_1.generateValibotSchema)(modelName, fields, config)}`;
+    const modelName = modelFields[0].modelName;
+    const modelDoc = modelFields[0].documentation || "";
+    const fields = (0, generate_valibot_properties_1.generateValibotProperties)(modelFields, config);
+    if (!(modelDoc || !config?.comment)) {
+        return (0, generate_valibot_schema_1.generateValibotSchema)(modelName, fields, config);
+    }
+    return `${(0, generate_valibot_schema_1.generateValibotSchema)(modelName, fields, config)}`;
 }

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

@@ -6,7 +6,4 @@ import type { Model } from "../../../common/type";
  * @param config - The configuration for the generator
  * @returns The generated Valibot schemas and types
  */
-export declare function generateValibot(
-	models: readonly Model[],
-	config: Config,
-): string;
+export declare function generateValibot(models: readonly Model[], config: Config): string;

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

@@ -15,55 +15,40 @@ const VALIBOT_IMPORT = `import * as v from 'valibot'\n`;
  * @returns The generated Valibot schemas and types
  */
 function generateValibot(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_valibot_documentation_1.isValibotDocumentValidation)(
-				field.documentation,
-			),
-			validation: (0, is_valibot_validation_1.isValibotValidation)(
-				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 valibots = Object.values(groupedByModel).map((fields) => {
-		return {
-			generateValibotSchema: (0,
-			generate_valibot_schemas_1.generateValibotSchemas)(fields, config),
-			generateValibotInfer:
-				config.type === "true"
-					? (0, generate_valibot_infer_input_1.generateValibotInferInput)(
-							fields[0].modelName,
-							config,
-						)
-					: "",
-		};
-	});
-	return [
-		VALIBOT_IMPORT,
-		"",
-		valibots
-			.flatMap(({ generateValibotSchema, generateValibotInfer }) =>
-				[generateValibotSchema, generateValibotInfer].filter(Boolean),
-			)
-			.join("\n\n"),
-	].join("\n");
+    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_valibot_documentation_1.isValibotDocumentValidation)(field.documentation),
+            validation: (0, is_valibot_validation_1.isValibotValidation)(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 valibots = Object.values(groupedByModel).map((fields) => {
+        return {
+            generateValibotSchema: (0, generate_valibot_schemas_1.generateValibotSchemas)(fields, config),
+            generateValibotInfer: config.type === "true"
+                ? (0, generate_valibot_infer_input_1.generateValibotInferInput)(fields[0].modelName, config)
+                : "",
+        };
+    });
+    return [
+        VALIBOT_IMPORT,
+        "",
+        valibots
+            .flatMap(({ generateValibotSchema, generateValibotInfer }) => [generateValibotSchema, generateValibotInfer].filter(Boolean))
+            .join("\n\n"),
+    ].join("\n");
 }

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

@@ -1,10 +1,11 @@
+#!/usr/bin/env node
 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[];
+    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/valibot/index.js

@@ -1,9 +1,8 @@
+#!/usr/bin/env node
 "use strict";
-var __importDefault =
-	(this && this.__importDefault) ||
-	function (mod) {
-		return mod && mod.__esModule ? mod : { default: mod };
-	};
+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");
@@ -11,49 +10,45 @@ 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,
+    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);
+    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,
+    onManifest() {
+        return {
+            defaultOutput: "./valibot/",
+            prettyName: "Hekireki-Valibot",
+        };
+    },
+    onGenerate: main,
 });

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

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

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

@@ -3,12 +3,11 @@ 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);
+    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

@@ -4,6 +4,4 @@
  * @param documentation
  * @returns string | null
  */
-export declare function isValibotValidation(
-	documentation?: string,
-): string | null;
+export declare function isValibotValidation(documentation?: string): string | null;

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

@@ -8,7 +8,8 @@ exports.isValibotValidation = isValibotValidation;
  * @returns string | null
  */
 function isValibotValidation(documentation) {
-	if (!documentation) return null;
-	const match = documentation.match(/@v\.(.+?)(?:\n|$)/);
-	return match ? match[1].trim() : null;
+    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

@@ -5,7 +5,4 @@ import type { Config } from "..";
  * @param config - The configuration for the generator
  * @returns The generated Zod infer
  */
-export declare function generateZodInfer(
-	modelName: string,
-	config: Config,
-): string;
+export declare function generateZodInfer(modelName: string, config: Config): string;