tina4-nodejs 3.10.41 → 3.10.44

package/packages/core/src/index.ts

@@ -12,7 +12,7 @@ export type {
   WebSocketRouteDefinition,
 } from "./types.js";
 
-export { startServer, resolvePortAndHost } from "./server.js";
+export { startServer, resolvePortAndHost, handle } from "./server.js";
 export { Router, RouteGroup, RouteRef, defaultRouter, runRouteMiddlewares } from "./router.js";
 export { get, post, put, patch, del, any, websocket, del as delete } from "./router.js";
 export type { RouteInfo } from "./router.js";
@@ -68,7 +68,7 @@ export type { ResponseCacheConfig } from "./cache.js";
 export { Api } from "./api.js";
 export type { ApiResult } from "./api.js";
 export { Events } from "./events.js";
-export { DevAdmin, MessageLog, RequestInspector, ErrorTracker, DevMailboxStore, DevQueue, WsTracker } from "./devAdmin.js";
+export { DevAdmin, MessageLog, RequestInspector, ErrorTracker, DevMailboxStore, DevQueue, WsTracker, renderDashboard } from "./devAdmin.js";
 export { Messenger } from "./messenger.js";
 export type { SendResult, EmailMessage } from "./messenger.js";
 export { DevMailbox, createMessenger } from "./devMailbox.js";
@@ -94,6 +94,7 @@ export type { ValkeySessionConfig } from "./sessionHandlers/valkeyHandler.js";
 export { RedisNpmSessionHandler } from "./sessionHandlers/redisHandler.js";
 export type { RedisNpmSessionConfig } from "./sessionHandlers/redisHandler.js";
 export { tests, assertEqual, assertThrows, assertTrue, assertFalse, runAllTests, resetTests } from "./testing.js";
+export { TestClient, TestResponse } from "./testClient.js";
 export { Container, container } from "./container.js";
 export { Validator } from "./validator.js";
 export type { ValidationError } from "./validator.js";

package/packages/core/src/metrics.ts

@@ -54,6 +54,18 @@ function relativePath(filePath: string): string {
   return path.relative(".", filePath);
 }
 
+// ── Test file detection ─────────────────────────────────────
+
+function hasMatchingTest(relPath: string): boolean {
+  const name = relPath.split('/').pop()?.replace('.ts', '').replace('.js', '') || '';
+  const patterns = [
+    `test/${name}.test.ts`,
+    `${relPath.replace('.ts', '.test.ts').replace('.js', '.test.js')}`,
+    `tests/${name}.test.ts`,
+  ];
+  return patterns.some(p => fs.existsSync(p));
+}
+
 // ── Line counting ────────────────────────────────────────────
 
 interface LineCounts {
@@ -517,9 +529,27 @@ function detectViolations(
   return violations;
 }
 
+// ── Root Resolution ──────────────────────────────────────────
+
+/**
+ * Pick the right directory to scan.
+ *
+ * If the root dir has .ts files, scan the user's project code.
+ * Otherwise, scan the framework itself — so the bubble chart is never empty.
+ */
+function resolveRoot(root: string = "src"): string {
+  const rootPath = path.resolve(root);
+  if (fs.existsSync(rootPath) && walkFiles(rootPath, [".ts", ".js"]).length > 0) {
+    return root;
+  }
+  // Fallback: scan the framework package itself
+  return path.resolve(path.dirname(new URL(import.meta.url).pathname));
+}
+
 // ── Quick Metrics ────────────────────────────────────────────
 
 export function quickMetrics(root: string = "src"): Record<string, any> {
+  root = resolveRoot(root);
   const rootPath = path.resolve(root);
   if (!fs.existsSync(rootPath)) {
     return { error: `Directory not found: ${root}` };
@@ -644,6 +674,7 @@ function filesHash(root: string = "src"): string {
 }
 
 export function fullAnalysis(root: string = "src"): Record<string, any> {
+  root = resolveRoot(root);
   const currentHash = filesHash(root);
   const now = Date.now() / 1000;
 
@@ -730,6 +761,8 @@ export function fullAnalysis(root: string = "src"): Record<string, any> {
       coupling_afferent: ca,
       coupling_efferent: ce,
       instability: Math.round(instability * 1000) / 1000,
+      has_tests: hasMatchingTest(relPath),
+      dep_count: ce,
     });
   }
 
@@ -746,6 +779,10 @@ export function fullAnalysis(root: string = "src"): Record<string, any> {
   const totalMI = fileMetrics.reduce((sum, f) => sum + f.maintainability, 0);
   const avgMI = fileMetrics.length > 0 ? totalMI / fileMetrics.length : 0;
 
+  // Detect if we're scanning framework or project
+  const frameworkDir = path.resolve(path.dirname(new URL(import.meta.url).pathname));
+  const scanningFramework = rootPath === frameworkDir || rootPath.startsWith(frameworkDir + path.sep);
+
   const result: Record<string, any> = {
     files_analyzed: fileMetrics.length,
     total_functions: allFunctions.length,
@@ -755,6 +792,8 @@ export function fullAnalysis(root: string = "src"): Record<string, any> {
     file_metrics: fileMetrics,
     violations,
     dependency_graph: importGraph,
+    scan_mode: scanningFramework ? "framework" : "project",
+    scan_root: rootPath,
   };
 
   _fullCache = { hash: currentHash, data: result, time: now };
@@ -789,6 +828,18 @@ export function fileDetail(filePath: string): Record<string, any> {
   // Remove file field from function info for single-file detail
   const cleanFunctions = functions.map(({ file, ...rest }) => rest);
 
+  // Detect empty methods/functions (loc <= 1 means only a brace or pass-through)
+  const warnings: { type: string; message: string; line: number }[] = [];
+  for (const fn of cleanFunctions) {
+    if (fn.loc <= 1) {
+      warnings.push({
+        type: "empty_method",
+        message: `Method '${fn.name}' appears to be empty`,
+        line: fn.line,
+      });
+    }
+  }
+
   return {
     path: filePath,
     loc,
@@ -796,5 +847,6 @@ export function fileDetail(filePath: string): Record<string, any> {
     classes,
     functions: cleanFunctions,
     imports,
+    warnings,
   };
 }

package/packages/core/src/server.ts

@@ -1,4 +1,4 @@
-import { createServer } from "node:http";
+import { createServer, IncomingMessage, ServerResponse } from "node:http";
 import { resolve, dirname, join, relative } from "node:path";
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { isatty } from "node:tty";
@@ -302,6 +302,8 @@ h1{font-size:3rem;font-weight:700;margin-bottom:0.25rem;letter-spacing:-1px}
 .gbtn-deploy{background:#3b82f6;color:#fff}
 .gbtn-deploy:hover{background:#2563eb}
 .gbtn-deployed{background:transparent;border:1px solid #22c55e;color:#22c55e;cursor:default;font-size:0.7rem}
+@keyframes wiggle{0%{transform:rotate(0deg)}15%{transform:rotate(14deg)}30%{transform:rotate(-10deg)}45%{transform:rotate(8deg)}60%{transform:rotate(-4deg)}75%{transform:rotate(2deg)}100%{transform:rotate(0deg)}}
+.star-wiggle{display:inline-block;transform-origin:center}
 </style>
 </head>
 <body>
@@ -315,7 +317,7 @@ h1{font-size:3rem;font-weight:700;margin-bottom:0.25rem;letter-spacing:-1px}
         <a href="/__dev" class="btn">Dev Admin</a>
         <a href="#gallery" class="btn">Gallery</a>
         <a href="https://github.com/tina4stack/tina4-nodejs" class="btn" target="_blank">GitHub</a>
-        <a href="https://github.com/tina4stack/tina4-nodejs/stargazers" class="btn" target="_blank">&#11088; Star</a>
+        <a href="https://github.com/tina4stack/tina4-nodejs/stargazers" class="btn" target="_blank"><span class="star-wiggle">&#9734;</span> Star</a>
     </div>
     <div class="status">
         <span><span class="dot"></span>Server running</span>
@@ -364,11 +366,39 @@ function deployGallery(name) {
     })
     .catch(function(e) { alert('Deploy error: ' + e.message); });
 }
+(function(){
+    var star=document.querySelector('.star-wiggle');
+    if(!star)return;
+    function doWiggle(){
+        star.style.animation='wiggle 1.2s ease-in-out';
+        star.addEventListener('animationend',function onEnd(){
+            star.removeEventListener('animationend',onEnd);
+            star.style.animation='none';
+            var delay=3000+Math.random()*15000;
+            setTimeout(doWiggle,delay);
+        });
+    }
+    setTimeout(doWiggle,3000);
+})();
 </script>
 </body>
 </html>`;
 }
 
+// Module-level dispatch function — assigned when startServer() is called.
+// Allows handle() to route requests without requiring a reference to the server.
+let _dispatchFn: ((rawReq: IncomingMessage, rawRes: ServerResponse) => Promise<void>) | null = null;
+
+/**
+ * Dispatch a raw Node.js request through the Tina4 router and write the response.
+ * Requires startServer() to have been called first.
+ * Useful for testing and embedding.
+ */
+export async function handle(rawReq: IncomingMessage, rawRes: ServerResponse): Promise<void> {
+  if (!_dispatchFn) throw new Error("Tina4 server not started — call startServer() first");
+  return _dispatchFn(rawReq, rawRes);
+}
+
 export async function startServer(config?: Tina4Config): Promise<{
   close: () => void;
   router: Router;
@@ -578,7 +608,7 @@ ${reset}
     console.log(`  Dev dashboard at  \x1b[36mhttp://localhost:${port}/__dev\x1b[0m`);
   }
 
-  const server = createServer(async (rawReq, rawRes) => {
+  async function dispatch(rawReq: IncomingMessage, rawRes: ServerResponse): Promise<void> {
     const req = createRequest(rawReq);
     const res = createResponse(rawRes);
 
@@ -717,7 +747,7 @@ ${reset}
         let result: unknown;
         const routeParams = req.params || {};
         const fnStr = match.handler.toString();
-        const argMatch = fnStr.match(/^(?:async\s+)?(?:function\s*\w*)?\s*\(([^)]*)\)/);
+        const argMatch = fnStr.match(/^(?:async\s*)?(?:function\s*\w*)?\s*\(([^)]*)\)/);
         const argNames = argMatch?.[1]?.split(",").map((s: string) => s.trim().replace(/[:=].*/,"")) ?? [];
         const filteredArgs = argNames.filter((n: string) => n.length > 0);
 
@@ -808,7 +838,12 @@ ${reset}
         }
       }
     }
-  });
+  }
+
+  // Assign to module-level so handle() can dispatch without a server reference
+  _dispatchFn = dispatch;
+
+  const server = createServer(dispatch);
 
   return new Promise((resolvePromise) => {
     server.listen(port, host, () => {

package/packages/core/src/testClient.ts

@@ -0,0 +1,187 @@
+/**
+ * Tina4 Test Client — Test routes without starting a server.
+ *
+ * Usage:
+ *
+ *   import { TestClient } from "@tina4/core";
+ *
+ *   const client = new TestClient(router);
+ *
+ *   const response = await client.get("/api/users");
+ *   assert(response.status === 200);
+ *   assert(response.json().users);
+ *
+ *   const response = await client.post("/api/users", { json: { name: "Alice" } });
+ *   assert(response.status === 201);
+ */
+import { IncomingMessage, ServerResponse } from "node:http";
+import { Socket } from "node:net";
+import { createRequest, parseBody } from "./request.js";
+import { createResponse } from "./response.js";
+import { defaultRouter, type Router } from "./router.js";
+
+export class TestResponse {
+  public readonly status: number;
+  public readonly body: string;
+  public readonly headers: Record<string, string>;
+  public readonly contentType: string;
+
+  constructor(statusCode: number, headers: Record<string, string>, body: string) {
+    this.status = statusCode;
+    this.body = body;
+    this.headers = headers;
+    this.contentType = headers["content-type"] ?? "";
+  }
+
+  /** Parse body as JSON. */
+  json(): unknown {
+    if (!this.body) return null;
+    try {
+      return JSON.parse(this.body);
+    } catch {
+      return null;
+    }
+  }
+
+  /** Return body as a string. */
+  text(): string {
+    return this.body;
+  }
+
+  toString(): string {
+    return `<TestResponse status=${this.status} contentType="${this.contentType}">`;
+  }
+}
+
+interface RequestOptions {
+  json?: Record<string, unknown> | unknown[];
+  body?: string;
+  headers?: Record<string, string>;
+}
+
+export class TestClient {
+  private router: Router;
+
+  constructor(router?: Router) {
+    this.router = router ?? defaultRouter;
+  }
+
+  /** Send a GET request. */
+  async get(path: string, options?: RequestOptions): Promise<TestResponse> {
+    return this._request("GET", path, options);
+  }
+
+  /** Send a POST request. */
+  async post(path: string, options?: RequestOptions): Promise<TestResponse> {
+    return this._request("POST", path, options);
+  }
+
+  /** Send a PUT request. */
+  async put(path: string, options?: RequestOptions): Promise<TestResponse> {
+    return this._request("PUT", path, options);
+  }
+
+  /** Send a PATCH request. */
+  async patch(path: string, options?: RequestOptions): Promise<TestResponse> {
+    return this._request("PATCH", path, options);
+  }
+
+  /** Send a DELETE request. */
+  async delete(path: string, options?: RequestOptions): Promise<TestResponse> {
+    return this._request("DELETE", path, options);
+  }
+
+  /** Build a mock request, match the route, execute the handler. */
+  private async _request(method: string, path: string, options?: RequestOptions): Promise<TestResponse> {
+    const { json, body, headers } = options ?? {};
+
+    // Build raw body
+    let rawBody = "";
+    let contentType = "";
+    if (json !== undefined) {
+      rawBody = JSON.stringify(json);
+      contentType = "application/json";
+    } else if (body !== undefined) {
+      rawBody = body;
+    }
+
+    // Build headers
+    const reqHeaders: Record<string, string> = {};
+    if (headers) {
+      for (const [k, v] of Object.entries(headers)) {
+        reqHeaders[k.toLowerCase()] = v;
+      }
+    }
+    if (contentType && !reqHeaders["content-type"]) {
+      reqHeaders["content-type"] = contentType;
+    }
+    if (rawBody && !reqHeaders["content-length"]) {
+      reqHeaders["content-length"] = String(Buffer.byteLength(rawBody));
+    }
+
+    // Create a mock IncomingMessage
+    const socket = new Socket();
+    const rawReq = new IncomingMessage(socket);
+    rawReq.method = method.toUpperCase();
+    rawReq.url = path;
+    rawReq.headers = { ...reqHeaders, host: "localhost:7145" };
+
+    // Push body data into the readable stream
+    if (rawBody) {
+      rawReq.push(Buffer.from(rawBody));
+    }
+    rawReq.push(null); // signal end of stream
+
+    // Create a mock ServerResponse that captures output
+    const rawRes = new ServerResponse(rawReq);
+    const chunks: Buffer[] = [];
+    const originalWrite = rawRes.write.bind(rawRes);
+    const originalEnd = rawRes.end.bind(rawRes);
+
+    rawRes.write = function (chunk: any, ...args: any[]): boolean {
+      if (chunk) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+      return true;
+    } as typeof rawRes.write;
+
+    rawRes.end = function (chunk?: any, ...args: any[]): ServerResponse {
+      if (chunk) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+      return rawRes;
+    } as typeof rawRes.end;
+
+    // Create Tina4 request/response wrappers
+    const req = createRequest(rawReq);
+    const res = createResponse(rawRes);
+
+    // Parse body (populates req.body)
+    await parseBody(req);
+
+    // Split path for route matching
+    const cleanPath = path.includes("?") ? path.split("?")[0] : path;
+
+    // Match route
+    const match = this.router.match(method.toUpperCase(), cleanPath);
+    if (!match) {
+      return new TestResponse(404, { "content-type": "application/json" }, '{"error":"Not found"}');
+    }
+
+    // Inject route params
+    req.params = match.params;
+
+    // Execute handler
+    await match.handler(req, res);
+
+    // Collect response
+    const responseBody = Buffer.concat(chunks).toString();
+    const responseHeaders: Record<string, string> = {};
+    for (const [name, value] of Object.entries(rawRes.getHeaders())) {
+      if (value !== undefined) {
+        responseHeaders[name] = Array.isArray(value) ? value.join(", ") : String(value);
+      }
+    }
+
+    // Clean up the socket
+    socket.destroy();
+
+    return new TestResponse(rawRes.statusCode, responseHeaders, responseBody);
+  }
+}

package/packages/orm/src/adapters/sqlite.ts

@@ -57,9 +57,13 @@ export class SQLiteAdapter implements DatabaseAdapter {
   fetch<T = Record<string, unknown>>(sql: string, params?: unknown[], limit?: number, skip?: number): T[] {
     let effectiveSql = sql;
     if (limit !== undefined) {
-      effectiveSql += ` LIMIT ${limit}`;
-      if (skip !== undefined && skip > 0) {
-        effectiveSql += ` OFFSET ${skip}`;
+      // Skip appending LIMIT when the SQL already contains one (dedup)
+      const sqlBeforeComment = sql.toUpperCase().split("--")[0];
+      if (!sqlBeforeComment.includes("LIMIT")) {
+        effectiveSql += ` LIMIT ${limit}`;
+        if (skip !== undefined && skip > 0) {
+          effectiveSql += ` OFFSET ${skip}`;
+        }
       }
     }
     return this.query<T>(effectiveSql, params);

package/packages/orm/src/baseModel.ts

@@ -17,6 +17,15 @@ export function camelToSnake(name: string): string {
   return name.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`);
 }
 
+/**
+ * Check whether ORM_PLURAL_TABLE_NAMES is enabled in .env.
+ * When true, hasMany relationship keys get an "s" suffix (e.g. "posts" instead of "post").
+ */
+function _pluralRelKeys(): boolean {
+  const v = process.env.ORM_PLURAL_TABLE_NAMES ?? "";
+  return /^(true|1|yes)$/i.test(v);
+}
+
 /**
  * BaseModel provides instance methods for ORM models.
  * Models extend this class and define static properties.
@@ -395,7 +404,8 @@ export class BaseModel {
       }
       if (ModelClass.hasMany) {
         for (const rel of ModelClass.hasMany) {
-          const relKey = rel.model.toLowerCase() + "s";
+          const base = rel.model.toLowerCase();
+          const relKey = _pluralRelKeys() ? base + "s" : base;
           if (this[relKey] !== undefined) {
             result[relKey] = this[relKey];
           }
@@ -818,8 +828,9 @@ export class BaseModel {
     // Check hasMany
     if (ModelClass.hasMany) {
       const rel = ModelClass.hasMany.find((r) => {
-        const key = r.model.toLowerCase() + "s";
-        return key === relName || r.model.toLowerCase() === relName || r.model === relName;
+        const base = r.model.toLowerCase();
+        const key = _pluralRelKeys() ? base + "s" : base;
+        return key === relName || base === relName || r.model === relName;
       });
       if (rel) {
         const relatedClass = BaseModel._modelRegistry[rel.model];
@@ -877,8 +888,9 @@ export class BaseModel {
       }
       if (!relDef && ModelClass.hasMany) {
         relDef = ModelClass.hasMany.find((r) => {
-          const key = r.model.toLowerCase() + "s";
-          return key === relName || r.model.toLowerCase() === relName || r.model === relName;
+          const base = r.model.toLowerCase();
+          const key = _pluralRelKeys() ? base + "s" : base;
+          return key === relName || base === relName || r.model === relName;
         });
         if (relDef) relType = "hasMany";
       }