sizuku 0.0.7 → 0.2.0

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/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/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/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

@@ -0,0 +1,20 @@
+/**
+ * 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: {
+    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/{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 { erContent } from './er-content.js';
+export { relationLine } from './relation-line.js';

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

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

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

@@ -0,0 +1,12 @@
+/**
+ * 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: {
+    fromModel: string;
+    toModel: string;
+    fromField: string;
+    toField: string;
+    type: string;
+}): string;

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

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateRelationLine = generateRelationLine;
-const build_relation_line_1 = require("../relationship/build-relation-line");
+import { buildRelationLine } from '../../../shared/helper/extract-schemas.js';
 /**
  * Generate a relation line for a relation
  * @param relation - The relation to generate a line for
  * @returns The generated relation line
  */
-function generateRelationLine(relation) {
-    const cardinality = (0, build_relation_line_1.buildRelationLine)(relation.type);
+export function relationLine(relation) {
+    const cardinality = buildRelationLine(relation.type);
     if (!cardinality) {
         throw new Error(`Unknown relation type: ${relation.type}`);
     }

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

@@ -1,5 +1,12 @@
-#!/usr/bin/env node
-import type { Config } from './config';
-export declare const ER_HEADER: readonly ["```mermaid", "erDiagram"];
-export declare const ER_FOOTER: readonly ["```"];
-export declare function main(dev?: boolean, config?: Config): Promise<boolean>;
+/**
+ * Generate Mermaid ER diagram
+ * @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<{
+    ok: true;
+    value: undefined;
+} | {
+    ok: false;
+    error: string;
+}>;

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

@@ -1,77 +1,33 @@
-#!/usr/bin/env node
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ER_FOOTER = exports.ER_HEADER = void 0;
-exports.main = main;
-const node_fs_1 = require("node:fs");
-const node_path_1 = __importDefault(require("node:path"));
-const generate_er_content_1 = require("./generator/generate-er-content");
-const parse_table_info_1 = require("./validator/parse-table-info");
-const extract_relations_1 = require("./core/extract-relations");
-const config_1 = require("./config");
-const node_process_1 = require("node:process");
-// ER diagram header
-exports.ER_HEADER = ['```mermaid', 'erDiagram'];
-// ER diagram footer
-exports.ER_FOOTER = ['```'];
-async function main(dev = false, config = (0, config_1.getConfig)()) {
-    // 1. argv ['**/bin/node', '**/dist/src/generator/mermaid-er/index.js', 'db/schema.ts', '-o', 'mermaid-er/ER.md']
-    if (config.output === undefined && !node_process_1.argv.includes('-o')) {
-        console.error('Error: -o is not found');
-        return false;
+import path from 'node:path';
+import { mkdir, writeFile } from '../../shared/fsp/index.js';
+import { extractRelations } from '../../shared/helper/extract-schemas.js';
+import { erContent } from './generator/index.js';
+import { parseTableInfo } from './validator/index.js';
+/**
+ * Generate Mermaid ER diagram
+ * @param code - The code to generate Mermaid ER diagram from
+ * @param output - The output file path
+ */
+export async function sizukuMermaidER(code, output) {
+    const tables = parseTableInfo(code);
+    const relations = extractRelations(code);
+    const ERContent = erContent(relations, tables);
+    const mkdirResult = await mkdir(path.dirname(output));
+    if (!mkdirResult.ok) {
+        return {
+            ok: false,
+            error: mkdirResult.error,
+        };
     }
-    // 2. slice [ 'db/schema.ts', '-o', 'mermaid-er/ER.md']
-    const args = process.argv.slice(2);
-    // 3. input = args[0] = 'db/schema.ts'
-    const input = config.input ?? args[0];
-    config.input = input;
-    // 4. output = 'mermaid-er/ER.md'
-    const output = config.output ?? args[args.indexOf('-o') + 1];
-    config.output = output;
-    try {
-        // 5. read db/schema.ts
-        const content = (0, node_fs_1.readFileSync)(input, 'utf-8');
-        // 6. split lines
-        const lines = content.split('\n');
-        // 7. create output directory
-        const outputDir = node_path_1.default.dirname(output);
-        if (!(0, node_fs_1.existsSync)(outputDir)) {
-            (0, node_fs_1.mkdirSync)(outputDir, { recursive: true });
-        }
-        // 8. skip import section
-        const codeStart = lines.findIndex((line) => !line.trim().startsWith('import') && line.trim() !== '');
-        // 9. parse table info
-        const tables = (0, parse_table_info_1.parseTableInfo)(lines.slice(codeStart));
-        // 10. extract relations
-        const relations = (0, extract_relations_1.extractRelations)(lines.slice(codeStart));
-        // 11. generate ER content
-        const ERContent = (0, generate_er_content_1.generateERContent)(relations, tables);
-        // 12. write ER content to output file
-        (0, node_fs_1.writeFileSync)(output, ERContent);
-        console.log(`Generated ER at: ${output}`);
-        return true;
+    const writeFileResult = await writeFile(output, ERContent);
+    if (!writeFileResult.ok) {
+        return {
+            ok: false,
+            error: writeFileResult.error,
+        };
     }
-    catch (e) {
-        if (e instanceof Error) {
-            console.error(e.message);
-            if (dev) {
-                throw e;
-            }
-            process.exit(1);
-        }
-        if (dev) {
-            throw new Error('Unknown error occurred');
-        }
-        return false;
-    }
-}
-if (require.main === module) {
-    main().then((success) => {
-        if (!success) {
-            process.exit(1);
-        }
-    });
+    return {
+        ok: true,
+        value: undefined,
+    };
 }

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

@@ -1,7 +1,4 @@
-"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: '||',
@@ -13,7 +10,7 @@ const RELATIONSHIPS = {
  * @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,7 +21,7 @@ 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))) {
+    if (!(isRelationship(from) && isRelationship(to))) {
         throw new Error(`Invalid relationship string: ${input}`);
     }
     const fromSymbol = RELATIONSHIPS[from];

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

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

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

@@ -0,0 +1,8 @@
+export declare function parseTableInfo(code: string[]): {
+    name: string;
+    fields: {
+        type: string;
+        name: string;
+        description: string | null;
+    }[];
+}[];

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

@@ -0,0 +1,71 @@
+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/is-relationship.d.ts

@@ -1,4 +1,4 @@
-import type { Relationship } from '../relationship/build-relation-line';
+import type { Relationship } from '../relationship/build-relation-line.js';
 /**
  * isRelationship
  * @param { string } key

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

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

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

@@ -1,12 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseRelationLine = parseRelationLine;
 /**
  * Parse a relation line
  * @param line - The line to parse
  * @returns The parsed relation
  */
-function parseRelationLine(line) {
+export function parseRelationLine(line) {
     // @relation <fromModel>.<fromField> <toModel>.<toField> <relationType>
     const relationMatch = line.match(/@relation\s+(\w+)\.(\w+)\s+(\w+)\.(\w+)\s+(\w+-to-\w+)/);
     if (relationMatch) {