keryx 0.21.9 → 0.22.0

package/classes/Action.ts

@@ -181,10 +181,12 @@ export abstract class Action {
    *   action's `inputs` Zod schema (falls back to `Record<string, unknown>` when no schema is
    *   defined). By the time `run` is called, all middleware `runBefore` hooks have already
    *   executed and may have mutated the params.
-   * @param connection - The connection that initiated this action. Provides access to the
-   *   caller's session (`connection.session`), subscription state, and raw transport handle.
-   *   It is `undefined` when the action is invoked outside an HTTP/WebSocket request context
-   *   (e.g., as a background task via the Resque worker or via `api.actions.run()`).
+   * @param connection - The connection that initiated this action. Always defined. Provides
+   *   access to the caller's session (`connection.session`), subscription state, and raw
+   *   transport handle. For background tasks (resque worker), `connection.type === "task"`
+   *   and `connection.session.data` is empty — tasks are fresh starts, so actions that
+   *   need user context should receive it as an input parameter rather than reading from
+   *   the session.
    * @param abortSignal - An `AbortSignal` tied to the action's timeout. The signal is aborted
    *   when the per-action `timeout` (or the global `config.actions.timeout`, default 300 000 ms)
    *   elapses. Long-running actions should check `abortSignal.aborted` or pass the signal to
@@ -194,7 +196,7 @@ export abstract class Action {
    */
   abstract run(
     params: ActionParams<Action>,
-    connection?: Connection,
+    connection: Connection,
     abortSignal?: AbortSignal,
   ): Promise<any>;
 }

package/initializers/resque.ts

@@ -279,9 +279,11 @@ export class Resque extends Initializer {
   };
 
   /**
-   * Wrap an action as a node-resque job. Creates a temporary `Connection` with type `"resque"`,
-   * converts inputs to a plain object, and runs the action via `connection.act()`. Handles
-   * fan-out result/error collection and recurring task re-enqueue.
+   * Wrap an action as a node-resque job. Creates a fresh `Connection` of type `"task"`
+   * with an empty in-memory session stub (tasks are fresh starts — no Redis read/write
+   * for session), converts inputs to a plain object, and runs the action via
+   * `connection.act()`. Handles fan-out result/error collection and recurring task
+   * re-enqueue.
    */
   wrapActionAsJob = (
     action: Action,
@@ -291,18 +293,6 @@ export class Resque extends Initializer {
       pluginOptions: {},
 
       perform: async function (params: ActionParams<typeof action>) {
-        const connection = new Connection(
-          "resque",
-          `job:${api.process.name}:${SERVER_JOB_COUNTER++}}`,
-        );
-
-        const propagatedCorrelationId = params._correlationId as
-          | string
-          | undefined;
-        if (propagatedCorrelationId) {
-          connection.correlationId = propagatedCorrelationId;
-        }
-
         const plainParams: Record<string, unknown> =
           typeof params === "object" && params !== null
             ? Object.fromEntries(
@@ -312,6 +302,27 @@ export class Resque extends Initializer {
               )
             : {};
 
+        const propagatedCorrelationId = plainParams._correlationId as
+          | string
+          | undefined;
+
+        const connection = new Connection(
+          "task",
+          `job:${api.process.name}:${SERVER_JOB_COUNTER++}`,
+        );
+        if (propagatedCorrelationId) {
+          connection.correlationId = propagatedCorrelationId;
+        }
+        // Synthesize an empty session in-memory — tasks are fresh starts; needed data
+        // must come through action params, not session state.
+        connection.session = {
+          id: `task:${connection.id}`,
+          cookieName: config.session.cookieName,
+          createdAt: Date.now(),
+          data: {},
+        };
+        connection.sessionLoaded = true;
+
         const fanOutId = plainParams._fanOutId as string | undefined;
 
         let response: Awaited<ReturnType<(typeof action)["run"]>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "keryx",
-  "version": "0.21.9",
+  "version": "0.22.0",
   "module": "index.ts",
   "type": "module",
   "license": "MIT",

package/templates/scaffold/middleware-session.ts.mustache

@@ -3,7 +3,7 @@ import type { ActionMiddleware } from "keryx/classes/Action.ts";
 
 export const SessionMiddleware: ActionMiddleware = {
   runBefore: async (_params, connection: Connection<{ userId?: number }>) => {
-    if (!connection.session || !connection.session.data.userId) {
+    if (!connection.session?.data.userId) {
       throw new TypedError({
         message: "Session not found",
         type: ErrorType.CONNECTION_SESSION_NOT_FOUND,