tina4-nodejs 3.10.64 → 3.10.66

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tina4-nodejs",
-  "version": "3.10.64",
+  "version": "3.10.66",
   "type": "module",
   "description": "Tina4 for Node.js/TypeScript — 54 built-in features, zero dependencies",
   "keywords": ["tina4", "framework", "web", "api", "orm", "graphql", "websocket", "typescript"],

package/packages/core/src/metrics.ts

@@ -50,22 +50,74 @@ function readFileSafe(filePath: string): string | null {
   }
 }
 
-function relativePath(filePath: string): string {
-  return path.relative(".", filePath);
+function relativePath(filePath: string, root: string = "."): string {
+  return path.relative(root, filePath);
 }
 
+// Stores the resolved scan root so fileDetail() can locate framework files.
+let _lastScanRoot = "";
+
 // ── Test file detection ─────────────────────────────────────
 
 function hasMatchingTest(relPath: string): boolean {
-  const name = relPath.split('/').pop()?.replace('.ts', '').replace('.js', '') || '';
-  const patterns = [
-    `test/${name}.test.ts`,
-    `test/${name}.test.js`,
-    `${relPath.replace('.ts', '.test.ts').replace('.js', '.test.js')}`,
-    `tests/${name}.test.ts`,
-    `spec/${name}.spec.ts`,
-  ];
-  return patterns.some(p => fs.existsSync(p));
+  const parts = relPath.split('/');
+  const basename = parts[parts.length - 1] || '';
+  const name = basename.replace(/\.(ts|js)$/, '');
+  // Parent directory name (e.g. "adapters" from "adapters/sqlite.ts")
+  const parentModule = parts.length > 1 ? parts[parts.length - 2] : '';
+
+  // Stage 1: Filename matching — name.test, name.spec, test_name patterns
+  const testDirs = ['test', 'tests', 'spec'];
+  for (const td of testDirs) {
+    const patterns = [
+      `${td}/${name}.test.ts`,
+      `${td}/${name}.test.js`,
+      `${td}/${name}.spec.ts`,
+      `${td}/${name}.spec.js`,
+      // Also check parent-named tests (test/database.test.ts covers adapters/sqlite.ts)
+      ...(parentModule && parentModule !== name ? [
+        `${td}/${parentModule}.test.ts`,
+        `${td}/${parentModule}.test.js`,
+        `${td}/${parentModule}.spec.ts`,
+      ] : []),
+    ];
+    if (patterns.some(p => fs.existsSync(p))) {
+      return true;
+    }
+  }
+
+  // Build the module import path for content matching
+  // e.g. "packages/core/src/metrics.ts" → "metrics" or "src/metrics"
+  const pathWithoutExt = relPath.replace(/\.(ts|js)$/, '');
+  // Build CamelCase class name from camelCase/kebab module name
+  // e.g. "sqlTranslation" → "SqlTranslation", "sql-translation" → "SqlTranslation"
+  const className = name
+    .replace(/[-_](.)/g, (_, c: string) => c.toUpperCase())
+    .replace(/^(.)/, (_, c: string) => c.toUpperCase());
+
+  // Stage 2+3: Content scan — check if any test file imports or references this module
+  for (const td of testDirs) {
+    if (!fs.existsSync(td)) continue;
+    const testFiles = walkFiles(td, ['.ts', '.js']);
+    for (const testFile of testFiles) {
+      const content = readFileSafe(testFile);
+      if (content === null) continue;
+      // Stage 2: import path matching
+      if (content.includes(name) && (
+        content.includes(`"${name}"`) || content.includes(`'${name}'`) ||
+        content.includes(`/${name}"`) || content.includes(`/${name}'`) ||
+        content.includes(pathWithoutExt)
+      )) {
+        return true;
+      }
+      // Stage 3: class name mention
+      if (className !== name && new RegExp(`\\b${className.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`).test(content)) {
+        return true;
+      }
+    }
+  }
+
+  return false;
 }
 
 // ── Line counting ────────────────────────────────────────────
@@ -192,7 +244,7 @@ interface FunctionInfo {
   file?: string;
 }
 
-function extractFunctions(source: string, filePath: string): FunctionInfo[] {
+function extractFunctions(source: string, filePath: string, root: string = "."): FunctionInfo[] {
   const functions: FunctionInfo[] = [];
   const lines = source.split("\n");
 
@@ -268,7 +320,7 @@ function extractFunctions(source: string, filePath: string): FunctionInfo[] {
           complexity,
           loc: funcLoc,
           args,
-          file: relativePath(filePath),
+          file: relativePath(filePath, root),
         });
 
         break; // Only match first pattern per line
@@ -542,10 +594,13 @@ function detectViolations(
 function resolveRoot(root: string = "src"): string {
   const rootPath = path.resolve(root);
   if (fs.existsSync(rootPath) && walkFiles(rootPath, [".ts", ".js"]).length > 0) {
+    _lastScanRoot = rootPath;
     return root;
   }
   // Fallback: scan the framework package itself
-  return path.resolve(path.dirname(new URL(import.meta.url).pathname));
+  const fwDir = path.resolve(path.dirname(new URL(import.meta.url).pathname));
+  _lastScanRoot = fwDir;
+  return fwDir;
 }
 
 // ── Quick Metrics ────────────────────────────────────────────
@@ -590,7 +645,7 @@ export function quickMetrics(root: string = "src"): Record<string, any> {
     totalFunctions += functions;
 
     fileDetails.push({
-      path: relativePath(f),
+      path: relativePath(f, rootPath),
       loc: counts.loc,
       blank: counts.blank,
       comment: counts.comment,
@@ -704,7 +759,7 @@ export function fullAnalysis(root: string = "src"): Record<string, any> {
     const source = readFileSafe(f);
     if (source === null) continue;
 
-    const relPath = relativePath(f);
+    const relPath = relativePath(f, rootPath);
     const lines = source.split("\n");
     const loc = lines.filter(
       (l) => l.trim() && !l.trim().startsWith("//")
@@ -722,7 +777,7 @@ export function fullAnalysis(root: string = "src"): Record<string, any> {
     }
 
     // Analyze functions/methods
-    const fileFunctions = extractFunctions(source, f);
+    const fileFunctions = extractFunctions(source, f, rootPath);
     let fileComplexity = 0;
 
     for (const func of fileFunctions) {
@@ -805,7 +860,15 @@ export function fullAnalysis(root: string = "src"): Record<string, any> {
 // ── File Detail ──────────────────────────────────────────────
 
 export function fileDetail(filePath: string): Record<string, any> {
-  const resolved = path.resolve(filePath);
+  let resolved = path.resolve(filePath);
+  if (!fs.existsSync(resolved) && _lastScanRoot) {
+    // Try resolving relative to the last scan root (framework mode)
+    const candidate = path.resolve(_lastScanRoot, filePath);
+    if (fs.existsSync(candidate)) {
+      resolved = candidate;
+      filePath = candidate;
+    }
+  }
   if (!fs.existsSync(resolved)) {
     return { error: `File not found: ${filePath}` };
   }