sizuku 0.1.0 → 0.2.0

package/README.md

@@ -24,8 +24,8 @@ npm install -D sizuku
 Prepare schema.ts:
 
 ```ts
-import { mysqlTable, varchar } from 'drizzle-orm/mysql-core'
 import { relations } from 'drizzle-orm'
+import { mysqlTable, varchar } from 'drizzle-orm/mysql-core'
 
 export const user = mysqlTable('user', {
   /// Primary key
@@ -49,8 +49,8 @@ export const post = mysqlTable('post', {
   /// @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()
+  /// @z.string().min(1).max(65535)
+  /// @v.pipe(v.string(), v.minLength(1), v.maxLength(65535))
   content: varchar('content', { length: 65535 }).notNull(),
   /// Foreign key referencing User.id
   /// @z.uuid()
@@ -99,7 +99,7 @@ npx sizuku
 ### Zod
 
 ```ts
-import { z } from 'zod/v4'
+import * as z from 'zod'
 
 export const UserSchema = z.object({
   /**
@@ -126,7 +126,7 @@ export const PostSchema = z.object({
   /**
    * Body content (no length limit)
    */
-  content: z.string(),
+  content: z.string().min(1).max(65535),
   /**
    * Foreign key referencing User.id
    */
@@ -134,6 +134,14 @@ export const PostSchema = z.object({
 })
 
 export type Post = z.infer<typeof PostSchema>
+
+export const UserRelationsSchema = z.object({ ...UserSchema.shape, posts: z.array(PostSchema) })
+
+export type UserRelations = z.infer<typeof UserRelationsSchema>
+
+export const PostRelationsSchema = z.object({ ...PostSchema.shape, user: UserSchema })
+
+export type PostRelations = z.infer<typeof PostRelationsSchema>
 ```
 
 ### Valibot
@@ -152,8 +160,6 @@ export const UserSchema = v.object({
   name: v.pipe(v.string(), v.minLength(1), v.maxLength(50)),
 })
 
-export type User = v.InferInput<typeof UserSchema>
-
 export const PostSchema = v.object({
   /**
    * Primary key
@@ -166,14 +172,16 @@ export const PostSchema = v.object({
   /**
    * Body content (no length limit)
    */
-  content: v.string(),
+  content: v.pipe(v.string(), v.minLength(1), v.maxLength(65535)),
   /**
    * Foreign key referencing User.id
    */
   userId: v.pipe(v.string(), v.uuid()),
 })
 
-export type Post = v.InferInput<typeof PostSchema>
+export const UserRelationsSchema = v.object({ ...UserSchema.entries, posts: v.array(PostSchema) })
+
+export const PostRelationsSchema = v.object({ ...PostSchema.entries, user: UserSchema })
 ```
 
 ### Mermaid ER
@@ -193,8 +201,6 @@ erDiagram
     }
 ```
 
-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
 
 **This package is in active development and may introduce breaking changes without prior notice.

package/dist/cli/main.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import type { Result } from 'neverthrow';
+import type { Config } from '../src/config/index.js';
+/**
+ * Main CLI function that orchestrates the schema generation process.
+ *
+ * @param config - The configuration object.
+ * @returns A Result indicating success or failure.
+ */
+export declare function main(config?: Config): Promise<Result<void, Error>>;

package/dist/cli/main.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+import { err, ok, ResultAsync } from 'neverthrow';
+import { getConfig } from '../src/config/index.js';
+import { sizukuMermaidER } from '../src/generator/mermaid-er/index.js';
+import { sizukuValibot } from '../src/generator/valibot/index.js';
+import { sizukuZod } from '../src/generator/zod/index.js';
+import { readFileSync } from '../src/shared/fs/index.js';
+/**
+ * Main CLI function that orchestrates the schema generation process.
+ *
+ * @param config - The configuration object.
+ * @returns A Result indicating success or failure.
+ */
+export async function main(config = getConfig()) {
+    return ResultAsync.fromPromise(Promise.resolve(), () => new Error('init'))
+        .andThen(() => {
+        if (!config.input) {
+            return err(new Error('input is not found'));
+        }
+        const contentResult = readFileSync(config.input);
+        if (contentResult.isErr()) {
+            return err(contentResult.error);
+        }
+        const content = contentResult.value;
+        const lines = content.split('\n');
+        const codeStart = lines.findIndex((line) => !line.trim().startsWith('import') && line.trim() !== '');
+        return ok(lines.slice(codeStart));
+    })
+        .andThen((code) => {
+        if (config.zod?.output) {
+            return ResultAsync.fromPromise(sizukuZod(code, config.zod.output, config.zod.comment, config.zod.type, config.zod.zod), (e) => (e instanceof Error ? e : new Error(String(e)))).map(() => {
+                console.log(`Generated Zod schema at: ${config.zod?.output}`);
+                return code;
+            });
+        }
+        return ok(code);
+    })
+        .andThen((code) => {
+        if (config.valibot?.output) {
+            return ResultAsync.fromPromise(sizukuValibot(code, config.valibot.output, config.valibot.comment, config.valibot.type), (e) => (e instanceof Error ? e : new Error(String(e)))).map(() => {
+                console.log(`Generated Valibot schema at: ${config.valibot?.output}`);
+                return code;
+            });
+        }
+        return ok(code);
+    })
+        .andThen((code) => {
+        if (config.mermaid?.output) {
+            return ResultAsync.fromPromise(sizukuMermaidER(code, config.mermaid.output), (e) => e instanceof Error ? e : new Error(String(e))).map(() => {
+                console.log(`Generated Mermaid ER at: ${config.mermaid?.output}`);
+            });
+        }
+        return ok(undefined);
+    });
+}
+main().then((result) => {
+    if (!result.isOk()) {
+        console.error(result.error);
+        process.exit(1);
+    }
+});

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+import { resolve } from 'path';
+import { Result, err, ok } from 'neverthrow';
+import { loadConfig, validateConfig } from './config/loader.js';
+import { generateSchemas } from './generator/engine.js';
+const main = async () => {
+    try {
+        // コマンドライン引数を解析
+        const args = process.argv.slice(2);
+        if (args.length === 0) {
+            return err(new Error('Usage: sizuku <config-file>'));
+        }
+        const configPath = resolve(args[0]);
+        // 設定ファイルを読み込み
+        const configResult = await loadConfig(configPath);
+        if (configResult.isErr()) {
+            return err(configResult.error);
+        }
+        // 設定をバリデーション
+        const validationResult = validateConfig(configResult.value);
+        if (validationResult.isErr()) {
+            return err(validationResult.error);
+        }
+        const config = validationResult.value;
+        // スキーマ生成を実行
+        const generationResult = await generateSchemas(config);
+        if (generationResult.isErr()) {
+            return err(generationResult.error);
+        }
+        console.log('✅ Schema generation completed successfully!');
+        return ok(undefined);
+    }
+    catch (error) {
+        return err(new Error(`CLI execution failed: ${error instanceof Error ? error.message : String(error)}`));
+    }
+};
+// CLI実行
+if (import.meta.url === `file://${process.argv[1]}`) {
+    main()
+        .then(result => {
+        if (result.isErr()) {
+            console.error('❌ Error:', result.error.message);
+            process.exit(1);
+        }
+        process.exit(0);
+    })
+        .catch(error => {
+        console.error('❌ Unexpected error:', error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    });
+}

package/dist/config/index.d.ts

@@ -4,7 +4,7 @@ export type Config = {
         output?: `${string}.ts`;
         comment?: boolean;
         type?: boolean;
-        zod?: 'v4' | 'v4-mini' | '@hono/zod-openapi';
+        zod?: 'v4' | 'mini' | '@hono/zod-openapi';
     };
     valibot?: {
         output?: `${string}.ts`;

package/dist/config/loader.d.ts

@@ -0,0 +1,19 @@
+import { Result } from 'neverthrow';
+export type SizukuConfig = {
+    input: string;
+    zod?: {
+        output: string;
+        comment?: boolean;
+        type?: boolean;
+    };
+    valibot?: {
+        output: string;
+        comment?: boolean;
+        type?: boolean;
+    };
+    mermaid?: {
+        output: string;
+    };
+};
+export declare const loadConfig: (configPath: string) => Promise<Result<SizukuConfig, Error>>;
+export declare const validateConfig: (config: SizukuConfig) => Result<SizukuConfig, Error>;

package/dist/config/loader.js

@@ -0,0 +1,30 @@
+import { readFile } from 'fs/promises';
+import { Result, err, ok } from 'neverthrow';
+export const loadConfig = async (configPath) => {
+    try {
+        const configContent = await readFile(configPath, 'utf-8');
+        const config = JSON.parse(configContent);
+        // 基本的なバリデーション
+        if (!config.input) {
+            return err(new Error('Config must specify input file path'));
+        }
+        return ok(config);
+    }
+    catch (error) {
+        return err(new Error(`Failed to load config from ${configPath}: ${error instanceof Error ? error.message : String(error)}`));
+    }
+};
+export const validateConfig = (config) => {
+    try {
+        if (!config.input) {
+            return err(new Error('Input file path is required'));
+        }
+        if (!config.zod && !config.valibot && !config.mermaid) {
+            return err(new Error('At least one output format must be specified (zod, valibot, or mermaid)'));
+        }
+        return ok(config);
+    }
+    catch (error) {
+        return err(new Error(`Config validation failed: ${error instanceof Error ? error.message : String(error)}`));
+    }
+};

package/dist/generator/engine.d.ts

@@ -0,0 +1,3 @@
+import { Result } from 'neverthrow';
+import type { SizukuConfig } from '../config/loader.js';
+export declare const generateSchemas: (config: SizukuConfig) => Promise<Result<void, Error>>;

package/dist/generator/engine.js

@@ -0,0 +1,63 @@
+import { Result, err, ok } from 'neverthrow';
+import { parseSchemaFile } from '../shared/helper/ast-parser.js';
+import { generateZodSchemas } from './zod/generator.js';
+import { generateValibotSchemas } from './valibot/generator.js';
+import { generateMermaidERDiagram } from './mermaid-er/generator.js';
+import { writeFileSafely } from '../shared/helper/file-writer.js';
+export const generateSchemas = async (config) => {
+    try {
+        // スキーマファイルを解析
+        const parseResult = await parseSchemaFile(config.input);
+        if (parseResult.isErr()) {
+            return err(parseResult.error);
+        }
+        const schema = parseResult.value;
+        // 各フォーマットを生成
+        const results = [];
+        if (config.zod) {
+            results.push(generateZodOutput(schema, config.zod.output));
+        }
+        if (config.valibot) {
+            results.push(generateValibotOutput(schema, config.valibot.output));
+        }
+        if (config.mermaid) {
+            results.push(generateMermaidOutput(schema, config.mermaid.output));
+        }
+        // すべての生成を待機
+        const generationResults = await Promise.all(results);
+        // エラーがあれば最初のエラーを返す
+        for (const result of generationResults) {
+            if (result.isErr()) {
+                return err(result.error);
+            }
+        }
+        return ok(undefined);
+    }
+    catch (error) {
+        return err(new Error(`Schema generation failed: ${error instanceof Error ? error.message : String(error)}`));
+    }
+};
+const generateZodOutput = async (schema, outputPath) => {
+    const zodResult = generateZodSchemas(schema);
+    if (zodResult.isErr()) {
+        return err(zodResult.error);
+    }
+    const writeResult = await writeFileSafely(outputPath, zodResult.value);
+    return writeResult;
+};
+const generateValibotOutput = async (schema, outputPath) => {
+    const valibotResult = generateValibotSchemas(schema);
+    if (valibotResult.isErr()) {
+        return err(valibotResult.error);
+    }
+    const writeResult = await writeFileSafely(outputPath, valibotResult.value);
+    return writeResult;
+};
+const generateMermaidOutput = async (schema, outputPath) => {
+    const mermaidResult = generateMermaidERDiagram(schema);
+    if (mermaidResult.isErr()) {
+        return err(mermaidResult.error);
+    }
+    const writeResult = await writeFileSafely(outputPath, mermaidResult.value);
+    return writeResult;
+};

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

@@ -0,0 +1,6 @@
+import type { TableInfo, ColumnInfo, RelationInfo } from '../../shared/utils/types.js';
+export declare const generateMermaidER: (tables: TableInfo[]) => string;
+export declare const generateRelations: (tables: TableInfo[]) => string;
+export declare const generateRelationLine: (relation: RelationInfo) => string;
+export declare const generateEntity: (table: TableInfo) => string;
+export declare const generateColumnDefinition: (column: ColumnInfo) => string;

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

@@ -0,0 +1,54 @@
+// 完全純粋なMermaid ER図生成ユーティリティ - 外部import禁止
+export const generateMermaidER = (tables) => {
+    const header = 'erDiagram';
+    const relations = generateRelations(tables);
+    const entities = tables.map(table => generateEntity(table)).join('\n    ');
+    return `${header}
+    ${relations}
+    ${entities}`;
+};
+export const generateRelations = (tables) => {
+    const relations = [];
+    for (const table of tables) {
+        for (const relation of table.relations) {
+            const relationLine = generateRelationLine(relation);
+            if (relationLine) {
+                relations.push(relationLine);
+            }
+        }
+    }
+    return relations.join('\n    ');
+};
+export const generateRelationLine = (relation) => {
+    const sourceTable = relation.sourceTable;
+    const targetTable = relation.targetTable;
+    const sourceColumn = relation.sourceColumn;
+    const targetColumn = relation.targetColumn;
+    if (relation.type === 'one-to-many') {
+        return `${sourceTable} ||--}| ${targetTable} : "(${sourceColumn}) - (${targetColumn})"`;
+    }
+    else if (relation.type === 'many-to-one') {
+        return `${targetTable} ||--}| ${sourceTable} : "(${targetColumn}) - (${sourceColumn})"`;
+    }
+    else if (relation.type === 'one-to-one') {
+        return `${sourceTable} ||--|| ${targetTable} : "(${sourceColumn}) - (${targetColumn})"`;
+    }
+    else if (relation.type === 'many-to-many') {
+        return `${sourceTable} }|--|{ ${targetTable} : "(${sourceColumn}) - (${targetColumn})"`;
+    }
+    return '';
+};
+export const generateEntity = (table) => {
+    const columns = table.columns.map(column => generateColumnDefinition(column)).join('\n        ');
+    return `${table.name} {
+        ${columns}
+    }`;
+};
+export const generateColumnDefinition = (column) => {
+    const type = column.type;
+    const name = column.name;
+    const comment = column.comment || '';
+    const primaryKey = column.isPrimary ? ' (PK)' : '';
+    const nullable = column.isNullable ? '' : ' NOT NULL';
+    return `${type} ${name}${primaryKey}${nullable} "${comment}"`;
+};

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

@@ -1,8 +1,20 @@
-import type { Relation, TableInfo } from '../types.js';
 /**
  * Generate ER content
  * @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 erContent(relations: Relation[], tables: TableInfo[]): string;
+export declare function erContent(relations: {
+    fromModel: string;
+    toModel: string;
+    fromField: string;
+    toField: string;
+    type: string;
+}[], tables: {
+    name: string;
+    fields: {
+        type: string;
+        name: string;
+        description: string | null;
+    }[];
+}[]): string;

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

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

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

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

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

@@ -1,7 +1,12 @@
-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 relationLine(relation: Relation): string;
+export declare function relationLine(relation: {
+    fromModel: string;
+    toModel: string;
+    fromField: string;
+    toField: string;
+    type: string;
+}): string;

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

@@ -1,4 +1,4 @@
-import { buildRelationLine } from '../relationship/build-relation-line.js';
+import { buildRelationLine } from '../../../shared/helper/extract-schemas.js';
 /**
  * Generate a relation line for a relation
  * @param relation - The relation to generate a line for

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

@@ -0,0 +1,3 @@
+import { Result } from 'neverthrow';
+import type { ParsedSchema } from '../../shared/utils/types.js';
+export declare const generateMermaidERDiagram: (schema: ParsedSchema) => Result<string, Error>;

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

@@ -0,0 +1,14 @@
+import { Result, err, ok } from 'neverthrow';
+import { generateMermaidER } from './core.js';
+export const generateMermaidERDiagram = (schema) => {
+    try {
+        if (schema.tables.length === 0) {
+            return err(new Error('No tables found in schema'));
+        }
+        const mermaidContent = generateMermaidER(schema.tables);
+        return ok(mermaidContent);
+    }
+    catch (error) {
+        return err(new Error(`Failed to generate Mermaid ER diagram: ${error instanceof Error ? error.message : String(error)}`));
+    }
+};

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

@@ -3,4 +3,10 @@
  * @param code - The code to generate Mermaid ER diagram from
  * @param output - The output file path
  */
-export declare function sizukuMermaidER(code: string[], output: string): Promise<import("neverthrow").Result<void, Error>>;
+export declare function sizukuMermaidER(code: string[], output: string): Promise<{
+    ok: true;
+    value: undefined;
+} | {
+    ok: false;
+    error: string;
+}>;

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

@@ -1,8 +1,8 @@
+import path from 'node:path';
 import { mkdir, writeFile } from '../../shared/fsp/index.js';
-import { extractRelations } from './core/extract-relations.js';
+import { extractRelations } from '../../shared/helper/extract-schemas.js';
 import { erContent } from './generator/index.js';
-import { parseTableInfo } from './validator/parse-table-info.js';
-import path from 'node:path';
+import { parseTableInfo } from './validator/index.js';
 /**
  * Generate Mermaid ER diagram
  * @param code - The code to generate Mermaid ER diagram from
@@ -12,5 +12,22 @@ export async function sizukuMermaidER(code, output) {
     const tables = parseTableInfo(code);
     const relations = extractRelations(code);
     const ERContent = erContent(relations, tables);
-    return await mkdir(path.dirname(output)).andThen(() => writeFile(output, ERContent));
+    const mkdirResult = await mkdir(path.dirname(output));
+    if (!mkdirResult.ok) {
+        return {
+            ok: false,
+            error: mkdirResult.error,
+        };
+    }
+    const writeFileResult = await writeFile(output, ERContent);
+    if (!writeFileResult.ok) {
+        return {
+            ok: false,
+            error: writeFileResult.error,
+        };
+    }
+    return {
+        ok: true,
+        value: undefined,
+    };
 }

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

@@ -1,4 +1,8 @@
-export { isRelationship } from './is-relationship.js';
-export { parseRelationLine } from './parse-relation-line.js';
-export { parseTableInfo } from './parse-table-info.js';
-export { removeDuplicateRelations } from './remove-duplicate-relations.js';
+export declare function parseTableInfo(code: string[]): {
+    name: string;
+    fields: {
+        type: string;
+        name: string;
+        description: string | null;
+    }[];
+}[];

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

@@ -1,4 +1,71 @@
-export { isRelationship } from './is-relationship.js';
-export { parseRelationLine } from './parse-relation-line.js';
-export { parseTableInfo } from './parse-table-info.js';
-export { removeDuplicateRelations } from './remove-duplicate-relations.js';
+import { Node, Project } from 'ts-morph';
+const baseBuilderName = (expr) => {
+    if (Node.isIdentifier(expr))
+        return expr.getText();
+    if (Node.isCallExpression(expr) || Node.isPropertyAccessExpression(expr))
+        return baseBuilderName(expr.getExpression());
+    return '';
+};
+const isFieldInfo = (v) => v !== null;
+export function parseTableInfo(code) {
+    const source = code.join('\n');
+    const file = new Project({ useInMemoryFileSystem: true }).createSourceFile('temp.ts', source);
+    return file
+        .getVariableStatements()
+        .filter((stmt) => stmt.isExported())
+        .flatMap((stmt) => {
+        const decl = stmt.getDeclarations()[0];
+        if (!Node.isVariableDeclaration(decl))
+            return [];
+        const varName = decl.getName();
+        if (varName.toLowerCase().includes('relation'))
+            return [];
+        const init = decl.getInitializer();
+        if (!(init && Node.isCallExpression(init)))
+            return [];
+        const callee = init.getExpression().getText();
+        if (!callee.endsWith('Table') || callee === 'relations')
+            return [];
+        const objLit = init.getArguments()[1];
+        if (!(objLit && Node.isObjectLiteralExpression(objLit)))
+            return [];
+        const fields = objLit
+            .getProperties()
+            .filter(Node.isPropertyAssignment)
+            .map((prop) => {
+            const keyNode = prop.getNameNode();
+            if (!Node.isIdentifier(keyNode))
+                return null;
+            const fieldName = keyNode.getText();
+            const initExpr = prop.getInitializer();
+            if (!(initExpr && Node.isCallExpression(initExpr)))
+                return null;
+            const fieldType = baseBuilderName(initExpr);
+            const initText = initExpr.getText();
+            const lineIdx = prop.getStartLineNumber() - 1;
+            const baseDesc = code
+                .slice(0, lineIdx)
+                .reverse()
+                .find((line) => {
+                const t = line.trim();
+                return (t.startsWith('///') &&
+                    !t.includes('@z.') &&
+                    !t.includes('@v.') &&
+                    !t.includes('@relation'));
+            })
+                ?.replace(/^\s*\/\/\/\s*/, '') ?? '';
+            const prefix = initText.includes('.primaryKey()')
+                ? '(PK) '
+                : initText.includes('.references(')
+                    ? '(FK) '
+                    : '';
+            return {
+                name: fieldName,
+                type: fieldType,
+                description: `${prefix}${baseDesc}`.trim(),
+            };
+        })
+            .filter(isFieldInfo);
+        return [{ name: varName, fields }];
+    });
+}

package/dist/generator/mermaid-er/validator/parse-table-info.js

@@ -1,4 +1,4 @@
-import { Project, Node } from 'ts-morph';
+import { Node, Project } from 'ts-morph';
 const baseBuilderName = (expr) => {
     if (Node.isIdentifier(expr))
         return expr.getText();

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

@@ -0,0 +1,5 @@
+import type { TableInfo, ColumnInfo } from '../../shared/utils/types.js';
+export declare const generateValibotSchema: (table: TableInfo) => string;
+export declare const generateValibotProperty: (column: ColumnInfo) => string;
+export declare const generateDefaultValibotSchema: (column: ColumnInfo) => string;
+export declare const generateValibotFile: (tables: TableInfo[]) => string;