hekireki 0.0.7 → 0.0.9

package/README.md

@@ -294,9 +294,9 @@ export type Like = v.InferInput<typeof LikeSchema>
 
 ```mermaid
 erDiagram
-    User ||--|{ Post : "(id) - (userId)"
-    Post ||--|{ Like : "(id) - (postId)"
-    User ||--|{ Like : "(id) - (userId)"
+    User ||--}| Post : "(id) - (userId)"
+    Post ||--}| Like : "(id) - (postId)"
+    User ||--}| Like : "(id) - (userId)"
     User {
         String id "Unique identifier for the user."
         String username "Username of the user."

package/dist/generator/mermaid/generator/generate-er-content.d.ts

@@ -1,7 +1,7 @@
-import type { ERContent, Model } from '../type';
+import type { ERContent, Model } from '../type'
 /**
  * generate ER content
  * @param { readonly Model[] } models - models
  * @returns { ERContent } - ER content
  */
-export declare function generateERContent(models: readonly Model[]): ERContent;
+export declare function generateERContent(models: readonly Model[]): ERContent

package/dist/generator/mermaid/generator/generate-model-fields.d.ts

@@ -1,7 +1,7 @@
-import type { DMMF } from '@prisma/generator-helper';
+import type { DMMF } from '@prisma/generator-helper'
 /**
  * generate model fields
  * @param { DMMF.Model } model
  * @returns { string[] }
  */
-export declare function generateModelFields(model: DMMF.Model): string[];
+export declare function generateModelFields(model: DMMF.Model): string[]

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

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

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

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

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

@@ -1,9 +1,9 @@
 #!/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[];
-};
-export declare const ER_HEADER: readonly ["```mermaid", "erDiagram"];
-export declare const ER_FOOTER: readonly ["```"];
-export declare function main(options: GeneratorOptions): Promise<void>;
+  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/output/index.d.ts

@@ -1,8 +1,8 @@
-import type { Config } from '..';
-import type { ERContent } from '../type';
+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;
+export declare function OutputFile(content: ERContent, config: Config): void

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

@@ -1,14 +1,14 @@
 declare const RELATIONSHIPS: {
-    readonly 'zero-one': "|o";
-    readonly one: "||";
-    readonly 'zero-many': "}o";
-    readonly many: "}|";
-};
-export type Relationship = keyof typeof 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 {};
+export declare function buildRelationLine(input: string): string
+export {}

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

@@ -1,10 +1,10 @@
-import type { DMMF } from '@prisma/generator-helper';
+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[];
+  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/validator/exclude-many-to-one-relations.d.ts

@@ -4,4 +4,4 @@
  * @param relations
  * @returns
  */
-export declare function excludeManyToOneRelations(relations: readonly string[]): readonly string[];
+export declare function excludeManyToOneRelations(relations: readonly string[]): readonly string[]

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

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

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

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

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

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

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

@@ -3,4 +3,4 @@
  * @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-er/generator/generate-er-content.d.ts

@@ -0,0 +1,7 @@
+import type { ERContent, Model } from '../type';
+/**
+ * generate ER content
+ * @param { readonly Model[] } models - models
+ * @returns { ERContent } - ER content
+ */
+export declare function generateERContent(models: readonly Model[]): ERContent;

package/dist/generator/mermaid-er/generator/generate-er-content.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateERContent = generateERContent;
+const __1 = require("..");
+const extract_relations_1 = require("../validator/extract-relations");
+const generate_model_info_1 = require("../generator/generate-model-info");
+const remove_duplicate_relations_1 = require("../validator/remove-duplicate-relations");
+/**
+ * generate ER content
+ * @param { readonly Model[] } models - models
+ * @returns { ERContent } - ER content
+ */
+function generateERContent(models) {
+    // extract all relations
+    const allRelations = models.flatMap(extract_relations_1.extractRelations);
+    // remove duplicate relations
+    const uniqueRelations = (0, remove_duplicate_relations_1.removeDuplicateRelations)(allRelations);
+    // collect all model info
+    const modelInfos = models.flatMap(generate_model_info_1.generateModelInfo);
+    // build ER diagram
+    return [...__1.ER_HEADER, ...uniqueRelations, ...modelInfos, ...__1.ER_FOOTER];
+}

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

@@ -0,0 +1,7 @@
+import type { DMMF } from '@prisma/generator-helper';
+/**
+ * generate model fields
+ * @param { DMMF.Model } model
+ * @returns { string[] }
+ */
+export declare function generateModelFields(model: DMMF.Model): string[];

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateModelFields = generateModelFields;
+const ZOD_ANNOTATION = '@z.';
+const VALIBOT_ANNOTATION = '@v.';
+/**
+ * generate model fields
+ * @param { DMMF.Model } model
+ * @returns { string[] }
+ */
+function generateModelFields(model) {
+    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)))
+                .join('\n')
+                .trim()
+            : '';
+        return `        ${field.type} ${field.name} ${commentPart ? `"${commentPart}"` : ''}`;
+    })
+        .filter((field) => field !== null);
+}

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hekireki",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "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.",
   "keywords": [
@@ -28,7 +28,7 @@
   "bin": {
     "hekireki-zod": "dist/generator/zod/index.js",
     "hekireki-valibot": "dist/generator/valibot/index.js",
-    "hekireki-mermaid-er": "dist/generator/mermaid/index.js"
+    "hekireki-mermaid-er": "dist/generator/mermaid-er/index.js"
   },
   "scripts": {
     "generate": "prisma generate",