septum 0.1.3 → 0.1.5

package/src/core/parser/extractors/typescript.ts

@@ -1,177 +1,181 @@
-import type { ExtractedDependency, ExtractedSymbol, ParsedFileAST, Visibility } from "../../../types/index.ts";
-import { findBraceBlockEnd } from "../boundary-tracker.ts";
-import type { CodeExtractor } from "./base.ts";
-
-export class TypeScriptExtractor implements CodeExtractor {
-  public canHandle(filePath: string): boolean {
-    return /\.(ts|tsx|js|jsx|mjs|cjs)$/i.test(filePath);
-  }
-
-  public async extract(filePath: string, content: string): Promise<ParsedFileAST> {
-    const symbols: ExtractedSymbol[] = [];
-    const dependencies: ExtractedDependency[] = [];
-
-    const lines = content.split("\n");
-
-    // 1. Extract Imports / Dependencies
-    const importRegex = /(?:import\s+(?:(?:[\w*\s{},]+)\s+from\s+)?['"]([^'"]+)['"]|require\s*\(\s*['"]([^'"]+)['"]\s*\))/g;
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      let match: RegExpExecArray | null;
-      while ((match = importRegex.exec(line)) !== null) {
-        const target = match[1] || match[2];
-        if (target) {
-          const isExternal = !target.startsWith(".") && !target.startsWith("/");
-          dependencies.push({
-            target,
-            statement: line.trim(),
-            line_number: i + 1,
-            is_external: isExternal,
-          });
-        }
-      }
-    }
-
-    // 2. Extract Symbols (Classes, Interfaces, Types, Functions, Methods)
-    let currentClass: string | null = null;
-    let currentClassEndLine = 0;
-
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      const trimmed = line.trim();
-      const lineNum = i + 1;
-
-      if (currentClass && lineNum > currentClassEndLine) {
-        currentClass = null;
-        currentClassEndLine = 0;
-      }
-
-      // Class / Interface / Type definition
-      const classMatch = /(?:export\s+)?(?:default\s+)?(?:abstract\s+)?(class|interface)\s+([A-Za-z0-9_]+)/.exec(trimmed);
-      if (classMatch) {
-        currentClass = classMatch[2];
-        const endLine = findBraceBlockEnd(lines, i);
-        currentClassEndLine = endLine;
-        symbols.push({
-          name: classMatch[2],
-          kind: classMatch[1] as "class" | "interface",
-          signature: trimmed.replace(/\{$/, "").trim(),
-          visibility: "public",
-          line_start: lineNum,
-          line_end: endLine,
-          line_count: Math.max(1, endLine - lineNum + 1),
-        });
-        continue;
-      }
-
-      // Type Alias
-      const typeMatch = /(?:export\s+)?type\s+([A-Za-z0-9_]+)\s*=/.exec(trimmed);
-      if (typeMatch) {
-        const endLine = trimmed.endsWith(";") ? lineNum : findBraceBlockEnd(lines, i);
-        symbols.push({
-          name: typeMatch[1],
-          kind: "type",
-          signature: trimmed.replace(/;$/, "").trim(),
-          visibility: "public",
-          line_start: lineNum,
-          line_end: endLine,
-          line_count: Math.max(1, endLine - lineNum + 1),
-        });
-        continue;
-      }
-
-      // Enum Declaration
-      const enumMatch = /(?:export\s+)?(?:const\s+)?enum\s+([A-Za-z0-9_]+)/.exec(trimmed);
-      if (enumMatch) {
-        const endLine = findBraceBlockEnd(lines, i);
-        symbols.push({
-          name: enumMatch[1],
-          kind: "enum",
-          signature: trimmed.replace(/\{$/, "").trim(),
-          visibility: "public",
-          line_start: lineNum,
-          line_end: endLine,
-          line_count: Math.max(1, endLine - lineNum + 1),
-        });
-        continue;
-      }
-
-      // Function Declaration
-      const fnMatch = /(?:export\s+)?(?:async\s+)?function\s+([A-Za-z0-9_]+)\s*\(([^)]*)\)(?:\s*:\s*([^;{]+))?/.exec(trimmed);
-      if (fnMatch) {
-        const name = fnMatch[1];
-        const params = fnMatch[2];
-        const retType = fnMatch[3] ? `: ${fnMatch[3].trim()}` : "";
-        const endLine = findBraceBlockEnd(lines, i);
-        symbols.push({
-          name,
-          kind: "function",
-          signature: `${name}(${params})${retType}`,
-          visibility: "public",
-          line_start: lineNum,
-          line_end: endLine,
-          line_count: Math.max(1, endLine - lineNum + 1),
-        });
-        continue;
-      }
-
-      // Exported Constants / Variables at module level
-      const constMatch = /^export\s+(?:const|let|var)\s+([A-Za-z0-9_]+)\s*(?::\s*([^=;]+))?\s*=/.exec(trimmed);
-      if (constMatch) {
-        const varName = constMatch[1];
-        const typeStr = constMatch[2] ? `: ${constMatch[2].trim()}` : "";
-        symbols.push({
-          name: varName,
-          kind: "property",
-          signature: `const ${varName}${typeStr}`,
-          visibility: "public",
-          line_start: lineNum,
-          line_end: lineNum,
-          line_count: 1,
-        });
-        continue;
-      }
-
-      // Method or Property in class
-      if (currentClass) {
-        // Class property: public foo: string; or private bar = 1;
-        const propMatch = /^(?:(public|protected|private)\s+)?(?:readonly\s+)?([A-Za-z0-9_]+)\s*(?:\?|\!)?\s*(?::\s*([^;={]+))?(?:\s*=[^;]+)?;\s*$/.exec(trimmed);
-        if (propMatch && !["return", "const", "let", "var", "throw", "import"].includes(propMatch[2])) {
-          const vis = (propMatch[1] as Visibility) || "public";
-          const propName = propMatch[2];
-          const typeStr = propMatch[3] ? `: ${propMatch[3].trim()}` : "";
-          symbols.push({
-            name: `${currentClass}::${propName}`,
-            kind: "property",
-            signature: `${vis} ${propName}${typeStr}`,
-            visibility: vis,
-            line_start: lineNum,
-            line_end: lineNum,
-            line_count: 1,
-          });
-          continue;
-        }
-
-        const methodMatch = /^(?:(public|protected|private)\s+)?(?:static\s+)?(?:async\s+)?([A-Za-z0-9_]+)\s*\(([^)]*)\)(?:\s*:\s*([^;{]+))?/.exec(trimmed);
-        if (methodMatch && !["if", "for", "while", "switch", "catch"].includes(methodMatch[2])) {
-          const vis = (methodMatch[1] as Visibility) || "public";
-          const name = methodMatch[2];
-          const params = methodMatch[3];
-          const retType = methodMatch[4] ? `: ${methodMatch[4].trim()}` : "";
-          const endLine = findBraceBlockEnd(lines, i);
-          symbols.push({
-            name: `${currentClass}::${name}`,
-            kind: "method",
-            signature: `${vis} ${name}(${params})${retType}`,
-            visibility: vis,
-            line_start: lineNum,
-            line_end: endLine,
-            line_count: Math.max(1, endLine - lineNum + 1),
-          });
-        }
-      }
-    }
-
-    return { symbols, dependencies };
-  }
-}
+import type { ExtractedDependency, ExtractedSymbol, ParsedFileAST, Visibility } from "../../../types/index.ts";
+import { findBraceBlockEnd, calculateControlFlowNesting } from "../boundary-tracker.ts";
+import type { CodeExtractor } from "./base.ts";
+
+export class TypeScriptExtractor implements CodeExtractor {
+  public canHandle(filePath: string): boolean {
+    return /\.(ts|tsx|js|jsx|mjs|cjs)$/i.test(filePath);
+  }
+
+  public async extract(filePath: string, content: string): Promise<ParsedFileAST> {
+    const symbols: ExtractedSymbol[] = [];
+    const dependencies: ExtractedDependency[] = [];
+
+    const lines = content.split("\n");
+
+    // 1. Extract Imports / Dependencies
+    const importRegex = /(?:import\s+(?:(?:[\w*\s{},]+)\s+from\s+)?['"]([^'"]+)['"]|require\s*\(\s*['"]([^'"]+)['"]\s*\))/g;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      let match: RegExpExecArray | null;
+      while ((match = importRegex.exec(line)) !== null) {
+        const target = match[1] || match[2];
+        if (target) {
+          const isExternal = !target.startsWith(".") && !target.startsWith("/");
+          dependencies.push({
+            target,
+            statement: line.trim(),
+            line_number: i + 1,
+            is_external: isExternal,
+          });
+        }
+      }
+    }
+
+    // 2. Extract Symbols (Classes, Interfaces, Types, Functions, Methods)
+    let currentClass: string | null = null;
+    let currentClassEndLine = 0;
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const trimmed = line.trim();
+      const lineNum = i + 1;
+
+      if (currentClass && lineNum > currentClassEndLine) {
+        currentClass = null;
+        currentClassEndLine = 0;
+      }
+
+      // Class / Interface / Type definition
+      const classMatch = /(?:export\s+)?(?:default\s+)?(?:abstract\s+)?(class|interface)\s+([A-Za-z0-9_]+)/.exec(trimmed);
+      if (classMatch) {
+        currentClass = classMatch[2];
+        const endLine = findBraceBlockEnd(lines, i);
+        currentClassEndLine = endLine;
+        symbols.push({
+          name: classMatch[2],
+          kind: classMatch[1] as "class" | "interface",
+          signature: trimmed.replace(/\{$/, "").trim(),
+          visibility: "public",
+          line_start: lineNum,
+          line_end: endLine,
+          line_count: Math.max(1, endLine - lineNum + 1),
+        });
+        continue;
+      }
+
+      // Type Alias
+      const typeMatch = /(?:export\s+)?type\s+([A-Za-z0-9_]+)\s*=/.exec(trimmed);
+      if (typeMatch) {
+        const endLine = trimmed.endsWith(";") ? lineNum : findBraceBlockEnd(lines, i);
+        symbols.push({
+          name: typeMatch[1],
+          kind: "type",
+          signature: trimmed.replace(/;$/, "").trim(),
+          visibility: "public",
+          line_start: lineNum,
+          line_end: endLine,
+          line_count: Math.max(1, endLine - lineNum + 1),
+        });
+        continue;
+      }
+
+      // Enum Declaration
+      const enumMatch = /(?:export\s+)?(?:const\s+)?enum\s+([A-Za-z0-9_]+)/.exec(trimmed);
+      if (enumMatch) {
+        const endLine = findBraceBlockEnd(lines, i);
+        symbols.push({
+          name: enumMatch[1],
+          kind: "enum",
+          signature: trimmed.replace(/\{$/, "").trim(),
+          visibility: "public",
+          line_start: lineNum,
+          line_end: endLine,
+          line_count: Math.max(1, endLine - lineNum + 1),
+        });
+        continue;
+      }
+
+      // Function Declaration
+      const fnMatch = /(?:export\s+)?(?:async\s+)?function\s+([A-Za-z0-9_]+)\s*\(([^)]*)\)(?:\s*:\s*([^;{]+))?/.exec(trimmed);
+      if (fnMatch) {
+        const name = fnMatch[1];
+        const params = fnMatch[2];
+        const retType = fnMatch[3] ? `: ${fnMatch[3].trim()}` : "";
+        const endLine = findBraceBlockEnd(lines, i);
+        const nestingDepth = calculateControlFlowNesting(lines, i, endLine - 1);
+        symbols.push({
+          name,
+          kind: "function",
+          signature: `${name}(${params})${retType}`,
+          visibility: "public",
+          line_start: lineNum,
+          line_end: endLine,
+          line_count: Math.max(1, endLine - lineNum + 1),
+          nesting_depth: nestingDepth,
+        });
+        continue;
+      }
+
+      // Exported Constants / Variables at module level
+      const constMatch = /^export\s+(?:const|let|var)\s+([A-Za-z0-9_]+)\s*(?::\s*([^=;]+))?\s*=/.exec(trimmed);
+      if (constMatch) {
+        const varName = constMatch[1];
+        const typeStr = constMatch[2] ? `: ${constMatch[2].trim()}` : "";
+        symbols.push({
+          name: varName,
+          kind: "property",
+          signature: `const ${varName}${typeStr}`,
+          visibility: "public",
+          line_start: lineNum,
+          line_end: lineNum,
+          line_count: 1,
+        });
+        continue;
+      }
+
+      // Method or Property in class
+      if (currentClass) {
+        // Class property: public foo: string; or private bar = 1;
+        const propMatch = /^(?:(public|protected|private)\s+)?(?:readonly\s+)?([A-Za-z0-9_]+)\s*(?:\?|\!)?\s*(?::\s*([^;={]+))?(?:\s*=[^;]+)?;\s*$/.exec(trimmed);
+        if (propMatch && !["return", "const", "let", "var", "throw", "import"].includes(propMatch[2])) {
+          const vis = (propMatch[1] as Visibility) || "public";
+          const propName = propMatch[2];
+          const typeStr = propMatch[3] ? `: ${propMatch[3].trim()}` : "";
+          symbols.push({
+            name: `${currentClass}::${propName}`,
+            kind: "property",
+            signature: `${vis} ${propName}${typeStr}`,
+            visibility: vis,
+            line_start: lineNum,
+            line_end: lineNum,
+            line_count: 1,
+          });
+          continue;
+        }
+
+        const methodMatch = /^(?:(public|protected|private)\s+)?(?:static\s+)?(?:async\s+)?([A-Za-z0-9_]+)\s*\(([^)]*)\)(?:\s*:\s*([^;{]+))?/.exec(trimmed);
+        if (methodMatch && !["if", "for", "while", "switch", "catch"].includes(methodMatch[2])) {
+          const vis = (methodMatch[1] as Visibility) || "public";
+          const name = methodMatch[2];
+          const params = methodMatch[3];
+          const retType = methodMatch[4] ? `: ${methodMatch[4].trim()}` : "";
+          const endLine = findBraceBlockEnd(lines, i);
+          const nestingDepth = calculateControlFlowNesting(lines, i, endLine - 1);
+          symbols.push({
+            name: `${currentClass}::${name}`,
+            kind: "method",
+            signature: `${vis} ${name}(${params})${retType}`,
+            visibility: vis,
+            line_start: lineNum,
+            line_end: endLine,
+            line_count: Math.max(1, endLine - lineNum + 1),
+            nesting_depth: nestingDepth,
+          });
+        }
+      }
+    }
+
+    return { symbols, dependencies };
+  }
+}

package/src/core/parser/schema/providers/laravel-migration-provider.ts

@@ -0,0 +1,215 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type {
+  SchemaFieldSummary,
+  SchemaMetadata,
+  StackSchemaProvider,
+} from "../schema-provider.interface.ts";
+
+export class LaravelMigrationSchemaProvider implements StackSchemaProvider {
+  public readonly id = "laravel-migration";
+  public readonly name = "Laravel Migration Schema Provider";
+
+  public canHandle(projectRoot: string): boolean {
+    const migrationsDir = path.join(projectRoot, "database", "migrations");
+    return fs.existsSync(migrationsDir) || fs.existsSync(path.join(projectRoot, "artisan"));
+  }
+
+  public resolveEntitySchema(
+    projectRoot: string,
+    entitySymbol: string,
+    entityFilePath?: string
+  ): SchemaMetadata | null {
+    const migrationsDir = path.join(projectRoot, "database", "migrations");
+    if (!fs.existsSync(migrationsDir)) return null;
+
+    const tableName = this.resolveTableName(projectRoot, entitySymbol, entityFilePath);
+    if (!tableName) return null;
+
+    const migrationFiles = this.findMigrationFilesForTable(migrationsDir, tableName);
+    if (migrationFiles.length === 0) return null;
+
+    const fieldsMap = new Map<string, SchemaFieldSummary>();
+    let primarySourceFile = migrationFiles[0];
+
+    for (const migFile of migrationFiles) {
+      const fullPath = path.join(migrationsDir, migFile);
+      try {
+        const content = fs.readFileSync(fullPath, "utf-8");
+        this.extractColumnsFromMigration(content, tableName, fieldsMap);
+      } catch {
+        // Skip unreadable files
+      }
+    }
+
+    if (fieldsMap.size === 0) return null;
+
+    const relSourceFile = path.relative(projectRoot, path.join(migrationsDir, primarySourceFile));
+
+    return {
+      entityName: entitySymbol,
+      tableName,
+      schemaSourceFile: relSourceFile,
+      fields: Array.from(fieldsMap.values()),
+    };
+  }
+
+  private resolveTableName(
+    projectRoot: string,
+    entitySymbol: string,
+    entityFilePath?: string
+  ): string {
+    // 1. Check if model file defines explicit protected $table = '...';
+    if (entityFilePath) {
+      const fullEntityPath = path.isAbsolute(entityFilePath)
+        ? entityFilePath
+        : path.join(projectRoot, entityFilePath);
+      if (fs.existsSync(fullEntityPath)) {
+        try {
+          const content = fs.readFileSync(fullEntityPath, "utf-8");
+          const tableMatch = /protected\s+\$table\s*=\s*['"]([^'"]+)['"]/.exec(content);
+          if (tableMatch) {
+            return tableMatch[1];
+          }
+        } catch {}
+      }
+    }
+
+    // 2. Derive snake_case plural from entity name (e.g. OrderItem -> order_items)
+    return this.pluralize(this.toSnakeCase(entitySymbol));
+  }
+
+  private toSnakeCase(str: string): string {
+    return str
+      .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+      .replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2")
+      .toLowerCase();
+  }
+
+  private pluralize(snake: string): string {
+    if (snake.endsWith("y") && !/[aeiou]y$/i.test(snake)) {
+      return `${snake.slice(0, -1)}ies`;
+    }
+    if (/(?:s|x|z|ch|sh)$/i.test(snake)) {
+      return `${snake}es`;
+    }
+    return `${snake}s`;
+  }
+
+  private findMigrationFilesForTable(migrationsDir: string, tableName: string): string[] {
+    const files = fs.readdirSync(migrationsDir).filter((f) => f.endsWith(".php")).sort();
+    const matched: string[] = [];
+
+    // Priority 1: *_create_${tableName}_table.php
+    const createTarget = `_create_${tableName}_table.php`;
+    for (const f of files) {
+      if (f.endsWith(createTarget)) {
+        matched.push(f);
+      }
+    }
+
+    // Priority 2: Other migration files altering this table
+    for (const f of files) {
+      if (matched.includes(f)) continue;
+      if (f.includes(`_${tableName}_`)) {
+        matched.push(f);
+      }
+    }
+
+    // If still not found by filename, do a lightweight content search
+    if (matched.length === 0) {
+      for (const f of files) {
+        try {
+          const content = fs.readFileSync(path.join(migrationsDir, f), "utf-8");
+          if (
+            content.includes(`Schema::create('${tableName}'`) ||
+            content.includes(`Schema::create("${tableName}"`) ||
+            content.includes(`Schema::table('${tableName}'`) ||
+            content.includes(`Schema::table("${tableName}"`)
+          ) {
+            matched.push(f);
+          }
+        } catch {}
+      }
+    }
+
+    return matched;
+  }
+
+  private extractColumnsFromMigration(
+    content: string,
+    tableName: string,
+    fieldsMap: Map<string, SchemaFieldSummary>
+  ): void {
+    const lines = content.split("\n");
+
+    for (const rawLine of lines) {
+      const line = rawLine.trim();
+      if (!line.includes("$table->")) continue;
+
+      // Special shorthand: $table->id();
+      if (/\$table->id\s*\(\s*\)/.test(line)) {
+        fieldsMap.set("id", { name: "id", type: "id", isPrimary: true });
+        continue;
+      }
+
+      // Special shorthand: $table->id('custom_id');
+      const customIdMatch = /\$table->id\s*\(\s*['"]([^'"]+)['"]\s*\)/.exec(line);
+      if (customIdMatch) {
+        fieldsMap.set(customIdMatch[1], { name: customIdMatch[1], type: "id", isPrimary: true });
+        continue;
+      }
+
+      // Special shorthand: $table->timestamps();
+      if (/\$table->timestamps\s*\(/.test(line)) {
+        if (!fieldsMap.has("created_at")) {
+          fieldsMap.set("created_at", { name: "created_at", type: "timestamp", nullable: true });
+        }
+        if (!fieldsMap.has("updated_at")) {
+          fieldsMap.set("updated_at", { name: "updated_at", type: "timestamp", nullable: true });
+        }
+        continue;
+      }
+
+      // Special shorthand: $table->softDeletes();
+      if (/\$table->softDeletes\s*\(/.test(line)) {
+        if (!fieldsMap.has("deleted_at")) {
+          fieldsMap.set("deleted_at", { name: "deleted_at", type: "timestamp", nullable: true });
+        }
+        continue;
+      }
+
+      // Special shorthand: $table->rememberToken();
+      if (/\$table->rememberToken\s*\(/.test(line)) {
+        if (!fieldsMap.has("remember_token")) {
+          fieldsMap.set("remember_token", { name: "remember_token", type: "string", nullable: true });
+        }
+        continue;
+      }
+
+      // Standard column definitions: $table->type('column_name', ...)
+      const colMatch = /\$table->([a-zA-Z0-9_]+)\s*\(\s*['"]([^'"]+)['"]/.exec(line);
+      if (colMatch) {
+        const type = colMatch[1];
+        const name = colMatch[2];
+
+        // Skip non-column fluent methods like foreign, dropColumn, index, primary
+        if (["index", "unique", "primary", "foreign", "dropColumn", "dropForeign"].includes(type)) {
+          continue;
+        }
+
+        const nullable = line.includes("->nullable()");
+        const isPrimary = type === "increments" || type === "bigIncrements" || line.includes("->primary()");
+        const isForeign = type.startsWith("foreign") || name.endsWith("_id");
+
+        fieldsMap.set(name, {
+          name,
+          type,
+          nullable: nullable || undefined,
+          isPrimary: isPrimary || undefined,
+          isForeign: isForeign || undefined,
+        });
+      }
+    }
+  }
+}

package/src/core/parser/schema/providers/prisma-schema-provider.ts

@@ -0,0 +1,89 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type {
+  SchemaFieldSummary,
+  SchemaMetadata,
+  StackSchemaProvider,
+} from "../schema-provider.interface.ts";
+
+export class PrismaSchemaProvider implements StackSchemaProvider {
+  public readonly id = "prisma";
+  public readonly name = "Prisma Schema Provider";
+
+  public canHandle(projectRoot: string): boolean {
+    return (
+      fs.existsSync(path.join(projectRoot, "prisma", "schema.prisma")) ||
+      fs.existsSync(path.join(projectRoot, "schema.prisma"))
+    );
+  }
+
+  public resolveEntitySchema(
+    projectRoot: string,
+    entitySymbol: string,
+    _entityFilePath?: string
+  ): SchemaMetadata | null {
+    const candidatePaths = [
+      path.join(projectRoot, "prisma", "schema.prisma"),
+      path.join(projectRoot, "schema.prisma"),
+    ];
+
+    let schemaPath: string | null = null;
+    for (const p of candidatePaths) {
+      if (fs.existsSync(p)) {
+        schemaPath = p;
+        break;
+      }
+    }
+
+    if (!schemaPath) return null;
+
+    try {
+      const content = fs.readFileSync(schemaPath, "utf-8");
+      const modelRegex = new RegExp(`model\\s+${entitySymbol}\\s*\\{([^}]+)\\}`, "m");
+      const match = modelRegex.exec(content);
+      if (!match) return null;
+
+      const body = match[1];
+      const lines = body.split("\n");
+      const fields: SchemaFieldSummary[] = [];
+
+      for (const rawLine of lines) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith("//") || line.startsWith("@@")) continue;
+
+        // Pattern: fieldName FieldType attributes...
+        const parts = line.split(/\s+/);
+        if (parts.length >= 2) {
+          const name = parts[0];
+          let type = parts[1];
+          const nullable = type.endsWith("?");
+          if (nullable) {
+            type = type.slice(0, -1);
+          }
+
+          const isPrimary = line.includes("@id");
+          const isForeign = line.includes("@relation");
+
+          fields.push({
+            name,
+            type,
+            nullable: nullable || undefined,
+            isPrimary: isPrimary || undefined,
+            isForeign: isForeign || undefined,
+          });
+        }
+      }
+
+      if (fields.length === 0) return null;
+
+      return {
+        entityName: entitySymbol,
+        tableName: entitySymbol.toLowerCase(),
+        schemaSourceFile: path.relative(projectRoot, schemaPath),
+        fields,
+      };
+    } catch {
+      return null;
+    }
+  }
+}