sizuku 0.0.7 → 0.2.0

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

@@ -1,8 +1,2 @@
-import type { TableInfo } from '../type';
-/**
- * Parse table info from code
- * @function parseTableInfo
- * @param code - The code to parse the table info from
- * @returns The parsed table info
- */
+import type { TableInfo } from '../types.js';
 export declare function parseTableInfo(code: string[]): TableInfo[];

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

@@ -1,91 +1,71 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseTableInfo = parseTableInfo;
-/**
- * Parse table info from code
- * @function parseTableInfo
- * @param code - The code to parse the table info from
- * @returns The parsed table info
- */
-function parseTableInfo(code) {
-    const initialAccumulator = {
-        tables: [],
-        currentTable: null,
-        currentDescription: '',
-        tempFields: [],
-        currentTableStartLine: 0,
-    };
-    const result = code.reduce((acc, line, index) => {
-        // extract description
-        const descriptionMatch = line.match(/\/\/\/\s*([^@].*)/);
-        if (descriptionMatch &&
-            !(line.includes('@z.') || line.includes('@v.')) &&
-            !line.includes('@relation')) {
-            acc.currentDescription = descriptionMatch[1]?.trim() ?? null;
-            return acc;
-        }
-        // extract table name
-        const tableMatch = line.match(/export const (\w+)\s*=\s*mysqlTable/);
-        if (tableMatch) {
-            if (acc.currentTable && acc.tempFields.length > 0) {
-                acc.currentTable.fields = acc.tempFields.map((field) => ({
-                    name: field.name,
-                    type: field.type,
-                    description: field.description,
-                }));
-                acc.tables.push(acc.currentTable);
-            }
-            acc.currentTable = {
-                name: tableMatch[1],
-                fields: [],
+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(),
             };
-            acc.tempFields = [];
-            acc.currentTableStartLine = index;
-            return acc;
-        }
-        // field info extraction
-        if (!acc.currentTable) {
-            return acc;
-        }
-        const fieldMatch = line.match(/^\s*([^:]+):\s*([^(]+)\(/);
-        if (fieldMatch) {
-            const [_, fieldName, fieldType] = fieldMatch;
-            const description = line.includes('.primaryKey()')
-                ? `(PK) ${acc.currentDescription || ''}`
-                : acc.currentDescription || '';
-            acc.tempFields.push({
-                name: fieldName.trim(),
-                type: fieldType.trim(),
-                description,
-                line: index,
-            });
-            acc.currentDescription = '';
-            return acc;
-        }
-        // detect foreign key constraint
-        if (line.includes('.references') || line.includes('relations')) {
-            const lastIndex = acc.tempFields.length - 1;
-            if (lastIndex >= 0) {
-                const lastField = acc.tempFields[lastIndex];
-                acc.tempFields[lastIndex] = {
-                    name: lastField.name,
-                    type: lastField.type,
-                    description: `(FK) ${lastField.description}`,
-                    line: lastField.line,
-                };
-            }
-            return acc;
-        }
-        return acc;
-    }, initialAccumulator);
-    // process fields of the last table
-    if (result.currentTable && result.tempFields.length > 0) {
-        result.currentTable.fields = result.tempFields.map((field) => ({
-            name: field.name,
-            type: field.type,
-            description: field.description,
-        }));
-        result.tables.push(result.currentTable);
-    }
-    return result.tables;
+        })
+            .filter(isFieldInfo);
+        return [{ name: varName, fields }];
+    });
 }

package/dist/generator/mermaid-er/validator/remove-duplicate-relations.js

@@ -1,12 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.removeDuplicateRelations = removeDuplicateRelations;
 /**
  * Remove duplicate relations
  * @function removeDuplicateRelations
  * @param relations - The relations to remove duplicates from
  * @returns The relations without duplicates
  */
-function removeDuplicateRelations(relations) {
+export function removeDuplicateRelations(relations) {
     return [...new Set(relations)];
 }

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

@@ -1,7 +1,7 @@
-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.
  *
  * @returns The configuration object.
  */
-export declare function getConfig(): Config;
+export declare function getConfig(): Config

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

@@ -1,19 +1,13 @@
-"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.
  *
  * @returns The configuration object.
  */
-function getConfig() {
-    const config = node_fs_1.default.existsSync('sizuku-valibot.json')
-        ? { ...config_1.DEFAULT_CONFIG, ...JSON.parse(node_fs_1.default.readFileSync('sizuku-valibot.json', 'utf-8')) }
-        : config_1.DEFAULT_CONFIG;
+export function getConfig() {
+    const config = fs.existsSync('sizuku-valibot.json')
+        ? { ...DEFAULT_CONFIG, ...JSON.parse(fs.readFileSync('sizuku-valibot.json', 'utf-8')) }
+        : DEFAULT_CONFIG;
     return config;
 }

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

@@ -1,8 +1,5 @@
-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
+ * Public API: extract schemas from code lines
  */
 export declare function extractSchemas(lines: string[]): Schema[];

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

@@ -1,92 +1,173 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractSchemas = extractSchemas;
+import { Node, Project } from 'ts-morph';
 /**
- * Check if line contains metadata
+ * Check if the comment line is metadata (Zod / Valibot / relation helper)
  */
-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.');
 };
 /**
- * Extract schemas from lines of code
- * @function extractSchemas
- * @param lines - Lines of code
- * @returns Schemas
+ * Collect consecutive `///` comment lines that appear immediately above a field.
  */
-function extractSchemas(lines) {
-    const process = (i, acc) => {
-        if (i >= lines.length) {
+const extractFieldComments = (sourceText, fieldStartPos) => {
+    const beforeField = sourceText.substring(0, fieldStartPos);
+    const lines = beforeField.split('\n');
+    return lines
+        .map((line) => line.trim())
+        .reverse()
+        .reduce((acc, line) => {
+        if (acc.stop)
             return acc;
+        if (line.startsWith('///')) {
+            return { commentLines: [line, ...acc.commentLines], stop: false };
         }
-        const line = lines[i];
-        // extract schema name
-        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);
-        }
-        // handle comment line
-        if (line.trim().startsWith('///')) {
-            // detect valibot comment
-            const valibotComment = line.match(/\/\/\/\s*@(v\.[^\n]+)/);
-            if (valibotComment && acc.currentSchema) {
-                // find next field definition line
-                const remainingCandidates = lines.slice(i + 1);
-                const foundRelative = remainingCandidates.findIndex((candidate) => {
-                    const trimmed = candidate.trim();
-                    return trimmed !== '' && !trimmed.startsWith('///');
-                });
-                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: valibotComment[1],
-                            description: acc.pendingDescription,
-                        };
-                        acc.currentSchema.fields.push(newField);
-                        acc.pendingDescription = undefined;
-                        return process(i + 1, acc);
-                    }
-                }
-            }
-            else {
-                // ignore comment line except metadata
-                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 field definition is found in non-comment line, use 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);
+        if (line === '')
+            return acc;
+        return { commentLines: acc.commentLines, stop: true };
+    }, { commentLines: [], stop: false }).commentLines;
+};
+/**
+ * Parse the collected comment lines -> { valibotDefinition, description }
+ */
+const parseFieldComments = (commentLines) => {
+    const cleaned = commentLines.map((l) => l.replace(/^\/\/\/\s*/, '').trim()).filter(Boolean);
+    const valibotDefinition = cleaned.find((l) => l.startsWith('@v.'))?.replace(/^@/, '') ?? '';
+    const descriptionLines = cleaned.filter((l) => !isMetadataComment(l));
+    const description = descriptionLines.length ? descriptionLines.join(' ') : undefined;
+    return { valibotDefinition, description };
+};
+/**
+ * Convert table name to Schema name (e.g. `user` -> `UserSchema`)
+ */
+const toSchemaName = (table) => `${table.charAt(0).toUpperCase() + table.slice(1)}Schema`;
+/**
+ * Extract an ordinary column field.
+ */
+const extractFieldFromProperty = (property, sourceText) => {
+    if (!Node.isPropertyAssignment(property))
+        return null;
+    const name = property.getName();
+    if (!name)
+        return null;
+    const commentLines = extractFieldComments(sourceText, property.getStart());
+    const { valibotDefinition, description } = parseFieldComments(commentLines);
+    return { name, definition: valibotDefinition, description };
+};
+/**
+ * Extract a relation field (many / one) and infer Valibot schema.
+ */
+const extractRelationFieldFromProperty = (property, sourceText) => {
+    if (!Node.isPropertyAssignment(property))
+        return null;
+    const name = property.getName();
+    if (!name)
+        return null;
+    const init = property.getInitializer();
+    if (!Node.isCallExpression(init))
+        return { name, definition: '', description: undefined };
+    const expr = init.getExpression();
+    if (!Node.isIdentifier(expr))
+        return { name, definition: '', description: undefined };
+    const fnName = expr.getText();
+    const args = init.getArguments();
+    if (!(args.length && Node.isIdentifier(args[0])))
+        return { name, definition: '', description: undefined };
+    const refTable = args[0].getText();
+    const schemaName = toSchemaName(refTable);
+    const definition = fnName === 'many' ? `v.array(${schemaName})` : fnName === 'one' ? schemaName : '';
+    const commentLines = extractFieldComments(sourceText, property.getStart());
+    const { description } = parseFieldComments(commentLines);
+    return { name, definition, description };
+};
+/** Utility: unwrap arrow / paren / etc. until ObjectLiteralExpression or null */
+const extractObjectLiteralFromExpression = (expr) => {
+    if (Node.isObjectLiteralExpression(expr))
+        return expr;
+    if (Node.isParenthesizedExpression(expr))
+        return extractObjectLiteralFromExpression(expr.getExpression());
+    if (Node.isArrowFunction(expr)) {
+        const body = expr.getBody();
+        if (Node.isObjectLiteralExpression(body))
+            return body;
+        if (Node.isParenthesizedExpression(body))
+            return extractObjectLiteralFromExpression(body.getExpression());
+        if (Node.isBlock(body)) {
+            const ret = body.getStatements().find(Node.isReturnStatement);
+            if (ret && Node.isReturnStatement(ret)) {
+                const re = ret.getExpression();
+                return re && Node.isObjectLiteralExpression(re) ? re : null;
             }
         }
-        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;
+};
+/** find the first object literal among call expression arguments */
+const findObjectLiteralInArgs = (call) => {
+    for (const arg of call.getArguments()) {
+        const obj = extractObjectLiteralFromExpression(arg);
+        if (obj)
+            return obj;
+    }
+    return null;
+};
+/** recognise `relations()` / `somethingRelation*` helpers */
+const isRelationFunction = (call) => {
+    const expr = call.getExpression();
+    return (Node.isIdentifier(expr) &&
+        (expr.getText() === 'relations' || expr.getText().includes('relation')));
+};
+/** extract fields from mysqlTable / relations call expression */
+const extractFieldsFromCallExpression = (call, sourceText) => {
+    const obj = findObjectLiteralInArgs(call);
+    if (!obj)
+        return [];
+    const relation = isRelationFunction(call);
+    return obj
+        .getProperties()
+        .map((p) => relation
+        ? extractRelationFieldFromProperty(p, sourceText)
+        : extractFieldFromProperty(p, sourceText))
+        .filter((f) => f !== null);
+};
+/** extract a single schema from variable declaration */
+const extractSchemaFromDeclaration = (decl, sourceText) => {
+    if (!Node.isVariableDeclaration(decl))
+        return null;
+    const name = decl.getName();
+    if (!name)
+        return null;
+    const init = decl.getInitializer();
+    // Handle call expressions (mysqlTable, relations, etc.)
+    if (Node.isCallExpression(init)) {
+        // ⛔ Skip relation helper exports (userRelations / postRelations ...)
+        if (isRelationFunction(init))
+            return null;
+        const fields = extractFieldsFromCallExpression(init, sourceText);
+        return { name, fields };
+    }
+    // Direct object literal export
+    if (Node.isObjectLiteralExpression(init)) {
+        const fields = init
+            .getProperties()
+            .map((p) => extractFieldFromProperty(p, sourceText))
+            .filter((f) => f !== null);
+        return { name, fields };
+    }
+    return { name, fields: [] };
+};
+/**
+ * Public API: extract schemas from code lines
+ */
+export function extractSchemas(lines) {
+    const project = new Project({
+        useInMemoryFileSystem: true,
+        compilerOptions: { allowJs: true, skipLibCheck: true },
+    });
+    const file = project.createSourceFile('temp.ts', lines.join('\n'));
+    const fullText = file.getFullText();
+    return file
+        .getVariableStatements()
+        .filter((s) => s.hasExportKeyword())
+        .flatMap((s) => s.getDeclarations())
+        .map((d) => extractSchemaFromDeclaration(d, fullText))
+        .filter((s) => s !== null);
 }

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;

package/dist/generator/valibot/core.js

@@ -0,0 +1,39 @@
+// 完全純粋なValibotスキーマ生成ユーティリティ - 外部import禁止
+import { toPascalCase } from '../../shared/utils/string-utils.js';
+export const generateValibotSchema = (table) => {
+    const schemaName = `${toPascalCase(table.name)}Schema`;
+    const typeName = toPascalCase(table.name);
+    const properties = table.columns.map(column => generateValibotProperty(column)).join('\n  ');
+    return `export const ${schemaName} = v.object({
+  ${properties}
+})
+export type ${typeName} = v.InferInput<typeof ${schemaName}>`;
+};
+export const generateValibotProperty = (column) => {
+    const comment = column.comment ? `/** ${column.comment} */\n  ` : '';
+    const schema = column.valibotSchema || generateDefaultValibotSchema(column);
+    return `${comment}${column.name}: ${schema},`;
+};
+export const generateDefaultValibotSchema = (column) => {
+    if (column.type === 'varchar') {
+        if (column.length === 36) {
+            return 'v.pipe(v.string(), v.uuid())';
+        }
+        if (column.length) {
+            return `v.pipe(v.string(), v.maxLength(${column.length}))`;
+        }
+        return 'v.string()';
+    }
+    if (column.type === 'int') {
+        return 'v.pipe(v.number(), v.integer())';
+    }
+    if (column.type === 'text') {
+        return 'v.string()';
+    }
+    return 'v.unknown()';
+};
+export const generateValibotFile = (tables) => {
+    const imports = 'import * as v from \'valibot\'\n\n';
+    const schemas = tables.map(table => generateValibotSchema(table)).join('\n\n');
+    return imports + schemas;
+};

package/dist/generator/valibot/generator/infer-input.d.ts

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

package/dist/generator/valibot/generator/infer-input.js

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

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

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

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

@@ -0,0 +1,19 @@
+import { capitalize, inferInput } from '../../../utils/index.js';
+/**
+ * Generates Valibot relation schema code from a relation schema AST extraction.
+ */
+export function relationValibotCode(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)} = v.${objectType}({...${baseSchema}.entries,${fields}})`;
+    if (withType)
+        return `${obj}\n\n${inferInput(schema.name)}\n`;
+    return `${obj}`;
+}

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

@@ -0,0 +1,15 @@
+/**
+ * @param schema
+ * @param comment
+ * @param type
+ * @returns
+ */
+export declare function valibotCode(schema: {
+    name: string;
+    fields: {
+        name: string;
+        definition: string;
+        description?: string;
+    }[];
+    objectType?: 'strict' | 'loose';
+}, comment: boolean, type: boolean): string;

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

@@ -0,0 +1,16 @@
+import { inferInput } from '../../../utils/index.js';
+import { valibot } from './valibot.js';
+/**
+ * @param schema
+ * @param comment
+ * @param type
+ * @returns
+ */
+export function valibotCode(schema, comment, type) {
+    const valibotSchema = valibot(schema, comment);
+    if (type) {
+        const valibotInfer = inferInput(schema.name);
+        return `${valibotSchema}\n\n${valibotInfer}\n`;
+    }
+    return `${valibotSchema}\n`;
+}

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

@@ -0,0 +1,14 @@
+/**
+ * @param schema
+ * @param config
+ * @returns
+ */
+export declare function valibot(schema: {
+    name: string;
+    fields: {
+        name: string;
+        definition: string;
+        description?: string;
+    }[];
+    objectType?: 'strict' | 'loose';
+}, comment: boolean): string;