sizuku 0.0.7 → 0.2.0

package/dist/shared/helper/ast-parser.js

@@ -0,0 +1,202 @@
+import { Project, SourceFile, Node, SyntaxKind, JSDocTagInfo } from 'ts-morph';
+import { Result, err, ok } from 'neverthrow';
+import { extractComment, parseZodTag, parseValibotTag, parseRelationTag, toPascalCase } from '../utils/string-utils.js';
+import { validateTableName, validateColumnName, validateRelationType } from '../utils/validation-utils.js';
+export const parseSchemaFile = (filePath) => {
+    try {
+        const project = new Project();
+        const sourceFile = project.addSourceFileAtPath(filePath);
+        const tables = [];
+        const relations = [];
+        // テーブル定義を解析
+        const tableExports = sourceFile.getExportedDeclarations();
+        for (const [name, declarations] of tableExports) {
+            if (name === 'userRelations' || name === 'postRelations')
+                continue;
+            const declaration = declarations[0];
+            if (!declaration || !Node.isVariableDeclaration(declaration))
+                continue;
+            const initializer = declaration.getInitializer();
+            if (!initializer || !Node.isCallExpression(initializer))
+                continue;
+            const callName = initializer.getExpression().getText();
+            if (!callName.includes('Table'))
+                continue;
+            const tableName = initializer.getArguments()[0]?.getText().replace(/['"]/g, '');
+            if (!tableName || !validateTableName(tableName))
+                continue;
+            const columns = parseTableColumns(initializer);
+            if (columns.isErr())
+                return err(columns.error);
+            tables.push({
+                name: tableName,
+                columns: columns.value,
+                relations: []
+            });
+        }
+        // リレーション定義を解析
+        const relationExports = sourceFile.getExportedDeclarations();
+        for (const [name, declarations] of relationExports) {
+            if (!name.includes('Relations'))
+                continue;
+            const declaration = declarations[0];
+            if (!declaration || !Node.isVariableDeclaration(declaration))
+                continue;
+            const initializer = declaration.getInitializer();
+            if (!initializer || !Node.isCallExpression(initializer))
+                continue;
+            const relation = parseRelation(initializer, tables.map(t => t.name));
+            if (relation.isOk()) {
+                relations.push(relation.value);
+            }
+        }
+        // リレーションをテーブルに割り当て
+        for (const relation of relations) {
+            const sourceTable = tables.find(t => t.name === relation.sourceTable);
+            const targetTable = tables.find(t => t.name === relation.targetTable);
+            if (sourceTable) {
+                sourceTable.relations.push(relation);
+            }
+            if (targetTable) {
+                targetTable.relations.push(relation);
+            }
+        }
+        return ok({ tables });
+    }
+    catch (error) {
+        return err(new Error(`Failed to parse schema file: ${error instanceof Error ? error.message : String(error)}`));
+    }
+};
+const parseTableColumns = (tableCall) => {
+    try {
+        const columns = [];
+        const objectLiteral = tableCall.getArguments()[1];
+        if (!objectLiteral || !Node.isObjectLiteralExpression(objectLiteral)) {
+            return err(new Error('Invalid table definition'));
+        }
+        const properties = objectLiteral.getProperties();
+        for (const property of properties) {
+            if (!Node.isPropertyAssignment(property))
+                continue;
+            const propertyName = property.getName();
+            if (!validateColumnName(propertyName))
+                continue;
+            const initializer = property.getInitializer();
+            if (!initializer || !Node.isCallExpression(initializer))
+                continue;
+            const column = parseColumnDefinition(propertyName, initializer, property);
+            if (column.isOk()) {
+                columns.push(column.value);
+            }
+        }
+        return ok(columns);
+    }
+    catch (error) {
+        return err(new Error(`Failed to parse table columns: ${error instanceof Error ? error.message : String(error)}`));
+    }
+};
+const parseColumnDefinition = (name, columnCall, property) => {
+    try {
+        const callName = columnCall.getExpression().getText();
+        const args = columnCall.getArguments();
+        let type = 'unknown';
+        let length;
+        let isPrimary = false;
+        let isNullable = true;
+        // 型と長さを解析
+        if (callName.includes('varchar')) {
+            type = 'varchar';
+            if (args[1] && Node.isObjectLiteralExpression(args[1])) {
+                const lengthProp = args[1].getProperty('length');
+                if (lengthProp && Node.isPropertyAssignment(lengthProp)) {
+                    const lengthValue = lengthProp.getInitializer();
+                    if (lengthValue && Node.isNumericLiteral(lengthValue)) {
+                        length = parseInt(lengthValue.getText());
+                    }
+                }
+            }
+        }
+        else if (callName.includes('int')) {
+            type = 'int';
+        }
+        else if (callName.includes('text')) {
+            type = 'text';
+        }
+        // メソッドチェーンを解析
+        let currentCall = columnCall;
+        while (currentCall.getParent() && Node.isCallExpression(currentCall.getParent())) {
+            currentCall = currentCall.getParent();
+            const methodName = currentCall.getExpression().getText();
+            if (methodName.includes('primaryKey')) {
+                isPrimary = true;
+            }
+            else if (methodName.includes('notNull')) {
+                isNullable = false;
+            }
+        }
+        // JSDocコメントを解析
+        const jsDoc = property.getJsDocs()[0];
+        const comment = jsDoc ? extractComment(jsDoc.getText()) : undefined;
+        let zodSchema;
+        let valibotSchema;
+        if (jsDoc) {
+            const tags = jsDoc.getTags();
+            for (const tag of tags) {
+                const tagName = tag.getTagName();
+                const tagText = tag.getText();
+                if (tagName === 'z') {
+                    zodSchema = parseZodTag(tagText);
+                }
+                else if (tagName === 'v') {
+                    valibotSchema = parseValibotTag(tagText);
+                }
+            }
+        }
+        return ok({
+            name,
+            type,
+            isPrimary,
+            isNullable,
+            length,
+            zodSchema,
+            valibotSchema,
+            comment
+        });
+    }
+    catch (error) {
+        return err(new Error(`Failed to parse column definition: ${error instanceof Error ? error.message : String(error)}`));
+    }
+};
+const parseRelation = (relationCall, tableNames) => {
+    try {
+        // リレーションコメントを探す
+        const jsDoc = relationCall.getJsDocs()[0];
+        if (!jsDoc)
+            return err(new Error('No relation comment found'));
+        const relationText = parseRelationTag(jsDoc.getText());
+        const parts = relationText.split(' ');
+        if (parts.length < 4)
+            return err(new Error('Invalid relation format'));
+        const sourceTable = parts[0];
+        const sourceColumn = parts[1];
+        const targetTable = parts[2];
+        const targetColumn = parts[3];
+        const type = parts[4] || 'one-to-many';
+        if (!validateRelationType(type)) {
+            return err(new Error(`Invalid relation type: ${type}`));
+        }
+        if (!tableNames.includes(sourceTable) || !tableNames.includes(targetTable)) {
+            return err(new Error(`Table not found in relation: ${sourceTable} -> ${targetTable}`));
+        }
+        return ok({
+            sourceTable,
+            sourceColumn,
+            targetTable,
+            targetColumn,
+            type
+        });
+    }
+    catch (error) {
+        return err(new Error(`Failed to parse relation: ${error instanceof Error ? error.message : String(error)}`));
+    }
+};

package/dist/shared/helper/build-schema-extractor.d.ts

@@ -0,0 +1,25 @@
+import type { CallExpression } from 'ts-morph';
+import { Node } from 'ts-morph';
+/**
+ * Creates a schema extractor from customizable strategies.
+ *
+ * @param extractFieldsFromCall - Function to extract fields from a call expression (e.g. mysqlTable(...)).
+ * @param extractFieldFromProperty - Function to extract a single field from an object literal property.
+ * @returns A function that extracts a schema from a variable declaration node.
+ */
+export declare function buildSchemaExtractor(extractFieldsFromCall: (call: CallExpression, sourceText: string) => {
+    name: string;
+    definition: string;
+    description?: string;
+}[], extractFieldFromProperty: (prop: Node, sourceText: string) => {
+    name: string;
+    definition: string;
+    description?: string;
+} | null): (declaration: Node, sourceText: string) => {
+    name: string;
+    fields: {
+        name: string;
+        definition: string;
+        description?: string;
+    }[];
+} | null;

package/dist/shared/helper/build-schema-extractor.js

@@ -0,0 +1,33 @@
+import { Node } from 'ts-morph';
+import { isRelationFunctionCall } from '../../shared/helper/is-relation-function.js';
+/**
+ * Creates a schema extractor from customizable strategies.
+ *
+ * @param extractFieldsFromCall - Function to extract fields from a call expression (e.g. mysqlTable(...)).
+ * @param extractFieldFromProperty - Function to extract a single field from an object literal property.
+ * @returns A function that extracts a schema from a variable declaration node.
+ */
+export function buildSchemaExtractor(extractFieldsFromCall, extractFieldFromProperty) {
+    return (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 (isRelationFunctionCall(initializer))
+                return null;
+            const fields = extractFieldsFromCall(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: [] };
+    };
+}

package/dist/shared/helper/create-extract-field-from-property.d.ts

@@ -0,0 +1,15 @@
+import { Node } from 'ts-morph';
+/**
+ * Creates a field extractor function using a custom parseFieldComments implementation.
+ *
+ * @param parseFieldComments - A function that parses comment lines into { definition, description }
+ * @returns A property node extractor function.
+ */
+export declare function createExtractFieldFromProperty(parseFieldComments: (commentLines: string[]) => {
+    definition: string;
+    description?: string;
+}): (property: Node, sourceText: string) => {
+    name: string;
+    definition: string;
+    description?: string;
+} | null;

package/dist/shared/helper/create-extract-field-from-property.js

@@ -0,0 +1,20 @@
+import { Node } from 'ts-morph';
+import { extractFieldComments } from '../../shared/utils/index.js';
+/**
+ * Creates a field extractor function using a custom parseFieldComments implementation.
+ *
+ * @param parseFieldComments - A function that parses comment lines into { definition, description }
+ * @returns A property node extractor function.
+ */
+export function createExtractFieldFromProperty(parseFieldComments) {
+    return (property, sourceText) => {
+        if (!Node.isPropertyAssignment(property))
+            return null;
+        const name = property.getName();
+        if (!name)
+            return null;
+        const commentLines = extractFieldComments(sourceText, property.getStart());
+        const { definition, description } = parseFieldComments(commentLines);
+        return { name, definition, description };
+    };
+}

package/dist/shared/helper/create-extract-fields-from-call-expression.d.ts

@@ -0,0 +1,14 @@
+import type { CallExpression, Node, ObjectLiteralExpression } from 'ts-morph';
+export declare function createExtractFieldsFromCallExpression(extractFieldFromProperty: (property: Node, sourceText: string) => {
+    name: string;
+    definition: string;
+    description?: string;
+} | null, extractRelationFieldFromProperty: (property: Node, sourceText: string) => {
+    name: string;
+    definition: string;
+    description?: string;
+} | null, findObjectLiteralExpression: (expr: Node) => ObjectLiteralExpression | null, findObjectLiteralInArgs: (call: CallExpression, finder: (expr: Node) => ObjectLiteralExpression | null) => ObjectLiteralExpression | null, isRelationFunctionCall: (call: CallExpression) => boolean): (callExpr: CallExpression, sourceText: string) => {
+    name: string;
+    definition: string;
+    description?: string;
+}[];

package/dist/shared/helper/create-extract-fields-from-call-expression.js

@@ -0,0 +1,14 @@
+export function createExtractFieldsFromCallExpression(extractFieldFromProperty, extractRelationFieldFromProperty, findObjectLiteralExpression, findObjectLiteralInArgs, isRelationFunctionCall) {
+    return (callExpr, sourceText) => {
+        const objectLiteral = findObjectLiteralInArgs(callExpr, findObjectLiteralExpression);
+        if (!objectLiteral)
+            return [];
+        const isRelation = isRelationFunctionCall(callExpr);
+        return objectLiteral
+            .getProperties()
+            .map((prop) => isRelation
+            ? extractRelationFieldFromProperty(prop, sourceText)
+            : extractFieldFromProperty(prop, sourceText))
+            .filter((field) => field !== null);
+    };
+}

package/dist/shared/helper/create-extract-relation-field-from-property.d.ts

@@ -0,0 +1,12 @@
+import { Node } from 'ts-morph';
+export declare const createExtractRelationFieldFromProperty: (parseFieldComments: (lines: string[]) => {
+    definition: string;
+    description?: string;
+}, prefix: "v" | "z") => (property: Node, sourceText: string) => {
+    name: string;
+    fields: {
+        name: string;
+        definition: string;
+        description?: string;
+    }[];
+}["fields"][0] | null;

package/dist/shared/helper/create-extract-relation-field-from-property.js

@@ -0,0 +1,27 @@
+import { Node } from 'ts-morph';
+import { extractFieldComments, schemaName } from '../utils/index.js';
+export const createExtractRelationFieldFromProperty = (parseFieldComments, prefix) => {
+    return (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 schema = schemaName(refTable);
+        const definition = fnName === 'many' ? `${prefix}.array(${schema})` : fnName === 'one' ? schema : '';
+        const { description } = parseFieldComments(extractFieldComments(sourceText, property.getStart()));
+        return { name, definition, description };
+    };
+};

package/dist/shared/helper/extract-schemas.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Supported validation library types.
+ */
+export type ValidationLibrary = 'zod' | 'valibot';
+/**
+ * Schema extraction result type containing table name and field definitions.
+ */
+export type SchemaExtractionResult = {
+    /** The name of the table/schema */
+    name: string;
+    /** Optional base schema/table name (used for relations) */
+    baseName?: string;
+    /** Array of field definitions with name, validation definition, and description */
+    fields: {
+        /** Field name */
+        name: string;
+        /** Validation definition (e.g., 'z.uuid()', 'v.pipe(v.string(), v.uuid())') */
+        definition: string;
+        /** Optional field description from comments */
+        description?: string;
+    }[];
+    /** Object type for schema generation ('strict' | 'loose' | undefined) */
+    objectType?: 'strict' | 'loose';
+};
+/**
+ * Relation schema extraction result with required base name.
+ */
+export type RelationSchemaExtractionResult = {
+    name: string;
+    baseName: string;
+    fields: {
+        name: string;
+        definition: string;
+        description?: string;
+    }[];
+    /** Object type for schema generation ('strict' | 'loose' | undefined) */
+    objectType?: 'strict' | 'loose';
+};
+/**
+ * Extracts schemas from TypeScript source code using AST analysis.
+ *
+ * This function processes exported variable declarations to extract table schemas
+ * with their field definitions and comments. It supports both Zod and Valibot schema extraction.
+ *
+ * @param lines - Array of source code lines to process
+ * @param library - The validation library to extract schemas for ('zod' or 'valibot')
+ * @returns Array of extracted schemas with field definitions
+ *
+ * @example
+ * ```typescript
+ * // For Zod schemas
+ * const zodSchemas = extractSchemas(sourceLines, 'zod')
+ *
+ * // For Valibot schemas
+ * const valibotSchemas = extractSchemas(sourceLines, 'valibot')
+ * ```
+ */
+export declare function extractSchemas(lines: string[], library: ValidationLibrary): SchemaExtractionResult[];
+/**
+ * Extracts Zod schemas from TypeScript source code using AST analysis.
+ *
+ * This function processes exported variable declarations to extract table schemas
+ * with their field definitions and comments. It automatically handles Zod schema extraction.
+ *
+ * @param lines - Array of source code lines to process
+ * @returns Array of extracted schemas with field definitions
+ *
+ * @example
+ * ```typescript
+ * const schemas = extractZodSchemas(sourceLines)
+ * // Returns: [{ name: 'user', fields: [{ name: 'id', definition: 'z.uuid()', description: 'Primary key' }] }]
+ * ```
+ */
+export declare function extractZodSchemas(lines: string[]): SchemaExtractionResult[];
+/**
+ * Extracts Valibot schemas from TypeScript source code using AST analysis.
+ *
+ * This function processes exported variable declarations to extract table schemas
+ * with their field definitions and comments. It automatically handles Valibot schema extraction.
+ *
+ * @param lines - Array of source code lines to process
+ * @returns Array of extracted schemas with field definitions
+ *
+ * @example
+ * ```typescript
+ * const schemas = extractValibotSchemas(sourceLines)
+ * // Returns: [{ name: 'user', fields: [{ name: 'id', definition: 'v.pipe(v.string(), v.uuid())', description: 'Primary key' }] }]
+ * ```
+ */
+export declare function extractValibotSchemas(lines: string[]): SchemaExtractionResult[];
+/**
+ * Extracts relation schemas from `relations(...)` declarations using AST analysis.
+ *
+ * This returns entries like `userRelations` and `postRelations` with fields
+ * resolved to either `z.array(OtherSchema)` / `v.array(OtherSchema)` or direct
+ * `OtherSchema` based on `many`/`one`.
+ *
+ * Note: Base table schemas are not included here; use `extractSchemas` for those.
+ */
+export declare function extractRelationSchemas(lines: string[], library: ValidationLibrary): RelationSchemaExtractionResult[];
+/**
+ * Extracts relations from the given code.
+ *
+ * @param code - The code to extract relations from.
+ * @returns The extracted relations.
+ */
+export declare function extractRelations(code: string[]): {
+    fromModel: string;
+    toModel: string;
+    fromField: string;
+    toField: string;
+    type: string;
+}[];
+/**
+ * Parse relation line and extract components.
+ *
+ * @param line - The line to parse.
+ * @returns Parsed relation or null if not a relation line.
+ */
+export declare function parseRelationLine(line: string): {
+    fromModel: string;
+    toModel: string;
+    fromField: string;
+    toField: string;
+    type: string;
+} | null;
+/**
+ * Build a relation line from a string.
+ *
+ * @param input - The input string.
+ * @returns The built relation line.
+ */
+export declare function buildRelationLine(input: string): string;