hekireki 0.0.6 → 0.0.8

package/dist/generator/mermaid-er/generator/generate-model-info.d.ts

@@ -0,0 +1,8 @@
+import type { Model } from '../type';
+/**
+ * generate model info
+ * @function generateModelInfo
+ * @param model
+ * @returns
+ */
+export declare function generateModelInfo(model: Model): readonly string[];

package/dist/generator/mermaid-er/generator/generate-model-info.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateModelInfo = generateModelInfo;
+const generate_model_fields_1 = require("./generate-model-fields");
+/**
+ * generate model info
+ * @function generateModelInfo
+ * @param model
+ * @returns
+ */
+function generateModelInfo(model) {
+    return [`    ${model.name} {`, ...(0, generate_model_fields_1.generateModelFields)(model), '    }'];
+}

package/dist/generator/mermaid-er/generator/generate-relation-line.d.ts

@@ -0,0 +1,7 @@
+import type { Relation } from '../type';
+/**
+ * generate relation line
+ * @param { Relation } relation
+ * @returns { string } relation line
+ */
+export declare function generateRelationLine(relation: Relation): string;

package/dist/generator/mermaid-er/generator/generate-relation-line.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRelationLine = generateRelationLine;
+const build_relation_line_1 = require("../relationship/build-relation-line");
+/**
+ * generate relation line
+ * @param { Relation } relation
+ * @returns { string } relation line
+ */
+function generateRelationLine(relation) {
+    const cardinality = (0, build_relation_line_1.buildRelationLine)(relation.type);
+    if (!cardinality) {
+        throw new Error(`Unknown relation type: ${relation.type}`);
+    }
+    return `    ${relation.fromModel} ${cardinality} ${relation.toModel} : "(${relation.fromField}) - (${relation.toField})"`;
+}

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

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import type { GeneratorOptions } from '@prisma/generator-helper';
+export type Config = {
+    output?: string;
+    file?: string | string[];
+};
+export declare const ER_HEADER: readonly ["```mermaid", "erDiagram"];
+export declare const ER_FOOTER: readonly ["```"];
+export declare function main(options: GeneratorOptions): Promise<void>;

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

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ER_FOOTER = exports.ER_HEADER = void 0;
+exports.main = main;
+const output_1 = require("./output");
+const generator_helper_1 = require("@prisma/generator-helper");
+const generate_er_content_1 = require("./generator/generate-er-content");
+const DEFAULT_CONFIG = {
+    output: './mermaid-er',
+    file: 'ER.md',
+};
+// ER diagram header
+exports.ER_HEADER = ['```mermaid', 'erDiagram'];
+// ER diagram footer
+exports.ER_FOOTER = ['```'];
+// main function
+async function main(options) {
+    const config = {
+        output: options.generator.output?.value ?? DEFAULT_CONFIG.output,
+        file: options.generator.config?.file ?? DEFAULT_CONFIG.file,
+    };
+    const models = options.dmmf.datamodel.models;
+    const content = (0, generate_er_content_1.generateERContent)(models);
+    if (!config.output) {
+        throw new Error('output is required');
+    }
+    (0, output_1.OutputFile)(content, config);
+}
+// prisma generator handler
+(0, generator_helper_1.generatorHandler)({
+    onManifest() {
+        return {
+            defaultOutput: './mermaid-er',
+            prettyName: 'Hekireki-ER',
+        };
+    },
+    onGenerate: main,
+});

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

@@ -0,0 +1,8 @@
+import type { Config } from '..';
+import type { ERContent } from '../type';
+/**
+ * Output the ER content to a file
+ * @param content - The ER content
+ * @param config - The configuration
+ */
+export declare function OutputFile(content: ERContent, config: Config): void;

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

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OutputFile = OutputFile;
+const node_fs_1 = __importDefault(require("node:fs"));
+/**
+ * Output the ER content to a file
+ * @param content - The ER content
+ * @param config - The configuration
+ */
+function OutputFile(content, config) {
+    const outputDir = config.output;
+    if (!outputDir) {
+        throw new Error('output is required');
+    }
+    if (!node_fs_1.default.existsSync(outputDir)) {
+        node_fs_1.default.mkdirSync(outputDir, { recursive: true });
+    }
+    const file = config.file ?? 'ER.md';
+    const filePath = `${outputDir}/${file}`;
+    node_fs_1.default.writeFileSync(filePath, content.join('\n'), { encoding: 'utf-8' });
+}

package/dist/generator/mermaid-er/relationship/build-relation-line.d.ts

@@ -0,0 +1,14 @@
+declare const RELATIONSHIPS: {
+    readonly 'zero-one': "|o";
+    readonly one: "||";
+    readonly 'zero-many': "}o";
+    readonly many: "}|";
+};
+export type Relationship = keyof typeof RELATIONSHIPS;
+/**
+ * Builds a relationship line for mermaid from a string.
+ * @param { string } input
+ * @returns { string }
+ */
+export declare function buildRelationLine(input: string): string;
+export {};

package/dist/generator/mermaid-er/relationship/build-relation-line.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildRelationLine = buildRelationLine;
+const is_relationship_1 = require("../validator/is-relationship");
+const RELATIONSHIPS = {
+    'zero-one': '|o',
+    one: '||',
+    'zero-many': '}o',
+    many: '}|',
+};
+/**
+ * Builds a relationship line for mermaid from a string.
+ * @param { string } input
+ * @returns { string }
+ */
+function buildRelationLine(input) {
+    const parts = input.split('-to-');
+    if (parts.length !== 2) {
+        throw new Error(`Invalid input format: ${input}`);
+    }
+    const [toRaw, optionalFlag] = parts[1].includes('-optional')
+        ? [parts[1].replace('-optional', ''), 'optional']
+        : [parts[1], ''];
+    const from = parts[0];
+    const to = toRaw;
+    const isOptional = optionalFlag === 'optional';
+    if (!((0, is_relationship_1.isRelationship)(from) && (0, is_relationship_1.isRelationship)(to))) {
+        throw new Error(`Invalid relationship string: ${input}`);
+    }
+    const fromSymbol = RELATIONSHIPS[from];
+    const toSymbol = RELATIONSHIPS[to];
+    if (!(fromSymbol && toSymbol)) {
+        throw new Error(`Invalid relationship string: ${input}`);
+    }
+    const connector = isOptional ? '..' : '--';
+    return `${fromSymbol}${connector}${toSymbol}`;
+}

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

@@ -0,0 +1,10 @@
+import type { DMMF } from '@prisma/generator-helper';
+export type Relation = {
+    fromModel: string;
+    toModel: string;
+    fromField: string;
+    toField: string;
+    type: string;
+};
+export type Model = Readonly<DMMF.Model>;
+export type ERContent = readonly string[];

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/generator/mermaid-er/validator/exclude-many-to-one-relations.d.ts

@@ -0,0 +1,7 @@
+/**
+ * exclude many-to-one relations
+ * @function excludeManyToOneRelations
+ * @param relations
+ * @returns
+ */
+export declare function excludeManyToOneRelations(relations: readonly string[]): readonly string[];

package/dist/generator/mermaid-er/validator/exclude-many-to-one-relations.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.excludeManyToOneRelations = excludeManyToOneRelations;
+/**
+ * exclude many-to-one relations
+ * @function excludeManyToOneRelations
+ * @param relations
+ * @returns
+ */
+function excludeManyToOneRelations(relations) {
+    return [...new Set(relations)].filter((r) => !r.includes('many-to-one'));
+}

package/dist/generator/mermaid-er/validator/extract-relations.d.ts

@@ -0,0 +1,7 @@
+import type { Model } from '../type';
+/**
+ * extract relations from model
+ * @param { Model } model
+ * @returns { readonly string[] }
+ */
+export declare function extractRelations(model: Model): readonly string[];

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractRelations = extractRelations;
+const generate_relation_line_1 = require("../generator/generate-relation-line");
+const parse_relation_1 = require("./parse-relation");
+/**
+ * extract relations from model
+ * @param { Model } model
+ * @returns { readonly string[] }
+ */
+function extractRelations(model) {
+    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-er/validator/is-relationship.d.ts

@@ -0,0 +1,7 @@
+import type { Relationship } from "../relationship/build-relation-line";
+/**
+ * isRelationship
+ * @param { string } key
+ * @returns { key is Relationship }
+ */
+export declare function isRelationship(key: string): key is Relationship;

package/dist/generator/mermaid-er/validator/is-relationship.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRelationship = isRelationship;
+/**
+ * isRelationship
+ * @param { string } key
+ * @returns { key is Relationship }
+ */
+function isRelationship(key) {
+    return ['zero-one', 'one', 'zero-many', 'many'].includes(key);
+}

package/dist/generator/mermaid-er/validator/parse-relation.d.ts

@@ -0,0 +1,8 @@
+import type { Relation } from '../type';
+/**
+ * parse relation
+ * @function parseRelation
+ * @param line
+ * @returns
+ */
+export declare function parseRelation(line: string): Relation | null;

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRelation = parseRelation;
+/**
+ * parse relation
+ * @function parseRelation
+ * @param line
+ * @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;
+    return {
+        fromModel,
+        fromField,
+        toModel,
+        toField,
+        type: relationType,
+    };
+}

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

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

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

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

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

@@ -1,4 +1,4 @@
-import type { Config } from "..";
+import type { Config } from '..';
 /**
  * Generate the infer input type for the model
  * @param modelName - The name of the model

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

@@ -1,4 +1,4 @@
-import type { Config } from "..";
+import type { Config } from '..';
 export declare function generateValibotProperties(modelFields: {
     documentation: string;
     modelName: string;

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

@@ -7,14 +7,12 @@ function generateValibotProperties(modelFields, config) {
         .map((field) => {
         // @relation, @v, @z exclude
         const cleanDoc = field.comment
-            .filter((line) => !(line.includes("@relation") ||
-            line.includes("@v") ||
-            line.includes("@z")))
-            .join("\n")
+            .filter((line) => !(line.includes('@relation') || line.includes('@v') || line.includes('@z')))
+            .join('\n')
             .trim();
-        const docComment = config?.comment && cleanDoc ? `  /**\n   * ${cleanDoc}\n   */\n` : "";
+        const docComment = config?.comment && cleanDoc ? `  /**\n   * ${cleanDoc}\n   */\n` : '';
         return `${docComment}  ${field.fieldName}: v.${field.validation}`;
     })
-        .join(",\n");
+        .join(',\n');
     return fields;
 }

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

@@ -1,4 +1,4 @@
-import type { Config } from "..";
+import type { Config } from '..';
 /**
  * Generate Valibot schema
  * @param modelName - The name of the model

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

@@ -1,4 +1,4 @@
-import type { Config } from "..";
+import type { Config } from '..';
 /**
  * generate valibot schemas
  * @function generateValibotSchemas

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

@@ -12,7 +12,7 @@ const generate_valibot_schema_1 = require("./generate-valibot-schema");
  */
 function generateValibotSchemas(modelFields, config) {
     const modelName = modelFields[0].modelName;
-    const modelDoc = modelFields[0].documentation || "";
+    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);

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

@@ -1,5 +1,5 @@
-import type { Config } from "..";
-import type { Model } from "../../../common/type";
+import type { Config } from '..';
+import type { Model } from '../../../common/type';
 /**
  * Generate Valibot schemas and types
  * @param models - The models to generate the Valibot schemas and types for

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

@@ -17,7 +17,7 @@ const VALIBOT_IMPORT = `import * as v from 'valibot'\n`;
 function generateValibot(models, config) {
     const modelInfos = models.map((model) => {
         return {
-            documentation: model.documentation ?? "",
+            documentation: model.documentation ?? '',
             name: model.name,
             fields: model.fields,
         };
@@ -39,16 +39,14 @@ function generateValibot(models, config) {
     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)
-                : "",
+            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");
+            .join('\n\n'),
+    ].join('\n');
 }

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

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
-import type { GeneratorOptions } from "@prisma/generator-helper";
+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[];
+    schemaName?: 'PascalCase' | 'camelCase' | string | string[];
+    typeName?: 'PascalCase' | 'camelCase' | string | string[];
     type?: boolean | string | string[];
     comment?: boolean | string | string[];
 };

package/dist/generator/valibot/index.js

@@ -10,10 +10,10 @@ 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",
+    output: './valibot',
+    file: 'index.ts',
+    schemaName: 'PascalCase',
+    typeName: 'PascalCase',
     type: false,
     comment: false,
 };
@@ -24,30 +24,30 @@ async function main(options) {
         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",
+        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",
+        parser: 'typescript',
         printWidth: 100,
         singleQuote: true,
         semi: false,
     });
     if (!config.output) {
-        throw new Error("output is required");
+        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 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",
+            defaultOutput: './valibot/',
+            prettyName: 'Hekireki-Valibot',
         };
     },
     onGenerate: main,

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

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

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

@@ -1,4 +1,4 @@
-import type { Config } from "..";
+import type { Config } from '..';
 /**
  * Generate Zod infer
  * @param modelName - The name of the model

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

@@ -1,4 +1,4 @@
-import type { Config } from "..";
+import type { Config } from '..';
 /**
  * Generate Zod properties
  * @param modelFields - The fields of the model

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

@@ -13,14 +13,12 @@ function generateZodProperties(modelFields, config) {
         .map((field) => {
         // @relation, @v, @z exclude
         const cleanDoc = field.comment
-            .filter((line) => !(line.includes("@relation") ||
-            line.includes("@v") ||
-            line.includes("@z")))
-            .join("\n")
+            .filter((line) => !(line.includes('@relation') || line.includes('@v') || line.includes('@z')))
+            .join('\n')
             .trim();
-        const docComment = config?.comment && cleanDoc ? `  /**\n   * ${cleanDoc}\n   */\n` : "";
+        const docComment = config?.comment && cleanDoc ? `  /**\n   * ${cleanDoc}\n   */\n` : '';
         return `${docComment}  ${field.fieldName}: z.${field.validation}`;
     })
-        .join(",\n");
+        .join(',\n');
     return fields;
 }

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

@@ -1,4 +1,4 @@
-import type { Config } from "..";
+import type { Config } from '..';
 /**
  * Generate Zod schema
  * @param modelName - The name of the model

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

@@ -1,4 +1,4 @@
-import type { Config } from "..";
+import type { Config } from '..';
 /**
  * Generate Zod schemas
  * @param modelFields - The fields of the model

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

@@ -11,7 +11,7 @@ const generate_zod_schema_1 = require("./generate-zod-schema");
  */
 function generateZodSchemas(modelFields, config) {
     const modelName = modelFields[0].modelName;
-    const modelDoc = modelFields[0].documentation || "";
+    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);

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

@@ -1,5 +1,5 @@
-import type { Config } from "..";
-import type { Model } from "../../../common/type";
+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

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

@@ -17,7 +17,7 @@ const ZOD_IMPORT = `import { z } from 'zod'\n`;
 function generateZod(models, config) {
     const modelInfos = models.map((model) => {
         return {
-            documentation: model.documentation ?? "",
+            documentation: model.documentation ?? '',
             name: model.name,
             fields: model.fields,
         };
@@ -39,16 +39,14 @@ function generateZod(models, config) {
     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)
-                : "",
+            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");
+            .join('\n\n'),
+    ].join('\n');
 }

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

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
-import type { GeneratorOptions } from "@prisma/generator-helper";
+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[];
+    schemaName?: 'PascalCase' | 'camelCase' | string | string[];
+    typeName?: 'PascalCase' | 'camelCase' | string | string[];
     type?: boolean | string | string[];
     comment?: boolean | string | string[];
 };