sizuku 0.0.7 → 0.1.0

package/README.md

@@ -21,432 +21,178 @@ npm install -D sizuku
 
 ### Example
 
-input:
+Prepare schema.ts:
 
 ```ts
-import { sql } from 'drizzle-orm'
-import { mysqlTable, varchar, timestamp, unique } from 'drizzle-orm/mysql-core'
+import { mysqlTable, varchar } from 'drizzle-orm/mysql-core'
+import { relations } from 'drizzle-orm'
 
 export const user = mysqlTable('user', {
-  /// Unique identifier for the user.
-  /// @z.string().uuid()
+  /// Primary key
+  /// @z.uuid()
   /// @v.pipe(v.string(), v.uuid())
   id: varchar('id', { length: 36 }).primaryKey(),
-  /// Username of the user.
-  /// @z.string()
-  /// @v.string()
-  username: varchar('username', { length: 255 }).notNull(),
-  /// Email address of the user.
-  /// @z.string().email()
-  /// @v.pipe(v.string(), v.email())
-  email: varchar('email', { length: 255 }).notNull().unique(),
-  /// Password for the user.
-  /// @z.string().min(8).max(100)
-  /// @v.pipe(v.string(), v.minLength(8), v.maxLength(100))
-  password: varchar('password', { length: 100 }).notNull(),
-  /// Timestamp when the user was created.
-  /// @z.date()
-  /// @v.date()
-  createdAt: timestamp('created_at', { mode: 'string' }).notNull().default(sql`CURRENT_TIMESTAMP`),
-  /// Timestamp when the user was last updated.
-  /// @z.date()
-  /// @v.date()
-  updatedAt: timestamp('updated_at', { mode: 'string' })
-    .notNull()
-    .default(sql`CURRENT_TIMESTAMP`)
-    .$onUpdate(() => sql`CURRENT_TIMESTAMP`),
+  /// Display name
+  /// @z.string().min(1).max(50)
+  /// @v.pipe(v.string(), v.minLength(1), v.maxLength(50))
+  name: varchar('name', { length: 50 }).notNull(),
 })
 
 /// @relation user.id post.userId one-to-many
 export const post = mysqlTable('post', {
-  /// Unique identifier for the post.
-  /// @z.string().uuid()
+  /// Primary key
+  /// @z.uuid()
   /// @v.pipe(v.string(), v.uuid())
   id: varchar('id', { length: 36 }).primaryKey(),
-  /// ID of the user who created the post.
-  /// @z.string().uuid()
-  /// @v.pipe(v.string(), v.uuid())
-  userId: varchar('user_id', { length: 36 })
-    .notNull()
-    .references(() => user.id, { onDelete: 'cascade' }),
-  /// Content of the post.
+  /// Article title
+  /// @z.string().min(1).max(100)
+  /// @v.pipe(v.string(), v.minLength(1), v.maxLength(100))
+  title: varchar('title', { length: 100 }).notNull(),
+  /// Body content (no length limit)
   /// @z.string()
   /// @v.string()
-  content: varchar('content', { length: 500 }).notNull(),
-  /// Timestamp when the post was created.
-  /// @z.date()
-  /// @v.date()
-  createdAt: timestamp('created_at', { mode: 'string' }).notNull().default(sql`CURRENT_TIMESTAMP`),
-  /// Timestamp when the post was last updated.
-  /// @z.date()
-  /// @v.date()
-  updatedAt: timestamp('updated_at', { mode: 'string' })
-    .notNull()
-    .default(sql`CURRENT_TIMESTAMP`)
-    .$onUpdate(() => sql`CURRENT_TIMESTAMP`),
+  content: varchar('content', { length: 65535 }).notNull(),
+  /// Foreign key referencing User.id
+  /// @z.uuid()
+  /// @v.pipe(v.string(), v.uuid())
+  userId: varchar('user_id', { length: 36 }).notNull(),
 })
 
-/// @relation post.id likes.postId one-to-many
-/// @relation user.id likes.userId one-to-many
-export const likes = mysqlTable(
-  'likes',
-  {
-    /// Unique identifier for the like.
-    /// @z.string().uuid()
-    /// @v.pipe(v.string(), v.uuid())
-    id: varchar('id', { length: 36 }).primaryKey(),
-    /// ID of the post that is liked.
-    /// @z.string().uuid()
-    /// @v.pipe(v.string(), v.uuid())
-    postId: varchar('post_id', { length: 36 })
-      .notNull()
-      .references(() => post.id, { onDelete: 'cascade' }),
-    /// ID of the user who liked the post.
-    /// @z.string().uuid()
-    /// @v.pipe(v.string(), v.uuid())
-    userId: varchar('user_id', { length: 36 })
-      .notNull()
-      .references(() => user.id, { onDelete: 'cascade' }),
-    /// Timestamp when the like was created.
-    /// @z.date()
-    /// @v.date()
-    createdAt: timestamp('created_at', { mode: 'string' })
-      .notNull()
-      .default(sql`CURRENT_TIMESTAMP`),
+export const userRelations = relations(user, ({ many }) => ({
+  posts: many(post),
+}))
+
+export const postRelations = relations(post, ({ one }) => ({
+  user: one(user, {
+    fields: [post.userId],
+    references: [user.id],
+  }),
+}))
+```
+
+Prepare sizuku.json:
+
+```json
+{
+  "input": "db/schema.ts",
+  "zod": {
+    "output": "zod/index.ts",
+    "comment": true,
+    "type": true
+  },
+  "valibot": {
+    "output": "valibot/index.ts",
+    "comment": true
   },
-  (t) => [unique().on(t.userId, t.postId)],
-)
+  "mermaid": {
+    "output": "mermaid-er/ER.md"
+  }
+}
 ```
 
-### Zod
+Run Sizuku:
 
-```bash
-npx sizuku-zod path/to/db/schema.ts -o path/to/output.ts
+```sh
+npx sizuku
 ```
 
-output:
+### 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.
-   */
-  username: z.string(),
-  /**
-   * Email address of the user.
-   */
-  email: z.string().email(),
-  /**
-   * Password for the user.
+   * Primary key
    */
-  password: z.string().min(8).max(100),
+  id: z.uuid(),
   /**
-   * Timestamp when the user was created.
+   * Display name
    */
-  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(),
   /**
-   * Timestamp when the post was created.
-   */
-  createdAt: z.date(),
-  /**
-   * Timestamp when the post was last updated.
+   * Foreign key referencing User.id
    */
-  updatedAt: z.date(),
+  userId: z.uuid(),
 })
 
-export const LikesSchema = 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 Post = z.infer<typeof PostSchema>
 ```
 
 ### Valibot
 
-```bash
-npx sizuku-valibot path/to/db/schema.ts -o path/to/output.ts
-```
-
-output:
-
 ```ts
 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.string(),
-  /**
-   * 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.
+   * Article title
    */
-  userId: v.pipe(v.string(), v.uuid()),
+  title: v.pipe(v.string(), v.minLength(1), v.maxLength(100)),
   /**
-   * Content of the post.
+   * Body content (no length limit)
    */
   content: v.string(),
   /**
-   * Timestamp when the post was created.
-   */
-  createdAt: v.date(),
-  /**
-   * Timestamp when the post was last updated.
-   */
-  updatedAt: v.date(),
-})
-
-export const LikesSchema = v.object({
-  /**
-   * Unique identifier for the like.
-   */
-  id: v.pipe(v.string(), v.uuid()),
-  /**
-   * ID of the post that is liked.
-   */
-  postId: v.pipe(v.string(), v.uuid()),
-  /**
-   * 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(),
 })
-```
-
-### Mermaid ER
 
-```bash
-npx sizuku-mermaid-er path/to/db/schema.ts -o path/to/output.md
+export type Post = v.InferInput<typeof PostSchema>
 ```
 
-output:
+### Mermaid ER
 
 ```mermaid
 erDiagram
     user ||--}| post : "(id) - (userId)"
-    post ||--}| likes : "(id) - (postId)"
-    user ||--}| likes : "(id) - (userId)"
     user {
-        varchar id "(PK) Unique identifier for the user."
-        varchar username "Username of the user."
-        varchar email "Email address of the user."
-        varchar password "Password for the user."
-        timestamp createdAt "Timestamp when the user was created."
-        timestamp updatedAt "Timestamp when the user was last updated."
+        varchar id "(PK) Primary key"
+        varchar name "Display name"
     }
     post {
-        varchar id "(PK) Unique identifier for the post."
-        varchar userId "(FK) ID of the user who created the post."
-        varchar content "Content of the post."
-        timestamp createdAt "Timestamp when the post was created."
-        timestamp updatedAt "Timestamp when the post was last updated."
-    }
-    likes {
-        varchar id "(PK) Unique identifier for the like."
-        varchar postId "(FK) ID of the post that is liked."
-        varchar userId "(FK) ID of the user who liked the post."
-        timestamp createdAt "Timestamp when the like was created."
+        varchar id "(PK) Primary key"
+        varchar title "Article title"
+        varchar content "Body content (no length limit)"
+        varchar userId "Foreign key referencing User.id"
     }
 ```
 
-## Configuration
-
-### sizuku-zod.json
-
-#### Schema Options
-
-| Option | Type | Default | Description |
-|--------|------|---------|-------------|
-| `name` | `"PascalCase"` \| `"camelCase"` | `"PascalCase"` | Naming convention for generated schema variables |
-| `export` | `boolean` | `false` | When true, exports all schema definitions |
-
-#### Type Options
-
-| Option | Type | Default | Description |
-|--------|------|---------|-------------|
-| `name` | `"PascalCase"` \| `"camelCase"` | `"PascalCase"` | Naming convention for generated type definitions |
-| `export` | `boolean` | `false` | When true, exports all type definitions |
-
-#### Comment Options
-
-| Option | Type | Default | Description |
-|--------|------|---------|-------------|
-| `name` | `boolean` | `false` | If enabled, includes the element's original name in TSDoc comments. |
-
-#### Input and Output
-
-| Option | Type | Default | Description |
-|--------|------|---------|-------------|
-| `input` | `string` | `""` | Input file path |
-| `output` | `string` | `""` | Output file path |
-
-#### Example
-
-```json
-{
-  "schema": {
-    "name": "PascalCase"
-  },
-  "type": {
-    "name": "PascalCase",
-    "export": false
-  },
-  "comment": true,
-  "input": "db/schema.ts",
-  "output": "zod/index.ts"
-}
-```
-
-> **⚠️** When using a configuration file, command line arguments are not required. The configuration file settings take precedence over command line arguments.
->
-> When you have configured `sizuku-zod.json`, you can simply run:
-> ```bash
-> npx sizuku-zod
-> ```
-
-### sizuku-valibot.json
-
-#### Schema Options
-
-| Option   | Type                            | Default        | Description                                |
-|----------|---------------------------------|----------------|--------------------------------------------|
-| `name`   | `"PascalCase"` \| `"camelCase"` | `"PascalCase"` | Naming convention for generated schema variables                                                                                                  |
-| `export` | `boolean`                       | `false`         | When true, exports all schema definitions |
-
-#### Type Options
-
-| Option   | Type                            | Default        | Description                             |
-|----------|---------------------------------|----------------|-----------------------------------------|
-| `name`   | `"PascalCase"` \| `"camelCase"` | `"PascalCase"` | Naming convention for generated type definitions                                                                                             |
-| `export` | `boolean`                       | `false`        | When true, exports all type definitions |
-
-#### Comment Options
-
-| Option | Type           | Default | Description                                                         |
-|--------|----------------|---------|---------------------------------------------------------------------|
-| `name` | `boolean`      | `false` | If enabled, includes the element's original name in TSDoc comments. |
-
-#### Input and Output
-
-| Option | Type | Default     | Description |
-|--------|------|-------------|-------------|
-| `input` | `string` | `""`   | Input file path |
-| `output` | `string` | `""`  | Output file path |
-
-#### Examples
-
-```json
-{
-  "schema": {
-    "name": "PascalCase"
-  },
-  "type": {
-    "name": "PascalCase",
-    "export": false
-  },
-  "comment": true,
-  "input": "db/schema.ts",
-  "output": "valibot/index.ts"
-}
-```
-
-> **⚠️** When using a configuration file, command line arguments are not required. The configuration file settings take precedence over command line arguments.
->
-> When you have configured `sizuku-valibot.json`, you can simply run:
-> ```bash
-> npx sizuku-valibot
-> ```
-
-### sizuku-mermaid-er.json
-
-| Option   | Type     | Default    | Description      |
-|----------|----------|------------|------------------|
-| `input`  | `string` | `""`       | Input file path  |
-| `output` | `string` | `""`       | Output file path |
-
-#### Example
-
-```json
-{
-  "input": "db/schema.ts",
-  "output": "mermaid-er/ER.md"
-}
-```
-
-> **⚠️** When using a configuration file, command line arguments are not required. The configuration file settings take precedence over command line arguments.
->
-> When you have configured `sizuku-mermaid-er.json`, you can simply run:
-> ```bash
-> npx sizuku-mermaid-er
-> ```
-
 This project is in **early development** and being maintained by a developer with about 2 years of experience. While I'm doing my best to create a useful tool:
 
 ### ⚠️ WARNING: Potential Breaking Changes Without Notice

package/dist/config/index.d.ts

@@ -0,0 +1,18 @@
+export type Config = {
+    input?: `${string}.ts`;
+    zod?: {
+        output?: `${string}.ts`;
+        comment?: boolean;
+        type?: boolean;
+        zod?: 'v4' | 'v4-mini' | '@hono/zod-openapi';
+    };
+    valibot?: {
+        output?: `${string}.ts`;
+        comment?: boolean;
+        type?: boolean;
+    };
+    mermaid?: {
+        output?: string;
+    };
+};
+export declare function getConfig(): Config;

package/dist/config/index.js

@@ -0,0 +1,13 @@
+import fs from 'node:fs';
+export function getConfig() {
+    if (!fs.existsSync('sizuku.json')) {
+        throw new Error('sizuku.json not found');
+    }
+    const parsed = JSON.parse(fs.readFileSync('sizuku.json', 'utf-8'));
+    return {
+        input: parsed.input,
+        zod: parsed.zod,
+        valibot: parsed.valibot,
+        mermaid: parsed.mermaid,
+    };
+}

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

@@ -1,10 +1,10 @@
 export type Config = {
-    input?: string;
-    output?: string;
-};
+  input?: string
+  output?: string
+}
 /**
  * Loads the configuration from the `sizuku.json` file or returns the default configuration.
  *
  * @returns The configuration object.
  */
-export declare function getConfig(): Config;
+export declare function getConfig(): Config

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

@@ -1,18 +1,12 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getConfig = getConfig;
-const node_fs_1 = __importDefault(require("node:fs"));
+import fs from 'node:fs';
 /**
  * Loads the configuration from the `sizuku.json` file or returns the default configuration.
  *
  * @returns The configuration object.
  */
-function getConfig() {
-    const config = node_fs_1.default.existsSync('sizuku-mermaid-er.json')
-        ? { ...JSON.parse(node_fs_1.default.readFileSync('sizuku-mermaid-er.json', 'utf-8')) }
+export function getConfig() {
+    const config = fs.existsSync('sizuku-mermaid-er.json')
+        ? { ...JSON.parse(fs.readFileSync('sizuku-mermaid-er.json', 'utf-8')) }
         : {};
     return config;
 }

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

@@ -1,4 +1,4 @@
-import type { Relation } from '../type';
+import type { Relation } from '../types.js';
 /**
  * Extracts relations from the given code.
  *

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

@@ -1,17 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractRelations = extractRelations;
-const parse_relation_line_1 = require("../validator/parse-relation-line");
+import { parseRelationLine } from '../validator/parse-relation-line.js';
 /**
  * Extracts relations from the given code.
  *
  * @param code - The code to extract relations from.
  * @returns The extracted relations.
  */
-function extractRelations(code) {
+export function extractRelations(code) {
     const relations = [];
     for (const line of code) {
-        const relation = (0, parse_relation_line_1.parseRelationLine)(line);
+        const relation = parseRelationLine(line);
         if (relation) {
             relations.push(relation);
         }

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

@@ -1,9 +1,8 @@
-import type { Relation, TableInfo } from '../type';
+import type { Relation, TableInfo } from '../types.js';
 /**
  * Generate ER content
- * @function generateERContent
  * @param relations - The relations to generate the ER content from
  * @param tables - The tables to generate the ER content from
  * @returns The generated ER content
  */
-export declare function generateERContent(relations: Relation[], tables: TableInfo[]): string;
+export declare function erContent(relations: Relation[], tables: TableInfo[]): string;

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

@@ -1,20 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateERContent = generateERContent;
-const generate_relation_line_1 = require("./generate-relation-line");
+import { relationLine } from './index.js';
 const ER_HEADER = ['```mermaid', 'erDiagram'];
 const ER_FOOTER = ['```'];
 /**
  * Generate ER content
- * @function generateERContent
  * @param relations - The relations to generate the ER content from
  * @param tables - The tables to generate the ER content from
  * @returns The generated ER content
  */
-function generateERContent(relations, tables) {
+export function erContent(relations, tables) {
     const erContent = [
         ...ER_HEADER,
-        ...relations.map(generate_relation_line_1.generateRelationLine),
+        ...relations.map(relationLine),
         // Generate per-table definitions
         ...tables.flatMap((table) => [
             `    ${table.name} {`,

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

@@ -0,0 +1,2 @@
+export { relationLine } from './relation-line.js';
+export { erContent } from './er-content.js';

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

@@ -0,0 +1,2 @@
+export { relationLine } from './relation-line.js';
+export { erContent } from './er-content.js';

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

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