@pristine-ts/networking 2.0.2 → 2.0.3

package/dist/types/contexts/contexts.d.ts

@@ -0,0 +1 @@
+export * from "./request-context";

package/dist/types/contexts/request-context.d.ts

@@ -0,0 +1,24 @@
+import { IdentityInterface, Request } from "@pristine-ts/common";
+import { MethodRouterNode } from "../nodes/method-router.node";
+/**
+ * Per-HTTP-request state, scoped to the lifetime of one routed request. Layered
+ * **inside** the framework's `EventContext` (which holds `eventId`/`traceId`/`container`):
+ * a controller method running inside an HTTP request can read both the EventContext
+ * primitives and these networking-specific slots.
+ *
+ * Owned by `@pristine-ts/networking`. Apps that don't import the networking module
+ * never see this type — `Request`, `MethodRouterNode`, and `IdentityInterface` are
+ * concerns of HTTP-shaped flows, not of the framework as a whole.
+ *
+ * Populated incrementally as the router progresses through the request lifecycle:
+ *   - `request` is set the moment the context is installed (route matching has
+ *     succeeded by then; a 404 short-circuits before installation).
+ *   - `methodNode` is set immediately after request (always together).
+ *   - `identity` fills in once the authentication pipeline runs. Until then,
+ *     downstream code that reads `identity` from the context sees `undefined`.
+ */
+export declare class RequestContext {
+    request: Request;
+    methodNode?: MethodRouterNode;
+    identity?: IdentityInterface;
+}

package/dist/types/managers/managers.d.ts

@@ -0,0 +1 @@
+export * from "./request-context.manager";

package/dist/types/managers/request-context.manager.d.ts

@@ -0,0 +1,43 @@
+import { IdentityInterface, Request } from "@pristine-ts/common";
+import { RequestContext } from "../contexts/request-context";
+import { MethodRouterNode } from "../nodes/method-router.node";
+/**
+ * Owns the `AsyncLocalStorage` instance that propagates the active `RequestContext`
+ * across `await` boundaries for HTTP-routed code.
+ *
+ * Nested inside the framework's `EventContext`: when the router installs a
+ * `RequestContext`, the surrounding `EventContext` (`eventId`/`traceId`/`container`)
+ * is still active, so application code inside a controller method can read both.
+ *
+ * Same shape as `EventContextManager` — `run` + read accessors + static convenience
+ * mirrors + `bind` for the background-work escape hatch.
+ *
+ * Application code outside the networking module never sees this manager. Code inside
+ * the networking module uses it to look up the active request without threading it
+ * through every method parameter.
+ */
+export declare class RequestContextManager {
+    private static readonly als;
+    run<T>(ctx: RequestContext, fn: () => T): T;
+    run<T>(ctx: RequestContext, fn: () => Promise<T>): Promise<T>;
+    current(): RequestContext | undefined;
+    request(): Request | undefined;
+    methodNode(): MethodRouterNode | undefined;
+    identity(): IdentityInterface | undefined;
+    /**
+     * Convenience alias for `EventContextManager.eventId()`. The framework's correlation
+     * id (`eventId`) is the same value HTTP people often call "request id" — exposing it
+     * here as `requestId()` makes it discoverable next to `request()` / `identity()`
+     * without duplicating storage. There is no `RequestContext.requestId` field — the
+     * canonical slot lives on `EventContext` and we delegate at lookup time, so the two
+     * values can never drift.
+     */
+    requestId(): string | undefined;
+    bind<F extends (...args: any[]) => any>(fn: F): F;
+    static current(): RequestContext | undefined;
+    static request(): Request | undefined;
+    static methodNode(): MethodRouterNode | undefined;
+    static identity(): IdentityInterface | undefined;
+    static requestId(): string | undefined;
+    static bind<F extends (...args: any[]) => any>(fn: F): F;
+}

package/dist/types/networking.module.d.ts

@@ -1,11 +1,13 @@
 import { ModuleInterface } from "@pristine-ts/common";
 export * from "./cache/cache";
+export * from "./contexts/contexts";
 export * from "./decorators/decorators";
 export * from "./enums/enums";
 export * from "./errors/errors";
 export * from "./handlers/handlers";
 export * from "./interceptors/interceptors";
 export * from "./interfaces/interfaces";
+export * from "./managers/managers";
 export * from "./mappers/mappers";
 export * from "./models/models";
 export * from "./nodes/nodes";

package/dist/types/router.d.ts

@@ -7,6 +7,7 @@ import { HttpMethod, Request, Response } from "@pristine-ts/common";
 import { LogHandlerInterface } from "@pristine-ts/logging";
 import { AuthenticationManagerInterface, AuthorizerManagerInterface } from "@pristine-ts/security";
 import { RouterCache } from "./cache/router.cache";
+import { RequestContextManager } from "./managers/request-context.manager";
 /**
  * The router service is the service that creates the routing tree from the controllers.
  * It also executes a request properly by routing it to the intended controller and returns the response.
@@ -17,6 +18,7 @@ export declare class Router implements RouterInterface {
     private readonly authorizerManager;
     private readonly authenticationManager;
     private readonly cache;
+    private readonly requestContextManager;
     private root;
     private setupCompleted;
     /**
@@ -28,7 +30,7 @@ export declare class Router implements RouterInterface {
      * @param authorizerManager The authorizer manager to validate authorization.
      * @param authenticationManager The authentication manager to validate authentication.
      */
-    constructor(loghandler: LogHandlerInterface, controllerMethodParameterDecoratorResolver: ControllerMethodParameterDecoratorResolver, authorizerManager: AuthorizerManagerInterface, authenticationManager: AuthenticationManagerInterface, cache: RouterCache);
+    constructor(loghandler: LogHandlerInterface, controllerMethodParameterDecoratorResolver: ControllerMethodParameterDecoratorResolver, authorizerManager: AuthorizerManagerInterface, authenticationManager: AuthenticationManagerInterface, cache: RouterCache, requestContextManager: RequestContextManager);
     /**
      * This method returns the whole route tree as a string.
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pristine-ts/networking",
-  "version": "2.0.2",
+  "version": "2.0.3",
   "description": "",
   "module": "dist/lib/esm/networking.module.js",
   "main": "dist/lib/cjs/networking.module.js",
@@ -20,12 +20,12 @@
     "access": "public"
   },
   "dependencies": {
-    "@pristine-ts/common": "^2.0.2",
-    "@pristine-ts/core": "^2.0.2",
-    "@pristine-ts/data-mapping": "^2.0.2",
+    "@pristine-ts/common": "^2.0.3",
+    "@pristine-ts/core": "^2.0.3",
+    "@pristine-ts/data-mapping": "^2.0.3",
     "@pristine-ts/metadata": "^1.0.16",
-    "@pristine-ts/security": "^2.0.2",
-    "@pristine-ts/telemetry": "^2.0.2",
+    "@pristine-ts/security": "^2.0.3",
+    "@pristine-ts/telemetry": "^2.0.3",
     "lodash": "^4.17.21"
   },
   "jest": {
@@ -62,7 +62,7 @@
       "src/*.{js,ts}"
     ]
   },
-  "gitHead": "b0899c7eb6b34a99c6df0739507b1458549a0009",
+  "gitHead": "c741bb430ab8f6286068dc3870fcadf4cefd0023",
   "repository": {
     "type": "git",
     "url": "https://github.com/magieno/pristine-ts.git",