sizuku 0.0.6 → 0.1.0

package/dist/generator/zod/core/extract-schema.js

@@ -1,96 +1,243 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractSchemas = extractSchemas;
+import { Node, Project } from 'ts-morph';
 /**
- * Check if line contains metadata
+ * Check if comment contains metadata
  */
-const isMetadataComment = (line) => {
-    return line.includes('@z.') || line.includes('@v.') || line.includes('@relation.');
+const isMetadataComment = (text) => {
+    return text.includes('@z.') || text.includes('@v.') || text.includes('@relation.');
 };
 /**
- * Check if line is a non-comment line
+ * Extract field comments that appear before a specific line position
  */
-const isNonCommentLine = (line) => {
-    const trimmed = line.trim();
-    return trimmed !== '' && !trimmed.startsWith('///');
+const extractFieldComments = (sourceText, fieldStartPos) => {
+    const beforeField = sourceText.substring(0, fieldStartPos);
+    const lines = beforeField.split('\n');
+    const reverseIndex = lines
+        .map((line, index) => ({ line: line.trim(), index }))
+        .reverse()
+        .reduce((acc, { line }) => {
+        if (acc.shouldStop)
+            return acc;
+        if (line.startsWith('///')) {
+            return {
+                commentLines: [line, ...acc.commentLines],
+                shouldStop: false,
+            };
+        }
+        if (line === '') {
+            return acc;
+        }
+        return { commentLines: acc.commentLines, shouldStop: true };
+    }, { commentLines: [], shouldStop: false });
+    return reverseIndex.commentLines;
 };
 /**
- * Extract schemas from lines of code
- * @function extractSchemas
- * @param lines - Lines of code
- * @returns Schemas
+ * Parse comment lines and extract Zod definition and description
  */
-function extractSchemas(lines) {
-    const process = (i, acc) => {
-        if (i >= lines.length) {
-            return acc;
+const parseFieldComments = (commentLines) => {
+    const cleanLines = commentLines
+        .map((line) => line.replace(/^\/\/\/\s*/, '').trim())
+        .filter((line) => line.length > 0);
+    const zodDefinition = cleanLines.find((line) => line.startsWith('@z.'))?.replace(/^@/, '') ?? '';
+    const descriptionLines = cleanLines.filter((line) => !isMetadataComment(line));
+    const description = descriptionLines.length > 0 ? descriptionLines.join(' ') : undefined;
+    return { zodDefinition, description };
+};
+/**
+ * Extract field information from object property
+ */
+const extractFieldFromProperty = (property, sourceText) => {
+    if (!Node.isPropertyAssignment(property))
+        return null;
+    const fieldName = property.getName();
+    if (!fieldName)
+        return null;
+    const fieldStartPos = property.getStart();
+    const commentLines = extractFieldComments(sourceText, fieldStartPos);
+    const { zodDefinition, description } = parseFieldComments(commentLines);
+    return {
+        name: fieldName,
+        definition: zodDefinition,
+        description,
+    };
+};
+/**
+ * Convert table name to Schema name (e.g., 'user' -> 'UserSchema', 'post' -> 'PostSchema')
+ */
+const toSchemaName = (tableName) => `${tableName.charAt(0).toUpperCase() + tableName.slice(1)}Schema`;
+/**
+ * Extract relation field with type inference
+ */
+const extractRelationFieldFromProperty = (property, sourceText) => {
+    if (!Node.isPropertyAssignment(property))
+        return null;
+    const fieldName = property.getName();
+    if (!fieldName)
+        return null;
+    const initializer = property.getInitializer();
+    if (!Node.isCallExpression(initializer)) {
+        return {
+            name: fieldName,
+            definition: '',
+            description: undefined,
+        };
+    }
+    const expression = initializer.getExpression();
+    if (!Node.isIdentifier(expression)) {
+        return {
+            name: fieldName,
+            definition: '',
+            description: undefined,
+        };
+    }
+    const functionName = expression.getText();
+    const args = initializer.getArguments();
+    if (args.length === 0) {
+        return {
+            name: fieldName,
+            definition: '',
+            description: undefined,
+        };
+    }
+    const firstArg = args[0];
+    if (!Node.isIdentifier(firstArg)) {
+        return {
+            name: fieldName,
+            definition: '',
+            description: undefined,
+        };
+    }
+    const referencedTable = firstArg.getText();
+    const schemaName = toSchemaName(referencedTable);
+    const zodDefinition = functionName === 'many'
+        ? `z.array(${schemaName})` // many(post) -> z.array(PostSchema)
+        : functionName === 'one'
+            ? schemaName // one(user, {...}) -> UserSchema
+            : '';
+    const fieldStartPos = property.getStart();
+    const commentLines = extractFieldComments(sourceText, fieldStartPos);
+    const { description } = parseFieldComments(commentLines);
+    return {
+        name: fieldName,
+        definition: zodDefinition,
+        description,
+    };
+};
+/**
+ * Extract object literal from any expression
+ */
+const extractObjectLiteralFromExpression = (expression) => {
+    // Direct object literal
+    if (Node.isObjectLiteralExpression(expression)) {
+        return expression;
+    }
+    if (Node.isParenthesizedExpression(expression)) {
+        const inner = expression.getExpression();
+        return Node.isObjectLiteralExpression(inner) ? inner : null;
+    }
+    if (Node.isArrowFunction(expression)) {
+        const body = expression.getBody();
+        if (Node.isObjectLiteralExpression(body)) {
+            return body;
         }
-        const line = lines[i];
-        // extract schema
-        const schemaMatch = line.match(/export const (\w+)\s*=/);
-        if (schemaMatch) {
-            if (acc.currentSchema) {
-                acc.schemas.push(acc.currentSchema);
-            }
-            acc.currentSchema = { name: schemaMatch[1], fields: [] };
-            acc.pendingDescription = undefined;
-            return process(i + 1, acc);
+        if (Node.isParenthesizedExpression(body)) {
+            const inner = body.getExpression();
+            return Node.isObjectLiteralExpression(inner) ? inner : null;
         }
-        // process comment
-        if (line.trim().startsWith('///')) {
-            // zod comment
-            const zodComment = line.match(/\/\/\/\s*(@z\.(?:[^()]+|\([^)]*\))+)/);
-            if (zodComment && acc.currentSchema) {
-                // find next field definition line
-                const remainingCandidates = lines.slice(i + 1);
-                const foundRelative = remainingCandidates.findIndex(isNonCommentLine);
-                if (foundRelative !== -1) {
-                    const j = i + 1 + foundRelative;
-                    const candidate = lines[j].trim();
-                    const fieldMatch = candidate.match(/^(\w+)\s*:/);
-                    if (fieldMatch) {
-                        const newField = {
-                            name: fieldMatch[1],
-                            definition: zodComment[1].replace('@', ''),
-                            description: acc.pendingDescription,
-                        };
-                        acc.currentSchema.fields.push(newField);
-                        acc.pendingDescription = undefined;
-                        return process(i + 1, acc);
-                    }
-                }
+        if (Node.isBlock(body)) {
+            const returnStatement = body.getStatements().find((stmt) => Node.isReturnStatement(stmt));
+            if (returnStatement && Node.isReturnStatement(returnStatement)) {
+                const returnExpression = returnStatement.getExpression();
+                return returnExpression && Node.isObjectLiteralExpression(returnExpression)
+                    ? returnExpression
+                    : null;
             }
-            else {
-                // comments other than metadata are pending
-                if (!isMetadataComment(line)) {
-                    const commentText = line.replace('///', '').trim();
-                    acc.pendingDescription = acc.pendingDescription
-                        ? `${acc.pendingDescription} ${commentText}`
-                        : commentText;
-                    return process(i + 1, acc);
-                }
-            }
-            return process(i + 1, acc);
         }
-        // if there is a field definition other than comment, use the pending comment as field information
-        if (acc.currentSchema && acc.pendingDescription) {
-            const fieldMatch = line.match(/^(\w+)\s*:/);
-            if (fieldMatch) {
-                const newField = {
-                    name: fieldMatch[1],
-                    definition: '',
-                    description: acc.pendingDescription,
-                };
-                acc.currentSchema.fields.push(newField);
-                acc.pendingDescription = undefined;
-                return process(i + 1, acc);
-            }
+    }
+    return null;
+};
+/**
+ * Find object literal in call expression arguments
+ */
+const findObjectLiteralInArgs = (callExpr) => {
+    const args = callExpr.getArguments();
+    for (const arg of args) {
+        const objectLiteral = extractObjectLiteralFromExpression(arg);
+        if (objectLiteral) {
+            return objectLiteral;
         }
-        return process(i + 1, acc);
-    };
-    const finalAcc = process(0, { currentSchema: null, pendingDescription: undefined, schemas: [] });
-    if (finalAcc.currentSchema) {
-        finalAcc.schemas.push(finalAcc.currentSchema);
     }
-    return finalAcc.schemas;
+    return null;
+};
+/**
+ * Determine if this is a relation-like function call
+ */
+const isRelationFunction = (callExpr) => {
+    const expression = callExpr.getExpression();
+    if (!Node.isIdentifier(expression))
+        return false;
+    const functionName = expression.getText();
+    return functionName === 'relations' || functionName.includes('relation');
+};
+/**
+ * Extract fields from any call expression
+ */
+const extractFieldsFromCallExpression = (callExpr, sourceText) => {
+    const objectLiteral = findObjectLiteralInArgs(callExpr);
+    if (!objectLiteral)
+        return [];
+    const isRelation = isRelationFunction(callExpr);
+    return objectLiteral
+        .getProperties()
+        .map((prop) => isRelation
+        ? extractRelationFieldFromProperty(prop, sourceText)
+        : extractFieldFromProperty(prop, sourceText))
+        .filter((field) => field !== null);
+};
+/**
+ * Extract a single schema (variable declaration)
+ */
+const extractSchemaFromDeclaration = (declaration, sourceText) => {
+    if (!Node.isVariableDeclaration(declaration))
+        return null;
+    const name = declaration.getName();
+    if (!name)
+        return null;
+    const initializer = declaration.getInitializer();
+    if (Node.isCallExpression(initializer)) {
+        if (isRelationFunction(initializer))
+            return null;
+        const fields = extractFieldsFromCallExpression(initializer, sourceText);
+        return { name, fields };
+    }
+    if (Node.isObjectLiteralExpression(initializer)) {
+        const fields = initializer
+            .getProperties()
+            .map((prop) => extractFieldFromProperty(prop, sourceText))
+            .filter((field) => field !== null);
+        return { name, fields };
+    }
+    return { name, fields: [] };
+};
+/**
+ * Extract schemas from lines of code
+ * @param lines - Lines of code
+ * @returns Schemas
+ */
+export function extractSchemas(lines) {
+    const sourceCode = lines.join('\n');
+    const project = new Project({
+        useInMemoryFileSystem: true,
+        compilerOptions: {
+            allowJs: true,
+            skipLibCheck: true,
+        },
+    });
+    const sourceFile = project.createSourceFile('temp.ts', sourceCode);
+    const sourceText = sourceFile.getFullText();
+    return sourceFile
+        .getVariableStatements()
+        .filter((stmt) => stmt.hasExportKeyword())
+        .flatMap((stmt) => stmt.getDeclarations())
+        .map((decl) => extractSchemaFromDeclaration(decl, sourceText))
+        .filter((schema) => schema !== null);
 }

package/dist/generator/zod/generator/infer.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @param name
+ * @returns
+ */
+export declare function infer(name: string): string;

package/dist/generator/zod/generator/infer.js

@@ -0,0 +1,8 @@
+import { capitalize } from '../../../shared/utils/capitalize.js';
+/**
+ * @param name
+ * @returns
+ */
+export function infer(name) {
+    return `export type ${capitalize(name)} = z.infer<typeof ${capitalize(name)}Schema>`;
+}

package/dist/generator/zod/generator/{generate-zod-code.d.ts → zod-code.d.ts}

@@ -1,5 +1,4 @@
-import type { Schema } from '../../../common/type';
-import type { Config } from '../../../common/config';
+import type { Schema } from '../../../shared/types.js';
 /**
  * Generates Zod code for a given schema and config.
  *
@@ -8,4 +7,4 @@ import type { Config } from '../../../common/config';
  * @param config - The configuration for the code generation.
  * @returns The generated Zod code.
  */
-export declare function generateZodCode(schema: Schema, config: Config): string;
+export declare function zodCode(schema: Schema, comment: boolean, type: boolean): string;

package/dist/generator/zod/generator/zod-code.js

@@ -0,0 +1,18 @@
+import { infer } from './infer.js';
+import { zod } from './zod.js';
+/**
+ * Generates Zod code for a given schema and config.
+ *
+ * @function generateZodCode
+ * @param schema - The schema to generate code for.
+ * @param config - The configuration for the code generation.
+ * @returns The generated Zod code.
+ */
+export function zodCode(schema, comment, type) {
+    const zodSchema = zod(schema, comment);
+    if (type) {
+        const zInfer = infer(schema.name);
+        return `${zodSchema}\n\n${zInfer}\n`;
+    }
+    return `${zodSchema}\n`;
+}

package/dist/generator/zod/generator/{generate-zod-schema.d.ts → zod.d.ts}

@@ -1,11 +1,9 @@
-import type { Schema } from '../../../common/type';
-import type { Config } from '../../../common/config';
+import type { Schema } from '../../../shared/types.js';
 /**
  * Generates a Zod schema for a given schema and config.
  *
- * @function generateZodSchema
  * @param schema - The schema to generate code for.
  * @param config - The configuration for the code generation.
  * @returns The generated Zod schema.
  */
-export declare function generateZodSchema(schema: Schema, config: Config): string;
+export declare function zod(schema: Schema, comment: boolean): string;

package/dist/generator/zod/generator/zod.js

@@ -0,0 +1,12 @@
+import { fieldDefinitions } from '../../../shared/generator/field-definitions.js';
+import { capitalize } from '../../../shared/utils/capitalize.js';
+/**
+ * Generates a Zod schema for a given schema and config.
+ *
+ * @param schema - The schema to generate code for.
+ * @param config - The configuration for the code generation.
+ * @returns The generated Zod schema.
+ */
+export function zod(schema, comment) {
+    return `export const ${capitalize(schema.name)}Schema = z.object({${fieldDefinitions(schema, comment)}})`;
+}

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

@@ -1,3 +1,10 @@
-#!/usr/bin/env node
-import type { Config } from '../../common/config';
-export declare function main(dev?: boolean, config?: Config): Promise<boolean>;
+import type { Result } from 'neverthrow';
+/**
+ * Generate Zod schema
+ * @param code - The code to generate Zod schema from
+ * @param output - The output file path
+ * @param comment - Whether to include comments in the generated code
+ * @param type - Whether to include type information in the generated code
+ * @param zod - The Zod version to use
+ */
+export declare function sizukuZod(code: string[], output: `${string}.ts`, comment?: boolean, type?: boolean, zod?: 'v4' | 'v4-mini' | '@hono/zod-openapi'): Promise<Result<void, Error>>;

package/dist/generator/zod/index.js

@@ -1,77 +1,30 @@
-#!/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.main = main;
-const node_fs_1 = require("node:fs");
-const node_path_1 = __importDefault(require("node:path"));
-const extract_schema_1 = require("./core/extract-schema");
-const generate_zod_code_1 = require("./generator/generate-zod-code");
-const format_1 = require("../../common/format");
-const config_1 = require("./config");
-const node_process_1 = require("node:process");
-const IMPORT_ZOD = 'import { z } from "zod"';
-async function main(dev = false, config = (0, config_1.getConfig)()) {
-    // 1. argv ['**/bin/node', ''/workspaces/sizuku-test/packages/sizuku/dist/generator/zod/index.js',', 'db/schema.ts', '-o', 'zod/index.ts']
-    if (config.output === undefined && !node_process_1.argv.includes('-o')) {
-        console.error('Error: -o is not found');
-        return false;
-    }
-    // 2. slice ['db/schema.ts', '-o', 'zod/index.ts']
-    const args = process.argv.slice(2);
-    // 3. input = args[0] = 'db/schema.ts'
-    const input = config.input ?? args[0];
-    config.input = input;
-    // 4. output = 'zod/index.ts'
-    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. extract schemas
-        const schemas = (0, extract_schema_1.extractSchemas)(lines.slice(codeStart));
-        // 10. generate zod code
-        const generatedCode = [
-            IMPORT_ZOD,
-            '',
-            ...schemas.map((schema) => (0, generate_zod_code_1.generateZodCode)(schema, config)),
-        ].join('\n');
-        // 11. format code
-        const code = await (0, format_1.formatCode)(generatedCode);
-        // 12. write to output file
-        (0, node_fs_1.writeFileSync)(output, code);
-        console.log(`Generated Zod schema at: ${output}`);
-        return true;
-    }
-    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);
-        }
-    });
+import path from 'node:path';
+import { extractSchemas } from './core/extract-schema.js';
+import { zodCode } from './generator/zod-code.js';
+import { mkdir, writeFile } from '../../shared/fsp/index.js';
+import { fmt } from '../../shared/format/index.js';
+const ZODV4_IMPORT = `import { z } from 'zod/v4'`;
+const ZODV4_MINI_IMPORT = `import { z } from 'zod/v4-mini'`;
+const ZOD_OPENAPI_HONO_IMPORT = `import { z } from '@hono/zod-openapi'`;
+/**
+ * Generate Zod schema
+ * @param code - The code to generate Zod schema from
+ * @param output - The output file path
+ * @param comment - Whether to include comments in the generated code
+ * @param type - Whether to include type information in the generated code
+ * @param zod - The Zod version to use
+ */
+export async function sizukuZod(code, output, comment, type, zod) {
+    const zodGeneratedCode = [
+        zod === 'v4-mini'
+            ? ZODV4_MINI_IMPORT
+            : zod === '@hono/zod-openapi'
+                ? ZOD_OPENAPI_HONO_IMPORT
+                : ZODV4_IMPORT,
+        '',
+        ...extractSchemas(code).map((schema) => zodCode(schema, comment ?? false, type ?? false)),
+    ].join('\n');
+    return await mkdir(path.dirname(output))
+        .andThen(() => fmt(zodGeneratedCode))
+        .andThen((formatted) => writeFile(output, formatted));
 }

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import type { Config } from './config/index.js';
+import type { Result } from 'neverthrow';
+export declare function main(config?: Config): Promise<Result<void, Error>>;

package/dist/index.js

@@ -0,0 +1,54 @@
+import { getConfig } from './config/index.js';
+import { sizukuZod } from './generator/zod/index.js';
+import { sizukuValibot } from './generator/valibot/index.js';
+import { sizukuMermaidER } from './generator/mermaid-er/index.js';
+import { readFileSync } from './shared/fs/index.js';
+import { ok, err, ResultAsync } from 'neverthrow';
+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/shared/config/index.d.ts

@@ -0,0 +1,13 @@
+export type Config = {
+  schema: {
+    name: 'PascalCase' | 'camelCase'
+  }
+  type: {
+    name: 'PascalCase' | 'camelCase'
+    export: boolean
+  }
+  input?: string
+  output?: string
+  comment?: boolean
+}
+export declare const DEFAULT_CONFIG: Config

package/dist/{common → shared}/config/index.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_CONFIG = void 0;
-exports.DEFAULT_CONFIG = {
+export const DEFAULT_CONFIG = {
     schema: {
         name: 'PascalCase',
     },

package/dist/shared/format/index.d.ts

@@ -0,0 +1,2 @@
+import { ResultAsync } from 'neverthrow';
+export declare function fmt(code: string): ResultAsync<string, Error>;

package/dist/shared/format/index.js

@@ -0,0 +1,10 @@
+import { format } from 'prettier';
+import { ResultAsync } from 'neverthrow';
+export function fmt(code) {
+    return ResultAsync.fromPromise(format(code, {
+        parser: 'typescript',
+        printWidth: 100,
+        singleQuote: true,
+        semi: false,
+    }), (e) => new Error(String(e)));
+}

package/dist/shared/fs/index.d.ts

@@ -0,0 +1,2 @@
+import type { Result } from 'neverthrow';
+export declare function readFileSync(path: string): Result<string, Error>;

package/dist/shared/fs/index.js

@@ -0,0 +1,10 @@
+import fs from 'node:fs';
+import { ok, err } from 'neverthrow';
+export function readFileSync(path) {
+    try {
+        return ok(fs.readFileSync(path, 'utf-8'));
+    }
+    catch (e) {
+        return err(new Error(String(e)));
+    }
+}

package/dist/shared/fsp/index.d.ts

@@ -0,0 +1,3 @@
+import { ResultAsync } from 'neverthrow';
+export declare function mkdir(path: string): ResultAsync<string | undefined, Error>;
+export declare function writeFile(path: string, data: string): ResultAsync<void, Error>;

package/dist/shared/fsp/index.js

@@ -0,0 +1,8 @@
+import fsp from 'node:fs/promises';
+import { ResultAsync } from 'neverthrow';
+export function mkdir(path) {
+    return ResultAsync.fromPromise(fsp.mkdir(path, { recursive: true }), (e) => new Error(String(e)));
+}
+export function writeFile(path, data) {
+    return ResultAsync.fromPromise(fsp.writeFile(path, data), (e) => new Error(String(e)));
+}