sizuku 0.3.2 → 0.4.0

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

@@ -1,19 +0,0 @@
-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

@@ -1,15 +0,0 @@
-/**
- * @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

@@ -1,16 +0,0 @@
-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

@@ -1,14 +0,0 @@
-/**
- * @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;

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

@@ -1,15 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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,14 +0,0 @@
-/**
- * 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, relation?: boolean): Promise<{
-    ok: true;
-    value: undefined;
-} | {
-    ok: false;
-    error: string;
-}>;

package/dist/generator/valibot/index.js

@@ -1,50 +0,0 @@
-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, relation) {
-    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)),
-        ...(relation
-            ? 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,
-        };
-    }
-    const fmtResult = await fmt(valibotGeneratedCode);
-    if (!fmtResult.ok) {
-        return {
-            ok: false,
-            error: fmtResult.error,
-        };
-    }
-    const writeFileResult = await writeFile(output, fmtResult.value);
-    if (!writeFileResult.ok) {
-        return {
-            ok: false,
-            error: writeFileResult.error,
-        };
-    }
-    return {
-        ok: true,
-        value: undefined,
-    };
-}

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

@@ -1,8 +0,0 @@
-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

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

@@ -1,14 +0,0 @@
-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.
- */
-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 +0,0 @@
-import type { Schema } from '../../../shared/types.js';
-/**
- * Extract schemas from lines of code
- * @param lines - Lines of code
- * @returns Schemas
- */
-export declare function extractSchemas(lines: string[]): Schema[];

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

@@ -1,243 +0,0 @@
-import { Node, Project } from 'ts-morph';
-/**
- * Check if comment contains metadata
- */
-const isMetadataComment = (text) => {
-    return text.includes('@z.') || text.includes('@v.') || text.includes('@relation.');
-};
-/**
- * Extract field comments that appear before a specific line position
- */
-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;
-};
-/**
- * Parse comment lines and extract Zod definition and description
- */
-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;
-        }
-        if (Node.isParenthesizedExpression(body)) {
-            const inner = body.getExpression();
-            return Node.isObjectLiteralExpression(inner) ? inner : null;
-        }
-        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;
-            }
-        }
-    }
-    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 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

@@ -1,5 +0,0 @@
-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

@@ -1,39 +0,0 @@
-// 完全純粋な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

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

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

@@ -1,8 +0,0 @@
-/**
- * @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

@@ -1,13 +0,0 @@
-/**
- * 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

@@ -1,19 +0,0 @@
-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}`;
-}

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

@@ -1,17 +0,0 @@
-/**
- * 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 declare function zodCode(schema: {
-    name: string;
-    fields: {
-        name: string;
-        definition: string;
-        description?: string;
-    }[];
-    objectType?: 'strict' | 'loose';
-}, comment: boolean, type: boolean): string;

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

@@ -1,18 +0,0 @@
-import { infer } from '../../../utils/index.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/zod.d.ts

@@ -1,16 +0,0 @@
-/**
- * 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 declare function zod(schema: {
-    name: string;
-    fields: {
-        name: string;
-        definition: string;
-        description?: string;
-    }[];
-    objectType?: 'strict' | 'loose';
-}, comment: boolean): string;

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

@@ -1,16 +0,0 @@
-import { capitalize, fieldDefinitions } from '../../../utils/index.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) {
-    const objectType = schema.objectType === 'strict'
-        ? 'strictObject'
-        : schema.objectType === 'loose'
-            ? 'looseObject'
-            : 'object';
-    return `export const ${capitalize(schema.name)}Schema = z.${objectType}({${fieldDefinitions(schema, comment)}})`;
-}

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

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

package/dist/generator/zod/generator.js

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

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

@@ -1,15 +0,0 @@
-/**
- * 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' | 'mini' | '@hono/zod-openapi', relation?: boolean): Promise<{
-    readonly ok: true;
-    readonly value: undefined;
-} | {
-    readonly ok: false;
-    readonly error: string;
-}>;