sizuku 0.0.7 → 0.2.0

package/dist/generator/valibot/generator/valibot.js

@@ -0,0 +1,15 @@
+import { capitalize, fieldDefinitions } from '../../../utils/index.js';
+/**
+ * @param schema
+ * @param config
+ * @returns
+ */
+export function valibot(schema, comment) {
+    const res = fieldDefinitions(schema, comment);
+    const objectType = schema.objectType === 'strict'
+        ? 'strictObject'
+        : schema.objectType === 'loose'
+            ? 'looseObject'
+            : 'object';
+    return `export const ${capitalize(schema.name)}Schema = v.${objectType}({${res}})`;
+}

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

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

package/dist/generator/valibot/generator.js

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

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

@@ -1,3 +1,14 @@
-#!/usr/bin/env node
-import type { Config } from '../../common/config';
-export declare function main(dev?: boolean, config?: Config): Promise<boolean>;
+/**
+ * Generate Valibot schema
+ * @param code - The code to generate Valibot 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
+ */
+export declare function sizukuValibot(code: string[], output: `${string}.ts`, comment?: boolean, type?: boolean, relations?: boolean): Promise<{
+    ok: true;
+    value: undefined;
+} | {
+    ok: false;
+    error: string;
+}>;

package/dist/generator/valibot/index.js

@@ -1,77 +1,50 @@
-#!/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 format_1 = require("../../common/format");
-const config_1 = require("./config");
-const node_process_1 = require("node:process");
-const generate_valibot_code_1 = require("./generator/generate-valibot-code");
-const IMPORT_VALIBOT = 'import * as v from "valibot"';
-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;
+import path from 'node:path';
+import { fmt } from '../../shared/format/index.js';
+import { mkdir, writeFile } from '../../shared/fsp/index.js';
+import { extractRelationSchemas, extractSchemas } from '../../shared/helper/extract-schemas.js';
+import { relationValibotCode } from './generator/relation-valibot-code.js';
+import { valibotCode } from './generator/valibot-code.js';
+/**
+ * Generate Valibot schema
+ * @param code - The code to generate Valibot 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
+ */
+export async function sizukuValibot(code, output, comment, type, relations) {
+    const baseSchemas = extractSchemas(code, 'valibot');
+    const relationSchemas = extractRelationSchemas(code, 'valibot');
+    const valibotGeneratedCode = [
+        "import * as v from 'valibot'",
+        '',
+        ...baseSchemas.map((schema) => valibotCode(schema, comment ?? false, type ?? false)),
+        ...(relations
+            ? relationSchemas.map((schema) => relationValibotCode(schema, type ?? false))
+            : []),
+    ].join('\n');
+    const mkdirResult = await mkdir(path.dirname(output));
+    if (!mkdirResult.ok) {
+        return {
+            ok: false,
+            error: mkdirResult.error,
+        };
     }
-    // 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_VALIBOT,
-            '',
-            ...schemas.map((schema) => (0, generate_valibot_code_1.generateValibotCode)(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 Valibot schema at: ${output}`);
-        return true;
+    const fmtResult = await fmt(valibotGeneratedCode);
+    if (!fmtResult.ok) {
+        return {
+            ok: false,
+            error: fmtResult.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;
+    const writeFileResult = await writeFile(output, fmtResult.value);
+    if (!writeFileResult.ok) {
+        return {
+            ok: false,
+            error: writeFileResult.error,
+        };
     }
-}
-if (require.main === module) {
-    main().then((success) => {
-        if (!success) {
-            process.exit(1);
-        }
-    });
+    return {
+        ok: true,
+        value: undefined,
+    };
 }

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

@@ -1,8 +1,8 @@
-import type { Config } from '../../../common/config';
+import type { Config } from '../../../shared/config/index.js'
 /**
  * Loads the configuration from the `sizuku.json` file or returns the default configuration.
  *
  * @function getConfig
  * @returns The configuration object.
  */
-export declare function getConfig(): Config;
+export declare function getConfig(): Config

package/dist/generator/zod/config/index.js

@@ -1,20 +1,14 @@
-"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"));
-const config_1 = require("../../../common/config");
+import fs from 'node:fs';
+import { DEFAULT_CONFIG } from '../../../shared/config/index.js';
 /**
  * Loads the configuration from the `sizuku.json` file or returns the default configuration.
  *
  * @function getConfig
  * @returns The configuration object.
  */
-function getConfig() {
-    const config = node_fs_1.default.existsSync('sizuku-zod.json')
-        ? { ...config_1.DEFAULT_CONFIG, ...JSON.parse(node_fs_1.default.readFileSync('sizuku-zod.json', 'utf-8')) }
-        : config_1.DEFAULT_CONFIG;
+export function getConfig() {
+    const config = fs.existsSync('sizuku-zod.json')
+        ? { ...DEFAULT_CONFIG, ...JSON.parse(fs.readFileSync('sizuku-zod.json', 'utf-8')) }
+        : DEFAULT_CONFIG;
     return config;
 }

package/dist/generator/zod/core/extract-schema.d.ts

@@ -1,7 +1,6 @@
-import type { Schema } from '../../../common/type';
+import type { Schema } from '../../../shared/types.js';
 /**
  * Extract schemas from lines of code
- * @function extractSchemas
  * @param lines - Lines of code
  * @returns Schemas
  */

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/core.d.ts

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

package/dist/generator/zod/core.js

@@ -0,0 +1,39 @@
+// 完全純粋なZodスキーマ生成ユーティリティ - 外部import禁止
+import { toPascalCase } from '../../shared/utils/string-utils.js';
+export const generateZodSchema = (table) => {
+    const schemaName = `${toPascalCase(table.name)}Schema`;
+    const typeName = toPascalCase(table.name);
+    const properties = table.columns.map(column => generateZodProperty(column)).join('\n  ');
+    return `export const ${schemaName} = z.object({
+  ${properties}
+})
+export type ${typeName} = z.infer<typeof ${schemaName}>`;
+};
+export const generateZodProperty = (column) => {
+    const comment = column.comment ? `/** ${column.comment} */\n  ` : '';
+    const schema = column.zodSchema || generateDefaultZodSchema(column);
+    return `${comment}${column.name}: ${schema},`;
+};
+export const generateDefaultZodSchema = (column) => {
+    if (column.type === 'varchar') {
+        if (column.length === 36) {
+            return 'z.uuid()';
+        }
+        if (column.length) {
+            return `z.string().max(${column.length})`;
+        }
+        return 'z.string()';
+    }
+    if (column.type === 'int') {
+        return 'z.number().int()';
+    }
+    if (column.type === 'text') {
+        return 'z.string()';
+    }
+    return 'z.unknown()';
+};
+export const generateZodFile = (tables) => {
+    const imports = 'import * as z from \'zod\'\n\n';
+    const schemas = tables.map(table => generateZodSchema(table)).join('\n\n');
+    return imports + schemas;
+};

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 @@
+/**
+ * @param name
+ * @returns
+ */
+export function infer(name) {
+    const capitalizedName = name.charAt(0).toUpperCase() + name.slice(1);
+    return `export type ${capitalizedName} = z.infer<typeof ${capitalizedName}Schema>`;
+}

package/dist/generator/zod/generator/relation-zod-code.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Generates Zod relation schema code from a relation schema AST extraction.
+ */
+export declare function relationZodCode(schema: {
+    name: string;
+    baseName: string;
+    fields: {
+        name: string;
+        definition: string;
+        description?: string;
+    }[];
+    objectType?: 'strict' | 'loose';
+}, withType: boolean): string;

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

@@ -0,0 +1,19 @@
+import { capitalize, infer } from '../../../utils/index.js';
+/**
+ * Generates Zod relation schema code from a relation schema AST extraction.
+ */
+export function relationZodCode(schema, withType) {
+    const base = schema.baseName;
+    const relName = `${schema.name}Schema`;
+    const baseSchema = `${capitalize(base)}Schema`;
+    const fields = schema.fields.map((f) => `${f.name}:${f.definition}`).join(',');
+    const objectType = schema.objectType === 'strict'
+        ? 'strictObject'
+        : schema.objectType === 'loose'
+            ? 'looseObject'
+            : 'object';
+    const obj = `\nexport const ${capitalize(relName)} = z.${objectType}({...${baseSchema}.shape,${fields}})`;
+    if (withType)
+        return `${obj}\n\n${infer(schema.name)}\n`;
+    return `${obj}`;
+}