hekireki 0.1.0 → 0.2.0

package/README.md

@@ -20,110 +20,65 @@ Prepare `schema.prisma`:
 
 ```prisma
 generator client {
-  provider = "prisma-client-js"
+    provider = "prisma-client-js"
 }
 
 datasource db {
-  provider = "sqlite"
-  url      = env("DATABASE_URL")
+    provider = "sqlite"
+    url      = env("DATABASE_URL")
 }
 
 generator Hekireki-ER {
-  provider = "hekireki-mermaid-er"
+    provider = "hekireki-mermaid-er"
 }
 
 generator Hekireki-Zod {
-  provider = "hekireki-zod"
-  type     = true
-  comment  = true
+    provider = "hekireki-zod"
+    type     = true
+    comment  = false
 }
 
 generator Hekireki-Valibot {
-  provider = "hekireki-valibot"
-  type     = true
-  comment  = true
+    provider = "hekireki-valibot"
+    type     = true
+    comment  = false
 }
 
 model User {
-  /// Unique identifier for the user.
-  /// @z.string().uuid()
-  /// @v.pipe(v.string(), v.uuid())
-  id String @id @default(uuid())
-  /// Username of the user.
-  /// @z.string().min(3)
-  /// @v.pipe(v.string(), v.minLength(3))
-  username String
-  /// Email address of the user.
-  /// @z.string().email()
-  /// @v.pipe(v.string(), v.email())
-  email String
-  /// Password for the user.
-  /// @z.string().min(8).max(100)
-  /// @v.pipe(v.string(), v.minLength(8), v.maxLength(100))
-  password String
-  /// Timestamp when the user was created.
-  /// @z.date()
-  /// @v.date()
-  createdAt DateTime
-  /// Timestamp when the user was last updated.
-  /// @z.date()
-  /// @v.date()
-  updatedAt DateTime
-  posts Post[]
-  likes Like[]
+    /// Primary key
+    /// @z.uuid()
+    /// @v.pipe(v.string(), v.uuid())
+    id    String @id @default(uuid())
+    /// Display name
+    /// @z.string().min(1).max(50)
+    /// @v.pipe(v.string(), v.minLength(1), v.maxLength(50))
+    name  String
+    /// One-to-many relation to Post
+    posts Post[]
 }
 
 /// @relation User.id Post.userId one-to-many
 model Post {
-  /// Unique identifier for the post.
-  /// @z.string().uuid()
-  /// @v.pipe(v.string(), v.uuid())
-  id String @id @default(uuid())
-  /// ID of the user who created the post.
-  /// @z.string().uuid()
-  /// @v.pipe(v.string(), v.uuid())
-  userId String
-  /// Content of the post.
-  /// @z.string().max(500)
-  /// @v.pipe(v.string(), v.maxLength(500))
-  content String
-  /// Timestamp when the post was created.
-  /// @z.date()
-  /// @v.date()
-  createdAt DateTime @default(now())
-  /// Timestamp when the post was last updated.
-  /// @z.date()
-  /// @v.date()
-  updatedAt DateTime @default(now()) @updatedAt
-  /// Relation with the User model.
-  user User @relation(fields: [userId], references: [id], onDelete: Cascade)
-  likes Like[]
-}
-
-/// @relation Post.id Like.postId one-to-many
-/// @relation User.id Like.userId one-to-many
-model Like {
-  /// Unique identifier for the like.
-  /// @z.string().uuid()
-  /// @v.pipe(v.string(), v.uuid())
-  id String
-  /// ID of the post that is liked.
-  /// @z.string().uuid()
-  /// @v.pipe(v.string(), v.uuid())
-  postId String
-  /// ID of the user who liked the post.
-  /// @z.string().uuid()
-  /// @v.pipe(v.string(), v.uuid())
-  userId String
-  /// Timestamp when the like was created.
-  /// @z.date()
-  /// @v.date()
-  createdAt DateTime @default(now())
-  /// Relation with the Post model.
-  post Post @relation(fields: [postId], references: [id], onDelete: Cascade)
-  /// Relation with the User model.
-  user User @relation(fields: [userId], references: [id], onDelete: Cascade)
-  @@unique([userId, postId])
+    /// Primary key
+    /// @z.uuid()
+    /// @v.pipe(v.string(), v.uuid())
+    id String @id @default(uuid())
+
+    /// Article title
+    /// @z.string().min(1).max(100)
+    /// @v.pipe(v.string(), v.minLength(1), v.maxLength(100))
+    title String
+
+    /// Body content (no length limit)
+    /// @z.string()
+    /// @v.string()
+    content String
+    /// Foreign key referencing User.id
+    /// @z.uuid()
+    /// @v.pipe(v.string(), v.uuid())
+    userId  String
+    /// Prisma relation definition
+    user    User   @relation(fields: [userId], references: [id])
 }
 ```
 
@@ -132,82 +87,41 @@ model Like {
 ## Zod
 
 ```ts
-import { z } from 'zod'
+import { z } from 'zod/v4'
 
 export const UserSchema = z.object({
   /**
-   * Unique identifier for the user.
-   */
-  id: z.string().uuid(),
-  /**
-   * Username of the user.
+   * Primary key
    */
-  username: z.string().min(3),
+  id: z.uuid(),
   /**
-   * Email address of the user.
+   * Display name
    */
-  email: z.string().email(),
-  /**
-   * Password for the user.
-   */
-  password: z.string().min(8).max(100),
-  /**
-   * Timestamp when the user was created.
-   */
-  createdAt: z.date(),
-  /**
-   * Timestamp when the user was last updated.
-   */
-  updatedAt: z.date(),
+  name: z.string().min(1).max(50),
 })
 
 export type User = z.infer<typeof UserSchema>
 
 export const PostSchema = z.object({
   /**
-   * Unique identifier for the post.
+   * Primary key
    */
-  id: z.string().uuid(),
+  id: z.uuid(),
   /**
-   * ID of the user who created the post.
+   * Article title
    */
-  userId: z.string().uuid(),
+  title: z.string().min(1).max(100),
   /**
-   * Content of the post.
+   * Body content (no length limit)
    */
-  content: z.string().max(500),
+  content: z.string(),
   /**
-   * Timestamp when the post was created.
+   * Foreign key referencing User.id
    */
-  createdAt: z.date(),
-  /**
-   * Timestamp when the post was last updated.
-   */
-  updatedAt: z.date(),
+  userId: z.uuid(),
 })
 
 export type Post = z.infer<typeof PostSchema>
-
-export const LikeSchema = z.object({
-  /**
-   * Unique identifier for the like.
-   */
-  id: z.string().uuid(),
-  /**
-   * ID of the post that is liked.
-   */
-  postId: z.string().uuid(),
-  /**
-   * ID of the user who liked the post.
-   */
-  userId: z.string().uuid(),
-  /**
-   * Timestamp when the like was created.
-   */
-  createdAt: z.date(),
-})
-
-export type Like = z.infer<typeof LikeSchema>
 ```
 
 ## Valibot
@@ -216,78 +130,37 @@ import * as v from 'valibot'
 
 export const UserSchema = v.object({
   /**
-   * Unique identifier for the user.
+   * Primary key
    */
   id: v.pipe(v.string(), v.uuid()),
   /**
-   * Username of the user.
-   */
-  username: v.pipe(v.string(), v.minLength(3)),
-  /**
-   * Email address of the user.
+   * Display name
    */
-  email: v.pipe(v.string(), v.email()),
-  /**
-   * Password for the user.
-   */
-  password: v.pipe(v.string(), v.minLength(8), v.maxLength(100)),
-  /**
-   * Timestamp when the user was created.
-   */
-  createdAt: v.date(),
-  /**
-   * Timestamp when the user was last updated.
-   */
-  updatedAt: v.date(),
+  name: v.pipe(v.string(), v.minLength(1), v.maxLength(50)),
 })
 
 export type User = v.InferInput<typeof UserSchema>
 
 export const PostSchema = v.object({
   /**
-   * Unique identifier for the post.
+   * Primary key
    */
   id: v.pipe(v.string(), v.uuid()),
   /**
-   * ID of the user who created the post.
-   */
-  userId: v.pipe(v.string(), v.uuid()),
-  /**
-   * Content of the post.
-   */
-  content: v.pipe(v.string(), v.maxLength(500)),
-  /**
-   * Timestamp when the post was created.
-   */
-  createdAt: v.date(),
-  /**
-   * Timestamp when the post was last updated.
-   */
-  updatedAt: v.date(),
-})
-
-export type Post = v.InferInput<typeof PostSchema>
-
-export const LikeSchema = v.object({
-  /**
-   * Unique identifier for the like.
+   * Article title
    */
-  id: v.pipe(v.string(), v.uuid()),
+  title: v.pipe(v.string(), v.minLength(1), v.maxLength(100)),
   /**
-   * ID of the post that is liked.
+   * Body content (no length limit)
    */
-  postId: v.pipe(v.string(), v.uuid()),
+  content: v.string(),
   /**
-   * ID of the user who liked the post.
+   * Foreign key referencing User.id
    */
   userId: v.pipe(v.string(), v.uuid()),
-  /**
-   * Timestamp when the like was created.
-   */
-  createdAt: v.date(),
 })
 
-export type Like = v.InferInput<typeof LikeSchema>
+export type Post = v.InferInput<typeof PostSchema>
 ```
 
 ## Mermaid
@@ -295,28 +168,15 @@ export type Like = v.InferInput<typeof LikeSchema>
 ```mermaid
 erDiagram
     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."
-        String email "Email address of the user."
-        String password "Password for the user."
-        DateTime createdAt "Timestamp when the user was created."
-        DateTime updatedAt "Timestamp when the user was last updated."
+        String id "Primary key"
+        String name "Display name"
     }
     Post {
-        String id "Unique identifier for the post."
-        String userId "ID of the user who created the post."
-        String content "Content of the post."
-        DateTime createdAt "Timestamp when the post was created."
-        DateTime updatedAt "Timestamp when the post was last updated."
-    }
-    Like {
-        String id "Unique identifier for the like."
-        String postId "ID of the post that is liked."
-        String userId "ID of the user who liked the post."
-        DateTime createdAt "Timestamp when the like was created."
+        String id "Primary key"
+        String title "Article title"
+        String content "Body content (no length limit)"
+        String userId "Foreign key referencing User.id"
     }
 ```
 
@@ -328,19 +188,16 @@ erDiagram
 |--------------|-----------|-------------------------------------|--------------------------------------------------|
 | `output`     | `string`  | `./zod`                             | Output directory                                 |
 | `file`       | `string`  | `index.ts`                          | File Name                                        |
-| `schemaName` | `"PascalCase"` \| `"camelCase"` | `"PascalCase"`| Naming convention for generated schema variables |
-| `typeName`   | `"PascalCase"` \| `"camelCase"` | `"PascalCase"`| Naming convention for generated type definitions |
 | `type`       | `boolean` | `false`                             | Generate TypeScript types                        |
 | `comment`    | `boolean` | `false`                             | Include schema documentation                     |
+| `zodVersion` | `string`  | `'v4'`                              | Zod import version (`'v4-mini'`, `'@hono/zod-openapi'`, or default `'v4'`) |
 
 ### Valibot Generator Options
 
 | Option       | Type      | Default                             | Description                                      |
 |--------------|-----------|-------------------------------------|--------------------------------------------------|
-| `output`     | `string`  | `./valibot`                          | Output directory                                 |
+| `output`     | `string`  | `./valibot`                         | Output directory                                 |
 | `file`       | `string`  | `index.ts`                          | File Name                                        |
-| `schemaName` | `"PascalCase"` \| `"camelCase"` | `"PascalCase"`| Naming convention for generated schema variables |
-| `typeName`   | `"PascalCase"` \| `"camelCase"` | `"PascalCase"`| Naming convention for generated type definitions |
 | `type`       | `boolean` | `false`                             | Generate TypeScript types                        |
 | `comment`    | `boolean` | `false`                             | Include schema documentation                     |
 

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

@@ -0,0 +1,2 @@
+import type { ERContent, Model } from '../types.js';
+export declare function erContent(models: readonly Model[]): ERContent;

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

@@ -0,0 +1,21 @@
+import { modelInfo } from '../generator/index.js';
+import { extractRelations, removeDuplicateRelations } from '../validator/index.js';
+/**
+ * generate ER content
+ * @param { readonly Model[] } models - models
+ * @returns { ERContent } - ER content
+ */
+// ER diagram header
+const ER_HEADER = ['```mermaid', 'erDiagram'];
+// ER diagram footer
+const ER_FOOTER = ['```'];
+export function erContent(models) {
+    // extract all relations
+    const allRelations = models.flatMap(extractRelations);
+    // remove duplicate relations
+    const uniqueRelations = removeDuplicateRelations(allRelations);
+    // collect all model info
+    const modelInfos = models.flatMap(modelInfo);
+    // build ER diagram
+    return [...ER_HEADER, ...uniqueRelations, ...modelInfos, ...ER_FOOTER];
+}

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

@@ -0,0 +1,4 @@
+export { erContent } from './er-content.js';
+export { modelInfo } from './model-info.js';
+export { modelFields } from './model-fields.js';
+export { relationLine } from './relation-line.js';

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

@@ -0,0 +1,4 @@
+export { erContent } from './er-content.js';
+export { modelInfo } from './model-info.js';
+export { modelFields } from './model-fields.js';
+export { relationLine } from './relation-line.js';

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

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

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

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateModelFields = generateModelFields;
 const ZOD_ANNOTATION = '@z.';
 const VALIBOT_ANNOTATION = '@v.';
 /**
@@ -8,7 +5,7 @@ const VALIBOT_ANNOTATION = '@v.';
  * @param { DMMF.Model } model
  * @returns { string[] }
  */
-function generateModelFields(model) {
+export function modelFields(model) {
     return model.fields
         .map((field) => {
         if (field.relationName) {

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

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

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

@@ -0,0 +1,9 @@
+import { modelFields } from './index.js';
+/**
+ * generate model info
+ * @param model
+ * @returns
+ */
+export function modelInfo(model) {
+    return [`    ${model.name} {`, ...modelFields(model), '    }'];
+}

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

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

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

@@ -0,0 +1,13 @@
+import { buildRelationLine } from '../relationship/build-relation-line.js';
+/**
+ * generate relation line
+ * @param { Relation } relation
+ * @returns { string } relation line
+ */
+export function relationLine(relation) {
+    const cardinality = 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

@@ -1,9 +1,3 @@
 #!/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

@@ -1,34 +1,17 @@
 #!/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);
+import { erContent } from './generator/er-content.js';
+import fsp from 'node:fs/promises';
+import pkg from '@prisma/generator-helper';
+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';
+    await fsp.mkdir(output, { recursive: true });
+    await fsp.writeFile(`${output}/${file}`, content.join('\n'), { encoding: 'utf-8' });
 }
 // prisma generator handler
-(0, generator_helper_1.generatorHandler)({
+generatorHandler({
     onManifest() {
         return {
             defaultOutput: './mermaid-er',

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

@@ -5,10 +5,5 @@ declare const RELATIONSHIPS: {
     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

@@ -1,19 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildRelationLine = buildRelationLine;
-const is_relationship_1 = require("../validator/is-relationship");
+import { isRelationship } from '../validator/is-relationship.js';
 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) {
+export function buildRelationLine(input) {
     const parts = input.split('-to-');
     if (parts.length !== 2) {
         throw new Error(`Invalid input format: ${input}`);
@@ -24,14 +16,14 @@ function buildRelationLine(input) {
     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}`);
+    if (!isRelationship(from)) {
+        throw new Error(`Invalid relationship: ${from}`);
+    }
+    if (!isRelationship(to)) {
+        throw new Error(`Invalid relationship: ${to}`);
     }
     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/types.js

@@ -0,0 +1 @@
+export {};

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

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

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

@@ -1,4 +1,4 @@
-import type { Model } from '../type';
+import type { Model } from '../types.js';
 /**
  * extract relations from model
  * @param { Model } model

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

@@ -1,22 +1,19 @@
-"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");
+import { relationLine } from '../generator/relation-line.js';
+import { parseRelation } from './index.js';
 /**
  * extract relations from model
  * @param { Model } model
  * @returns { readonly string[] }
  */
-function extractRelations(model) {
+export 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;
+            const relation = parseRelation(line);
+            return relation ? relationLine(relation) : null;
         })
             .filter((line) => line !== null);
         relations.push(...annotationRelations);