tina4-nodejs 3.13.37 → 3.13.39

package/packages/core/src/sessionHandlers/valkeyHandler.ts

@@ -26,6 +26,16 @@ export interface ValkeySessionConfig {
   password?: string;
   prefix?: string;
   db?: number;
+  // Unified SessionConfig fields are tolerated (and ignored) so the central
+  // Session can forward its config object without a structural mismatch.
+  backend?: string;
+  path?: string;
+  ttl?: number;
+  redisHost?: string;
+  redisPort?: number;
+  redisPassword?: string;
+  redisPrefix?: string;
+  redisDb?: number;
 }
 
 /**
@@ -67,7 +77,10 @@ export class ValkeySessionHandler implements SessionHandler {
   /**
    * Execute a RESP command synchronously via a short-lived TCP connection.
    *
-   * Returns the raw RESP response string.
+   * Returns the command result string. A genuine key miss yields `""`. A
+   * transport/connection FAILURE (server unreachable, AUTH error, timeout)
+   * THROWS so the Session boundary can distinguish "not found" (silent) from
+   * "backend failed" (log-loud + degrade). Backend-failure policy parity.
    */
   private execSync(args: string[]): string {
     const script = `
@@ -141,18 +154,24 @@ export class ValkeySessionHandler implements SessionHandler {
       setTimeout(() => { sock.destroy(); process.exit(1); }, 3000);
     `;
 
+    let result: string;
     try {
-      const result = execFileSync(process.execPath, ["-e", script], {
+      result = execFileSync(process.execPath, ["-e", script], {
         encoding: "utf-8",
         timeout: 5000,
         stdio: ["pipe", "pipe", "pipe"],
       });
-      if (result === "__NULL__") return "";
-      if (result.startsWith("__ERR__")) return "";
-      return result;
-    } catch {
-      return "";
+    } catch (err) {
+      // Non-zero exit = the child hit a socket error / AUTH failure / timeout.
+      // That is a transport FAILURE, not a key miss — surface it so the
+      // Session boundary logs + degrades (or re-throws under strict mode).
+      throw new Error(`Valkey command failed: ${(err as Error).message}`);
+    }
+    if (result === "__NULL__") return "";        // genuine key miss
+    if (result.startsWith("__ERR__")) {
+      throw new Error(`Valkey error: ${result.slice("__ERR__".length)}`);
     }
+    return result;
   }
 
   private key(sessionId: string): string {
@@ -161,7 +180,7 @@ export class ValkeySessionHandler implements SessionHandler {
 
   read(sessionId: string): SessionData | null {
     const raw = this.execSync(["GET", this.key(sessionId)]);
-    if (!raw) return null;
+    if (!raw) return null;     // key miss — normal "no session yet", NOT an error
     try {
       return JSON.parse(raw) as SessionData;
     } catch {

package/packages/core/src/testClient.ts

@@ -53,7 +53,7 @@ export class TestResponse {
   }
 }
 
-interface RequestOptions {
+export interface RequestOptions {
   json?: Record<string, unknown> | unknown[];
   body?: string;
   headers?: Record<string, string>;

package/packages/core/src/types.ts

@@ -179,13 +179,28 @@ export type MiddlewareSpec = Middleware | string;
  * event — one of "open", "message", or "close".
  * data — the incoming text message (only present for "message" events).
  */
-export type WebSocketRouteHandler = (
+export type WebSocketRouteHandler = ((
   connection: import("./websocketConnection.js").WebSocketConnection,
   event: "open" | "message" | "close",
   data: string,
-) => void | Promise<void>;
+) => void | Promise<void>) & {
+  /**
+   * Decorator-style secured flag — mirrors Python's `handler._secured`. When
+   * truthy the WS route requires a valid JWT on the upgrade. `Router.websocket`
+   * reads this into the route's `authRequired`. Lets a handler be marked
+   * secured in EITHER order (before or after registration).
+   */
+  _secured?: boolean;
+};
 
 export interface WebSocketRouteDefinition {
   pattern: string;
   handler: WebSocketRouteHandler;
+  /**
+   * True when this WS route requires a valid JWT on the upgrade. Public by
+   * default (mirrors GET). Set imperatively via `Router.websocket(path, fn,
+   * { secured: true })` / the returned `.secure()`, or by a `_secured` flag on
+   * the handler (decorator style).
+   */
+  authRequired?: boolean;
 }