@webpieces/http-routing 0.4.664 → 0.4.666

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webpieces/http-routing",
-  "version": "0.4.664",
+  "version": "0.4.666",
   "description": "Decorator-based routing with auto-wiring for WebPieces",
   "type": "commonjs",
   "main": "./src/index.js",
@@ -22,9 +22,9 @@
   },
   "dependencies": {
     "@inversifyjs/binding-decorators": "1.1.5",
-    "@webpieces/core-context": "0.4.664",
-    "@webpieces/core-util": "0.4.664",
-    "@webpieces/gcp-identity": "0.4.664",
+    "@webpieces/core-context": "0.4.666",
+    "@webpieces/core-util": "0.4.666",
+    "@webpieces/gcp-identity": "0.4.666",
     "inversify": "7.10.4",
     "jsonwebtoken": "9.0.2",
     "minimatch": "10.0.1"

package/src/AuthConfig.d.ts

@@ -1,4 +1,4 @@
-import { ContextTuple } from '@webpieces/core-util';
+import { ContextKey, ContextTuple } from '@webpieces/core-util';
 /**
  * SharedSecrets - the accepted values for ONE `@AuthSharedSecret(name)`. BOTH secret1 AND secret2
  * are accepted — this is what makes zero-downtime ROTATION possible:
@@ -15,19 +15,48 @@ export declare class SharedSecrets {
     constructor(secret1: string, secret2: string);
 }
 /**
- * AuthValues - what {@link JwtHook.parseJwt} and {@link ApiKeyHook.verifyApiKey} resolve to (both are
- * async): the authenticated caller's id + roles (used
- * by the framework to stamp a principal and enforce @AuthJwt({roles: [...]})) plus any extra context
- * entries the app wants set (orgId, tenant, ...). The framework sets `entries` into RequestContext
- * via {@link RequestContext.putTrusted}. Data-only structure (a class, per the guidelines).
+ * AuthenticatedCaller - what an authenticator PROVED about the caller of ONE request. Every hook
+ * that authenticates resolves to this: {@link JwtHook.parseJwt}, {@link ApiKeyHook.verifyApiKey} and
+ * {@link WebhookAuthCallback.verifyWebhook}. Four fields, three jobs:
+ *
+ *  - `userId`          — WHO the caller is, as the credential proved it.
+ *  - `roles` / `claims` — the AUTHORIZATION inputs: `roles` is what the framework's own any-of check
+ *                        reads, `claims` is the raw payload an app's {@link JwtHook.authorizeJwt}
+ *                        override reads for app-defined requirements (inOrg, tenant, ...).
+ *  - `entries`         — the TRUSTED CONTEXT to seed. The framework writes each one with
+ *                        {@link RequestContext.putTrusted}, so return only what THIS authenticator
+ *                        derived from the credential it just verified.
+ *
+ * NAMING, said out loud so it is not "fixed" back: it is deliberately NOT a `TrustedContextMap`.
+ * Three of the four fields are not context, and it is not a Map — it is the authenticated caller,
+ * and the context is one thing it carries.
+ *
+ * Data-only structure (a class, per the guidelines).
  */
-export declare class AuthValues {
+export declare class AuthenticatedCaller {
     readonly userId: string;
     readonly roles: string[];
     readonly entries: ContextTuple[];
     readonly claims: Record<string, unknown>;
     constructor(userId: string, roles?: string[], entries?: ContextTuple[], claims?: Record<string, unknown>);
 }
+/**
+ * The context slot holding the {@link AuthenticatedCaller} the framework {@link AuthFilter} resolved
+ * for this request. A real TRUSTED {@link ContextKey}, written with `RequestContext.putTrusted` and
+ * read with `RequestContext.getTrusted` — it replaces a raw `'__webpieces_principal__'` string that
+ * was the one place in the codebase bypassing the typed context layer.
+ *
+ * `httpHeader` is deliberately UNDEFINED, so the key is context-only and NEVER travels. Two reasons,
+ * and either alone is decisive: the value is an OBJECT, which no HTTP header can carry; and a
+ * principal is proof THIS hop's authenticator produced, so forwarding it would hand the next service
+ * a "proven" caller nothing on that hop verified. The individual facts a downstream service needs
+ * (userId, orgId, roles) already propagate as their own transferred keys in
+ * {@link WebpiecesCoreHeaders}, gated by the caller-verified rule.
+ *
+ * `isLogged` is FALSE: it is an object carrying the raw credential claims, which has no business
+ * being serialized into a log line.
+ */
+export declare const AUTHENTICATED_CALLER_KEY: ContextKey<AuthenticatedCaller, "trusted">;
 /**
  * AuthConfig - the app-provided SHARED-SECRET state the framework {@link AuthFilter} reads to
  * enforce `@AuthSharedSecret(name)` endpoints. It holds ONLY the accepted secret values (STATE) —

package/src/AuthConfig.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AUTH_CONFIG = exports.AuthConfig = exports.AuthValues = exports.SharedSecrets = void 0;
+exports.AUTH_CONFIG = exports.AuthConfig = exports.AUTHENTICATED_CALLER_KEY = exports.AuthenticatedCaller = exports.SharedSecrets = void 0;
+const core_util_1 = require("@webpieces/core-util");
 /**
  * SharedSecrets - the accepted values for ONE `@AuthSharedSecret(name)`. BOTH secret1 AND secret2
  * are accepted — this is what makes zero-downtime ROTATION possible:
@@ -21,13 +22,25 @@ class SharedSecrets {
 }
 exports.SharedSecrets = SharedSecrets;
 /**
- * AuthValues - what {@link JwtHook.parseJwt} and {@link ApiKeyHook.verifyApiKey} resolve to (both are
- * async): the authenticated caller's id + roles (used
- * by the framework to stamp a principal and enforce @AuthJwt({roles: [...]})) plus any extra context
- * entries the app wants set (orgId, tenant, ...). The framework sets `entries` into RequestContext
- * via {@link RequestContext.putTrusted}. Data-only structure (a class, per the guidelines).
+ * AuthenticatedCaller - what an authenticator PROVED about the caller of ONE request. Every hook
+ * that authenticates resolves to this: {@link JwtHook.parseJwt}, {@link ApiKeyHook.verifyApiKey} and
+ * {@link WebhookAuthCallback.verifyWebhook}. Four fields, three jobs:
+ *
+ *  - `userId`          — WHO the caller is, as the credential proved it.
+ *  - `roles` / `claims` — the AUTHORIZATION inputs: `roles` is what the framework's own any-of check
+ *                        reads, `claims` is the raw payload an app's {@link JwtHook.authorizeJwt}
+ *                        override reads for app-defined requirements (inOrg, tenant, ...).
+ *  - `entries`         — the TRUSTED CONTEXT to seed. The framework writes each one with
+ *                        {@link RequestContext.putTrusted}, so return only what THIS authenticator
+ *                        derived from the credential it just verified.
+ *
+ * NAMING, said out loud so it is not "fixed" back: it is deliberately NOT a `TrustedContextMap`.
+ * Three of the four fields are not context, and it is not a Map — it is the authenticated caller,
+ * and the context is one thing it carries.
+ *
+ * Data-only structure (a class, per the guidelines).
  */
-class AuthValues {
+class AuthenticatedCaller {
     userId;
     roles;
     entries;
@@ -41,7 +54,27 @@ class AuthValues {
         this.claims = claims;
     }
 }
-exports.AuthValues = AuthValues;
+exports.AuthenticatedCaller = AuthenticatedCaller;
+/**
+ * The context slot holding the {@link AuthenticatedCaller} the framework {@link AuthFilter} resolved
+ * for this request. A real TRUSTED {@link ContextKey}, written with `RequestContext.putTrusted` and
+ * read with `RequestContext.getTrusted` — it replaces a raw `'__webpieces_principal__'` string that
+ * was the one place in the codebase bypassing the typed context layer.
+ *
+ * `httpHeader` is deliberately UNDEFINED, so the key is context-only and NEVER travels. Two reasons,
+ * and either alone is decisive: the value is an OBJECT, which no HTTP header can carry; and a
+ * principal is proof THIS hop's authenticator produced, so forwarding it would hand the next service
+ * a "proven" caller nothing on that hop verified. The individual facts a downstream service needs
+ * (userId, orgId, roles) already propagate as their own transferred keys in
+ * {@link WebpiecesCoreHeaders}, gated by the caller-verified rule.
+ *
+ * `isLogged` is FALSE: it is an object carrying the raw credential claims, which has no business
+ * being serialized into a log line.
+ */
+exports.AUTHENTICATED_CALLER_KEY = core_util_1.ContextKey.trusted('authenticatedCaller', 'resolved by the framework AuthFilter from a credential an app-bound JwtHook, ApiKeyHook or WebhookAuthCallback verified', 
+/*httpHeader*/ undefined, 
+/*maskInLogs*/ false, 
+/*isLogged*/ false);
 /**
  * AuthConfig - the app-provided SHARED-SECRET state the framework {@link AuthFilter} reads to
  * enforce `@AuthSharedSecret(name)` endpoints. It holds ONLY the accepted secret values (STATE) —

package/src/AuthConfig.js.map

@@ -1 +1 @@
-{"version":3,"file":"AuthConfig.js","sourceRoot":"","sources":["../../../../../packages/http/http-routing/src/AuthConfig.ts"],"names":[],"mappings":";;;AAEA;;;;;;;;;GASG;AACH,MAAa,aAAa;IAEF;IACA;IAFpB,YACoB,OAAe,EACf,OAAe;QADf,YAAO,GAAP,OAAO,CAAQ;QACf,YAAO,GAAP,OAAO,CAAQ;IAChC,CAAC;CACP;AALD,sCAKC;AAED;;;;;;GAMG;AACH,MAAa,UAAU;IAEC;IACA;IACA;IAEA;IALpB,YACoB,MAAc,EACd,QAAkB,EAAE,EACpB,UAA0B,EAAE;IAC5C,wGAAwG;IACxF,SAAkC,EAAE;QAJpC,WAAM,GAAN,MAAM,CAAQ;QACd,UAAK,GAAL,KAAK,CAAe;QACpB,YAAO,GAAP,OAAO,CAAqB;QAE5B,WAAM,GAAN,MAAM,CAA8B;IACrD,CAAC;CACP;AARD,gCAQC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAa,UAAU;IACnB,wGAAwG;IAC/F,aAAa,CAAgC;IAEtD,YAAY,gBAA+C,EAAE;QACzD,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC;IACvC,CAAC;CACJ;AAPD,gCAOC;AAED;;;;GAIG;AACH,mNAAmN;AACtM,QAAA,WAAW,GAAG,MAAM,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC","sourcesContent":["import { ContextTuple } from '@webpieces/core-util';\n\n/**\n * SharedSecrets - the accepted values for ONE `@AuthSharedSecret(name)`. BOTH secret1 AND secret2\n * are accepted — this is what makes zero-downtime ROTATION possible:\n *\n *   to rotate: shift secret2 → secret1, and put the NEW secret in secret2. Callers cut over from\n *   the old value to the new during the window; once every caller sends the new one, the stale\n *   value falls out on the next shift. At all times EITHER key works, so no request is dropped.\n *\n * Data-only structure (a class, per the guidelines). Leave secret2 empty for a single secret.\n */\nexport class SharedSecrets {\n    constructor(\n        public readonly secret1: string,\n        public readonly secret2: string,\n    ) {}\n}\n\n/**\n * AuthValues - what {@link JwtHook.parseJwt} and {@link ApiKeyHook.verifyApiKey} resolve to (both are\n * async): the authenticated caller's id + roles (used\n * by the framework to stamp a principal and enforce @AuthJwt({roles: [...]})) plus any extra context\n * entries the app wants set (orgId, tenant, ...). The framework sets `entries` into RequestContext\n * via {@link RequestContext.putTrusted}. Data-only structure (a class, per the guidelines).\n */\nexport class AuthValues {\n    constructor(\n        public readonly userId: string,\n        public readonly roles: string[] = [],\n        public readonly entries: ContextTuple[] = [],\n        // webpieces-disable no-any-unknown -- raw JWT claims for app-defined authorization (inOrg, tenant, ...)\n        public readonly claims: Record<string, unknown> = {},\n    ) {}\n}\n\n/**\n * AuthConfig - the app-provided SHARED-SECRET state the framework {@link AuthFilter} reads to\n * enforce `@AuthSharedSecret(name)` endpoints. It holds ONLY the accepted secret values (STATE) —\n * there is no verification code here. The verification MECHANISMS are separate optional hooks the\n * app binds when it needs them:\n *\n *  - user JWT  → bind a {@link JwtHook} (async parseJwt + async authorizeJwt).\n *  - api key   → bind an {@link ApiKeyHook} (async verifyApiKey over the request's headers).\n *  - OIDC      → bind an {@link OidcHook} to override the framework's default verifier; a server that\n *                binds nothing still verifies Google OIDC via the built-in {@link DefaultOidcVerifier}.\n *\n * So a zero-wiring server accepts service-to-service OIDC out of the box, and an app only binds the\n * pieces it actually uses. This class is injected `@optional` into AuthFilter (rebindable in tests);\n * when unbound, shared-secret endpoints simply have no accepted secret and fail fast (401).\n */\nexport class AuthConfig {\n    /** Accepted shared-secret values keyed by `@AuthSharedSecret(name)`. DEFAULT empty — pass to enable. */\n    readonly sharedSecrets: Record<string, SharedSecrets>;\n\n    constructor(sharedSecrets: Record<string, SharedSecrets> = {}) {\n        this.sharedSecrets = sharedSecrets;\n    }\n}\n\n/**\n * DI identifier for the optional {@link AuthConfig} binding. It is a Symbol (not the class) so the app\n * container's inversify autobind never auto-constructs this token, keeping `@optional() @inject(AUTH_CONFIG)`\n * correct — undefined when unbound. The AuthConfig class stays the TYPE and the impl base.\n */\n// webpieces-disable no-symbol-di-tokens -- optional DI token: must be a Symbol so the app container's autobind never auto-constructs this token, keeping @optional() @inject(...) correct (undefined when unbound)\nexport const AUTH_CONFIG = Symbol.for('AuthConfig');\n"]}
+{"version":3,"file":"AuthConfig.js","sourceRoot":"","sources":["../../../../../packages/http/http-routing/src/AuthConfig.ts"],"names":[],"mappings":";;;AAAA,oDAAgE;AAEhE;;;;;;;;;GASG;AACH,MAAa,aAAa;IAEF;IACA;IAFpB,YACoB,OAAe,EACf,OAAe;QADf,YAAO,GAAP,OAAO,CAAQ;QACf,YAAO,GAAP,OAAO,CAAQ;IAChC,CAAC;CACP;AALD,sCAKC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAa,mBAAmB;IAER;IACA;IACA;IAEA;IALpB,YACoB,MAAc,EACd,QAAkB,EAAE,EACpB,UAA0B,EAAE;IAC5C,wGAAwG;IACxF,SAAkC,EAAE;QAJpC,WAAM,GAAN,MAAM,CAAQ;QACd,UAAK,GAAL,KAAK,CAAe;QACpB,YAAO,GAAP,OAAO,CAAqB;QAE5B,WAAM,GAAN,MAAM,CAA8B;IACrD,CAAC;CACP;AARD,kDAQC;AAED;;;;;;;;;;;;;;;GAeG;AACU,QAAA,wBAAwB,GAAG,sBAAU,CAAC,OAAO,CACtD,qBAAqB,EACrB,yHAAyH;AACzH,cAAc,CAAC,SAAS;AACxB,cAAc,CAAC,KAAK;AACpB,YAAY,CAAC,KAAK,CACrB,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,MAAa,UAAU;IACnB,wGAAwG;IAC/F,aAAa,CAAgC;IAEtD,YAAY,gBAA+C,EAAE;QACzD,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC;IACvC,CAAC;CACJ;AAPD,gCAOC;AAED;;;;GAIG;AACH,mNAAmN;AACtM,QAAA,WAAW,GAAG,MAAM,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC","sourcesContent":["import { ContextKey, ContextTuple } from '@webpieces/core-util';\n\n/**\n * SharedSecrets - the accepted values for ONE `@AuthSharedSecret(name)`. BOTH secret1 AND secret2\n * are accepted — this is what makes zero-downtime ROTATION possible:\n *\n *   to rotate: shift secret2 → secret1, and put the NEW secret in secret2. Callers cut over from\n *   the old value to the new during the window; once every caller sends the new one, the stale\n *   value falls out on the next shift. At all times EITHER key works, so no request is dropped.\n *\n * Data-only structure (a class, per the guidelines). Leave secret2 empty for a single secret.\n */\nexport class SharedSecrets {\n    constructor(\n        public readonly secret1: string,\n        public readonly secret2: string,\n    ) {}\n}\n\n/**\n * AuthenticatedCaller - what an authenticator PROVED about the caller of ONE request. Every hook\n * that authenticates resolves to this: {@link JwtHook.parseJwt}, {@link ApiKeyHook.verifyApiKey} and\n * {@link WebhookAuthCallback.verifyWebhook}. Four fields, three jobs:\n *\n *  - `userId`          — WHO the caller is, as the credential proved it.\n *  - `roles` / `claims` — the AUTHORIZATION inputs: `roles` is what the framework's own any-of check\n *                        reads, `claims` is the raw payload an app's {@link JwtHook.authorizeJwt}\n *                        override reads for app-defined requirements (inOrg, tenant, ...).\n *  - `entries`         — the TRUSTED CONTEXT to seed. The framework writes each one with\n *                        {@link RequestContext.putTrusted}, so return only what THIS authenticator\n *                        derived from the credential it just verified.\n *\n * NAMING, said out loud so it is not \"fixed\" back: it is deliberately NOT a `TrustedContextMap`.\n * Three of the four fields are not context, and it is not a Map — it is the authenticated caller,\n * and the context is one thing it carries.\n *\n * Data-only structure (a class, per the guidelines).\n */\nexport class AuthenticatedCaller {\n    constructor(\n        public readonly userId: string,\n        public readonly roles: string[] = [],\n        public readonly entries: ContextTuple[] = [],\n        // webpieces-disable no-any-unknown -- raw JWT claims for app-defined authorization (inOrg, tenant, ...)\n        public readonly claims: Record<string, unknown> = {},\n    ) {}\n}\n\n/**\n * The context slot holding the {@link AuthenticatedCaller} the framework {@link AuthFilter} resolved\n * for this request. A real TRUSTED {@link ContextKey}, written with `RequestContext.putTrusted` and\n * read with `RequestContext.getTrusted` — it replaces a raw `'__webpieces_principal__'` string that\n * was the one place in the codebase bypassing the typed context layer.\n *\n * `httpHeader` is deliberately UNDEFINED, so the key is context-only and NEVER travels. Two reasons,\n * and either alone is decisive: the value is an OBJECT, which no HTTP header can carry; and a\n * principal is proof THIS hop's authenticator produced, so forwarding it would hand the next service\n * a \"proven\" caller nothing on that hop verified. The individual facts a downstream service needs\n * (userId, orgId, roles) already propagate as their own transferred keys in\n * {@link WebpiecesCoreHeaders}, gated by the caller-verified rule.\n *\n * `isLogged` is FALSE: it is an object carrying the raw credential claims, which has no business\n * being serialized into a log line.\n */\nexport const AUTHENTICATED_CALLER_KEY = ContextKey.trusted<AuthenticatedCaller>(\n    'authenticatedCaller',\n    'resolved by the framework AuthFilter from a credential an app-bound JwtHook, ApiKeyHook or WebhookAuthCallback verified',\n    /*httpHeader*/ undefined,\n    /*maskInLogs*/ false,\n    /*isLogged*/ false,\n);\n\n/**\n * AuthConfig - the app-provided SHARED-SECRET state the framework {@link AuthFilter} reads to\n * enforce `@AuthSharedSecret(name)` endpoints. It holds ONLY the accepted secret values (STATE) —\n * there is no verification code here. The verification MECHANISMS are separate optional hooks the\n * app binds when it needs them:\n *\n *  - user JWT  → bind a {@link JwtHook} (async parseJwt + async authorizeJwt).\n *  - api key   → bind an {@link ApiKeyHook} (async verifyApiKey over the request's headers).\n *  - OIDC      → bind an {@link OidcHook} to override the framework's default verifier; a server that\n *                binds nothing still verifies Google OIDC via the built-in {@link DefaultOidcVerifier}.\n *\n * So a zero-wiring server accepts service-to-service OIDC out of the box, and an app only binds the\n * pieces it actually uses. This class is injected `@optional` into AuthFilter (rebindable in tests);\n * when unbound, shared-secret endpoints simply have no accepted secret and fail fast (401).\n */\nexport class AuthConfig {\n    /** Accepted shared-secret values keyed by `@AuthSharedSecret(name)`. DEFAULT empty — pass to enable. */\n    readonly sharedSecrets: Record<string, SharedSecrets>;\n\n    constructor(sharedSecrets: Record<string, SharedSecrets> = {}) {\n        this.sharedSecrets = sharedSecrets;\n    }\n}\n\n/**\n * DI identifier for the optional {@link AuthConfig} binding. It is a Symbol (not the class) so the app\n * container's inversify autobind never auto-constructs this token, keeping `@optional() @inject(AUTH_CONFIG)`\n * correct — undefined when unbound. The AuthConfig class stays the TYPE and the impl base.\n */\n// webpieces-disable no-symbol-di-tokens -- optional DI token: must be a Symbol so the app container's autobind never auto-constructs this token, keeping @optional() @inject(...) correct (undefined when unbound)\nexport const AUTH_CONFIG = Symbol.for('AuthConfig');\n"]}

package/src/AuthHooks.d.ts

@@ -1,6 +1,6 @@
 import { JwtRequirement } from '@webpieces/core-util';
-import { HttpRequest, RawRequest } from '@webpieces/core-context';
-import { AuthValues } from './AuthConfig';
+import { HttpRequest, RawHttpRequest } from '@webpieces/core-context';
+import { AuthenticatedCaller } from './AuthConfig';
 /**
  * JwtHook - the OPTIONAL user-JWT mechanism. Its DI token is the {@link JWT_HOOK} Symbol injected via
  * `@inject(JWT_HOOK)` (a Symbol, because the app container uses autobind; rebindable in tests). Bind one
@@ -8,7 +8,7 @@ import { AuthValues } from './AuthConfig';
  * {@link AuthFilter} treats every jwt endpoint as "not enabled" and fails fast (401) — there is no
  * default JWT verification because it needs an app secret + payload shape the framework can't guess.
  *
- *  - `parseJwt`     — AUTHENTICATION: decode/verify a user JWT into {@link AuthValues}, or throw. The
+ *  - `parseJwt`     — AUTHENTICATION: decode/verify a user JWT into {@link AuthenticatedCaller}, or throw. The
  *                     app owns the strategy (HS256 secret, RS256 + JWKS, a provider SDK, ...).
  *  - `authorizeJwt` — AUTHORIZATION: check the authenticated user against the endpoint's
  *                     {@link JwtRequirement}. The DEFAULT enforces the roles any-of; override for
@@ -20,7 +20,7 @@ import { AuthValues } from './AuthConfig';
  * reaches the network. `parseJwt` may fetch a JWKS or call a provider SDK; `authorizeJwt`'s own
  * motivating example — `@AuthJwt({allRolesAllowed: true, inOrg: true})` — is a membership question a
  * real app answers from a datastore. A sync signature makes both of those unwritable, and it made
- * `JwtHook` the last sync hook: {@link OidcHook.verifyOidc}, {@link WebhookAuthCallback.verify} and
+ * `JwtHook` the last sync hook: {@link OidcHook.verifyOidc}, {@link WebhookAuthCallback.verifyWebhook} and
  * {@link ApiKeyHook.verifyApiKey} all return promises. An implementation that needs no I/O simply has
  * no `await` in its body — {@link DefaultJwtHook} is exactly that and pays nothing for it.
  */
@@ -28,14 +28,23 @@ export declare abstract class JwtHook {
     /**
      * Parse a user JWT (kind:'jwt') — AUTHENTICATION only. Return who the user is, or throw.
      * ASYNC so an app can reach a JWKS endpoint or a provider SDK; see the class doc.
+     *
+     * IT TAKES THE TOKEN, NOT THE REQUEST — the one deliberate asymmetry among the four hooks, and
+     * NOT an oversight to be "fixed". {@link ApiKeyHook.verifyApiKey} and
+     * {@link WebhookAuthCallback.verifyWebhook} take the whole {@link HttpRequest} because their
+     * credential regime is the APP's: which headers carry an api key, and how a vendor signs, are
+     * things the framework cannot know. A user JWT is different — the framework owns the
+     * `Authorization: Bearer` scheme and has already extracted the token from it. Widening this to
+     * the request would only invite a JwtHook to authenticate off some OTHER header, which is a
+     * second, ungoverned credential path on the mode that guards browser traffic.
      */
-    abstract parseJwt(token: string): Promise<AuthValues>;
+    abstract parseJwt(token: string): Promise<AuthenticatedCaller>;
     /**
      * DEFAULT authorization: enforce the endpoint's roles (any-of). Override to enforce app-defined
      * requirements. Throw HttpForbiddenError to deny; return to allow. ASYNC so an app-defined
      * requirement can be answered from a datastore; see the class doc.
      */
-    authorizeJwt(values: AuthValues, requirement: JwtRequirement): Promise<void>;
+    authorizeJwt(caller: AuthenticatedCaller, requirement: JwtRequirement): Promise<void>;
 }
 /**
  * DI identifier for the optional {@link JwtHook} binding. It is a Symbol (not the class) so the app
@@ -81,20 +90,32 @@ export declare const OIDC_HOOK: unique symbol;
  *
  * ONE hook serves EVERY vendor: `name` selects which, so an app with a Sentry hook and a Twilio hook
  * switches on it rather than binding a token per vendor. What arrives is enough of the raw request to
- * call the vendor's OWN validator — the bytes for a body-signing vendor (Sentry, GitHub, Stripe,
- * Slack), the absolute url for one that signs the url instead (Twilio).
+ * call the vendor's OWN validator — `request.raw.rawBody` for a body-signing vendor (Sentry, GitHub,
+ * Stripe, Slack), `request.raw.absoluteUrl` for one that signs the url instead (Twilio).
  */
 export declare abstract class WebhookAuthCallback {
     /**
-     * Verify ONE inbound request. Return to allow; throw {@link HttpUnauthorizedError} to deny.
+     * Verify ONE inbound request. Return the {@link AuthenticatedCaller} the vendor's signature
+     * proved; throw {@link HttpUnauthorizedError} to deny.
+     *
+     * IT RETURNS A CALLER, not `void`, for the same reason {@link ApiKeyHook.verifyApiKey} does: once
+     * the signature checks out, the payload's vendor account is a PROVEN fact, and a hook that could
+     * only return `void` had no way to say so. The framework seeds `entries` with
+     * `RequestContext.putTrusted` exactly as it does for a jwt or api-key caller, so a controller
+     * reads which vendor account this webhook is for off the context instead of re-deriving it.
      *
-     * @param name   the string on the contract's `@AuthWebhook(name)` — which vendor this route is.
-     * @param request the transport-neutral request (method, path, headers).
-     * @param raw    the verbatim bytes + absolute url, guaranteed present: `@AuthWebhook` requires
-     *               `@Endpoint(..., { rawBody: true })` at wiring time, and AuthFilter 401s rather
-     *               than calling this hook with nothing to check.
+     * Return only what THIS hook proved from the signature it just verified. `webhook` remains
+     * caller-NOT-verified (see `AuthFilter.verifiesCaller`): a vendor is not a peer service, so
+     * nothing the vendor merely ASSERTED on the wire is admitted.
+     *
+     * @param name    the string on the contract's `@AuthWebhook(name)` — which vendor this route is.
+     * @param request the transport-neutral request, narrowed to {@link RawHttpRequest}: `request.raw`
+     *                holds the verbatim bytes + absolute url and is PRESENT, never optional.
+     *                `@AuthWebhook` requires `@Endpoint(..., { rawBody: true })` at wiring time, and
+     *                AuthFilter 401s rather than calling this hook with nothing to check — so an
+     *                implementation never writes `raw!` or a guard of its own.
      */
-    abstract verify(name: string, request: HttpRequest, raw: RawRequest): Promise<void>;
+    abstract verifyWebhook(name: string, request: RawHttpRequest): Promise<AuthenticatedCaller>;
 }
 /**
  * DI identifier for the optional {@link WebhookAuthCallback} binding. It is a Symbol (not the class) so the app
@@ -102,21 +123,6 @@ export declare abstract class WebhookAuthCallback {
  * correct — undefined when unbound. The WebhookAuthCallback class stays the TYPE and the impl base.
  */
 export declare const WEBHOOK_AUTH_CALLBACK: unique symbol;
-/**
- * HeaderReader - read-only access to the inbound request's headers, and the ONLY thing an
- * {@link ApiKeyHook} is handed besides the regime name.
- *
- * It is an INTERFACE, not a class, because it is behaviour rather than data (per the guidelines) —
- * and it is NARROWER than {@link HttpRequest} on purpose. An api-key hook's job is to read the
- * credential headers and look them up; giving it the whole request would also give it the retained
- * raw bytes and the parsed body, none of which it has any business deciding authentication on.
- * `HttpRequest` satisfies this structurally, so the framework passes the live request and a spec can
- * pass a two-line stub.
- */
-export interface HeaderReader {
-    /** First value of the header, by lowercased name, or undefined when absent. */
-    getHeader(name: string): string | undefined;
-}
 /**
  * ApiKeyHook - the OPTIONAL mechanism behind `@AuthApiKey(name)`: authenticate a CUSTOMER-held api key
  * against the app's own datastore and return the context to seed. Its DI token is the
@@ -134,19 +140,20 @@ export interface HeaderReader {
  * one: the key regime lives in the app's datastore, under the app's hashing scheme, behind the app's
  * choice of header names.
  *
- * THE ONE THING THIS HAS THAT `JwtHook.parseJwt` DOES NOT: it receives a {@link HeaderReader}, not one
- * pre-extracted token. A real key regime validates the key TOGETHER WITH a second header — the
+ * THE ONE THING THIS HAS THAT `JwtHook.parseJwt` DOES NOT: it receives the whole {@link HttpRequest},
+ * not one pre-extracted token. A real key regime validates the key TOGETHER WITH a second header — the
  * organization the caller is acting for — and a hook handed one header's value physically cannot do
  * that cross-check. The framework therefore configures no api-key header name: which headers carry the
- * credential is the app's business. (Being ASYNC is no longer a difference — every hook here is, and
- * for the same reason: an app's strategy reaches the network.)
+ * credential is the app's business, and `getHeader` / `getHeaderValues` read as many as the regime
+ * needs. (Being ASYNC is no longer a difference — every hook here is, and for the same reason: an
+ * app's strategy reaches the network.)
  *
  * ONE hook serves EVERY regime: `name` selects which, so a server with a partner-api regime and an
  * internal-tooling regime switches on it rather than binding a token per regime.
  */
 export declare abstract class ApiKeyHook {
     /**
-     * AUTHENTICATE one inbound request. Return who the caller is plus the {@link AuthValues.entries}
+     * AUTHENTICATE one inbound request. Return who the caller is plus the {@link AuthenticatedCaller.entries}
      * the framework seeds into `RequestContext` via `putTrusted`, or throw
      * {@link HttpUnauthorizedError} to deny.
      *
@@ -156,9 +163,10 @@ export declare abstract class ApiKeyHook {
      * because a customer is not an internal service.
      *
      * @param name    the string on the contract's `@AuthApiKey(name)` — which key regime this route is.
-     * @param headers the inbound request's headers; read as many as the regime needs.
+     * @param request the inbound request; read as many headers as the regime needs with
+     *                `getHeader` / `getHeaderValues`, either by raw name or by {@link ContextKey}.
      */
-    abstract verifyApiKey(name: string, headers: HeaderReader): Promise<AuthValues>;
+    abstract verifyApiKey(name: string, request: HttpRequest): Promise<AuthenticatedCaller>;
 }
 /**
  * DI identifier for the optional {@link ApiKeyHook} binding. It is a Symbol (not the class) so the app

package/src/AuthHooks.js

@@ -9,7 +9,7 @@ const core_util_1 = require("@webpieces/core-util");
  * {@link AuthFilter} treats every jwt endpoint as "not enabled" and fails fast (401) — there is no
  * default JWT verification because it needs an app secret + payload shape the framework can't guess.
  *
- *  - `parseJwt`     — AUTHENTICATION: decode/verify a user JWT into {@link AuthValues}, or throw. The
+ *  - `parseJwt`     — AUTHENTICATION: decode/verify a user JWT into {@link AuthenticatedCaller}, or throw. The
  *                     app owns the strategy (HS256 secret, RS256 + JWKS, a provider SDK, ...).
  *  - `authorizeJwt` — AUTHORIZATION: check the authenticated user against the endpoint's
  *                     {@link JwtRequirement}. The DEFAULT enforces the roles any-of; override for
@@ -21,7 +21,7 @@ const core_util_1 = require("@webpieces/core-util");
  * reaches the network. `parseJwt` may fetch a JWKS or call a provider SDK; `authorizeJwt`'s own
  * motivating example — `@AuthJwt({allRolesAllowed: true, inOrg: true})` — is a membership question a
  * real app answers from a datastore. A sync signature makes both of those unwritable, and it made
- * `JwtHook` the last sync hook: {@link OidcHook.verifyOidc}, {@link WebhookAuthCallback.verify} and
+ * `JwtHook` the last sync hook: {@link OidcHook.verifyOidc}, {@link WebhookAuthCallback.verifyWebhook} and
  * {@link ApiKeyHook.verifyApiKey} all return promises. An implementation that needs no I/O simply has
  * no `await` in its body — {@link DefaultJwtHook} is exactly that and pays nothing for it.
  */
@@ -31,11 +31,11 @@ class JwtHook {
      * requirements. Throw HttpForbiddenError to deny; return to allow. ASYNC so an app-defined
      * requirement can be answered from a datastore; see the class doc.
      */
-    async authorizeJwt(values, requirement) {
+    async authorizeJwt(caller, requirement) {
         // rolesRequired is the ONE reader of the JwtRoles union: [] means the endpoint typed
         // `allRolesAllowed: true`, never "the field was missing" — that state no longer compiles.
         const roles = (0, core_util_1.rolesRequired)(requirement);
-        if (roles.length > 0 && !roles.some((role) => values.roles.includes(role))) {
+        if (roles.length > 0 && !roles.some((role) => caller.roles.includes(role))) {
             throw new core_util_1.HttpForbiddenError(`Endpoint requires one of roles: ${roles.join(', ')}`);
         }
     }
@@ -87,8 +87,8 @@ exports.OIDC_HOOK = Symbol.for('OidcHook');
  *
  * ONE hook serves EVERY vendor: `name` selects which, so an app with a Sentry hook and a Twilio hook
  * switches on it rather than binding a token per vendor. What arrives is enough of the raw request to
- * call the vendor's OWN validator — the bytes for a body-signing vendor (Sentry, GitHub, Stripe,
- * Slack), the absolute url for one that signs the url instead (Twilio).
+ * call the vendor's OWN validator — `request.raw.rawBody` for a body-signing vendor (Sentry, GitHub,
+ * Stripe, Slack), `request.raw.absoluteUrl` for one that signs the url instead (Twilio).
  */
 class WebhookAuthCallback {
 }
@@ -117,12 +117,13 @@ exports.WEBHOOK_AUTH_CALLBACK = Symbol.for('WebhookAuthCallback');
  * one: the key regime lives in the app's datastore, under the app's hashing scheme, behind the app's
  * choice of header names.
  *
- * THE ONE THING THIS HAS THAT `JwtHook.parseJwt` DOES NOT: it receives a {@link HeaderReader}, not one
- * pre-extracted token. A real key regime validates the key TOGETHER WITH a second header — the
+ * THE ONE THING THIS HAS THAT `JwtHook.parseJwt` DOES NOT: it receives the whole {@link HttpRequest},
+ * not one pre-extracted token. A real key regime validates the key TOGETHER WITH a second header — the
  * organization the caller is acting for — and a hook handed one header's value physically cannot do
  * that cross-check. The framework therefore configures no api-key header name: which headers carry the
- * credential is the app's business. (Being ASYNC is no longer a difference — every hook here is, and
- * for the same reason: an app's strategy reaches the network.)
+ * credential is the app's business, and `getHeader` / `getHeaderValues` read as many as the regime
+ * needs. (Being ASYNC is no longer a difference — every hook here is, and for the same reason: an
+ * app's strategy reaches the network.)
  *
  * ONE hook serves EVERY regime: `name` selects which, so a server with a partner-api regime and an
  * internal-tooling regime switches on it rather than binding a token per regime.

package/src/AuthHooks.js.map

@@ -1 +1 @@
-{"version":3,"file":"AuthHooks.js","sourceRoot":"","sources":["../../../../../packages/http/http-routing/src/AuthHooks.ts"],"names":[],"mappings":";;;AAAA,oDAAyF;AAIzF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAsB,OAAO;IAOzB;;;;OAIG;IACH,KAAK,CAAC,YAAY,CAAC,MAAkB,EAAE,WAA2B;QAC9D,qFAAqF;QACrF,0FAA0F;QAC1F,MAAM,KAAK,GAAG,IAAA,yBAAa,EAAC,WAAW,CAAC,CAAC;QACzC,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAY,EAAE,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC;YACjF,MAAM,IAAI,8BAAkB,CAAC,mCAAmC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACxF,CAAC;IACL,CAAC;CACJ;AApBD,0BAoBC;AAED;;;;GAIG;AACH,mNAAmN;AACtM,QAAA,QAAQ,GAAG,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;AAE9C;;;;;;;;;GASG;AACH,MAAsB,QAAQ;CAE7B;AAFD,4BAEC;AAED;;;;GAIG;AACH,mNAAmN;AACtM,QAAA,SAAS,GAAG,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAsB,mBAAmB;CAWxC;AAXD,kDAWC;AAED;;;;GAIG;AACH,mNAAmN;AACtM,QAAA,qBAAqB,GAAG,MAAM,CAAC,GAAG,CAAC,qBAAqB,CAAC,CAAC;AAkBvE;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAsB,UAAU;CAe/B;AAfD,gCAeC;AAED;;;;GAIG;AACH,mNAAmN;AACtM,QAAA,YAAY,GAAG,MAAM,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC","sourcesContent":["import { JwtRequirement, rolesRequired, HttpForbiddenError } from '@webpieces/core-util';\nimport { HttpRequest, RawRequest } from '@webpieces/core-context';\nimport { AuthValues } from './AuthConfig';\n\n/**\n * JwtHook - the OPTIONAL user-JWT mechanism. Its DI token is the {@link JWT_HOOK} Symbol injected via\n * `@inject(JWT_HOOK)` (a Symbol, because the app container uses autobind; rebindable in tests). Bind one\n * to turn on `@AuthJwt({...})` endpoints. When NO JwtHook is bound, the framework\n * {@link AuthFilter} treats every jwt endpoint as \"not enabled\" and fails fast (401) — there is no\n * default JWT verification because it needs an app secret + payload shape the framework can't guess.\n *\n *  - `parseJwt`     — AUTHENTICATION: decode/verify a user JWT into {@link AuthValues}, or throw. The\n *                     app owns the strategy (HS256 secret, RS256 + JWKS, a provider SDK, ...).\n *  - `authorizeJwt` — AUTHORIZATION: check the authenticated user against the endpoint's\n *                     {@link JwtRequirement}. The DEFAULT enforces the roles any-of; override for\n *                     app-defined requirements carried by the SAME decorator, e.g.\n *                     `@AuthJwt({allRolesAllowed: true, inOrg: true})` →\n *                     `if (requirement['inOrg'] && !values.claims['orgId']) ...`.\n *\n * BOTH ARE ASYNC, and both for the same reason: the strategy is the app's, and an app's strategy\n * reaches the network. `parseJwt` may fetch a JWKS or call a provider SDK; `authorizeJwt`'s own\n * motivating example — `@AuthJwt({allRolesAllowed: true, inOrg: true})` — is a membership question a\n * real app answers from a datastore. A sync signature makes both of those unwritable, and it made\n * `JwtHook` the last sync hook: {@link OidcHook.verifyOidc}, {@link WebhookAuthCallback.verify} and\n * {@link ApiKeyHook.verifyApiKey} all return promises. An implementation that needs no I/O simply has\n * no `await` in its body — {@link DefaultJwtHook} is exactly that and pays nothing for it.\n */\nexport abstract class JwtHook {\n    /**\n     * Parse a user JWT (kind:'jwt') — AUTHENTICATION only. Return who the user is, or throw.\n     * ASYNC so an app can reach a JWKS endpoint or a provider SDK; see the class doc.\n     */\n    abstract parseJwt(token: string): Promise<AuthValues>;\n\n    /**\n     * DEFAULT authorization: enforce the endpoint's roles (any-of). Override to enforce app-defined\n     * requirements. Throw HttpForbiddenError to deny; return to allow. ASYNC so an app-defined\n     * requirement can be answered from a datastore; see the class doc.\n     */\n    async authorizeJwt(values: AuthValues, requirement: JwtRequirement): Promise<void> {\n        // rolesRequired is the ONE reader of the JwtRoles union: [] means the endpoint typed\n        // `allRolesAllowed: true`, never \"the field was missing\" — that state no longer compiles.\n        const roles = rolesRequired(requirement);\n        if (roles.length > 0 && !roles.some((role: string) => values.roles.includes(role))) {\n            throw new HttpForbiddenError(`Endpoint requires one of roles: ${roles.join(', ')}`);\n        }\n    }\n}\n\n/**\n * DI identifier for the optional {@link JwtHook} binding. It is a Symbol (not the class) so the app\n * container's inversify autobind never auto-constructs this token, keeping `@optional() @inject(JWT_HOOK)`\n * correct — undefined when unbound. The JwtHook class stays the TYPE and the impl base.\n */\n// webpieces-disable no-symbol-di-tokens -- optional DI token: must be a Symbol so the app container's autobind never auto-constructs this token, keeping @optional() @inject(...) correct (undefined when unbound)\nexport const JWT_HOOK = Symbol.for('JwtHook');\n\n/**\n * OidcHook - the OPTIONAL override for Google OIDC service-to-service verification. Its DI token is the\n * {@link OIDC_HOOK} Symbol injected via `@inject(OIDC_HOOK)` (a Symbol, because the app container uses\n * autobind; rebindable in tests). Bind one ONLY to customize the caller policy — e.g. an app that reads an\n * `ALLOWED_OIDC_CALLERS` env var at its composition root and enforces that allow-list. When NO\n * OidcHook is bound, the framework {@link AuthFilter} runs the built-in {@link DefaultOidcVerifier}\n * directly, so a server that wires nothing still verifies Google OIDC against its `@AuthOidc(...callers)`\n * (else trusts the edge — any Google-signed caller). `verifyOidc` verifies the token against `callers`;\n * throw on failure.\n */\nexport abstract class OidcHook {\n    abstract verifyOidc(token: string, callers: string[]): Promise<void>;\n}\n\n/**\n * DI identifier for the optional {@link OidcHook} binding. It is a Symbol (not the class) so the app\n * container's inversify autobind never auto-constructs this token, keeping `@optional() @inject(OIDC_HOOK)`\n * correct — undefined when unbound. The OidcHook class stays the TYPE and the impl base.\n */\n// webpieces-disable no-symbol-di-tokens -- optional DI token: must be a Symbol so the app container's autobind never auto-constructs this token, keeping @optional() @inject(...) correct (undefined when unbound)\nexport const OIDC_HOOK = Symbol.for('OidcHook');\n\n/**\n * WebhookAuthCallback - the OPTIONAL mechanism behind `@AuthWebhook(name)`: prove that an inbound request was\n * really authored by the outside vendor the contract names. Its DI token is the {@link WEBHOOK_AUTH_CALLBACK}\n * Symbol injected via `@inject(WEBHOOK_AUTH_CALLBACK)` (a Symbol, because the app container uses autobind;\n * rebindable in tests). The third hook, symmetric with {@link JwtHook} / {@link OidcHook}:\n *\n * ```typescript\n * // AppModule.ts, beside the CompanyJwtHook binding\n * options.bind(WEBHOOK_AUTH_CALLBACK).to(CompanyWebhookAuthCallback);\n * ```\n *\n * When NO WebhookAuthCallback is bound, the framework {@link AuthFilter} 401s every `@AuthWebhook` endpoint,\n * exactly as it does for an unbound JwtHook. There is no framework default and there never will be\n * one: silently allowing an unverified webhook is the single default that must not exist, and the\n * framework ships no vendor crypto by design (see {@link AuthWebhook} for why reimplementing five\n * vendors' schemes is a losing trade).\n *\n * ONE hook serves EVERY vendor: `name` selects which, so an app with a Sentry hook and a Twilio hook\n * switches on it rather than binding a token per vendor. What arrives is enough of the raw request to\n * call the vendor's OWN validator — the bytes for a body-signing vendor (Sentry, GitHub, Stripe,\n * Slack), the absolute url for one that signs the url instead (Twilio).\n */\nexport abstract class WebhookAuthCallback {\n    /**\n     * Verify ONE inbound request. Return to allow; throw {@link HttpUnauthorizedError} to deny.\n     *\n     * @param name   the string on the contract's `@AuthWebhook(name)` — which vendor this route is.\n     * @param request the transport-neutral request (method, path, headers).\n     * @param raw    the verbatim bytes + absolute url, guaranteed present: `@AuthWebhook` requires\n     *               `@Endpoint(..., { rawBody: true })` at wiring time, and AuthFilter 401s rather\n     *               than calling this hook with nothing to check.\n     */\n    abstract verify(name: string, request: HttpRequest, raw: RawRequest): Promise<void>;\n}\n\n/**\n * DI identifier for the optional {@link WebhookAuthCallback} binding. It is a Symbol (not the class) so the app\n * container's inversify autobind never auto-constructs this token, keeping `@optional() @inject(WEBHOOK_AUTH_CALLBACK)`\n * correct — undefined when unbound. The WebhookAuthCallback class stays the TYPE and the impl base.\n */\n// webpieces-disable no-symbol-di-tokens -- optional DI token: must be a Symbol so the app container's autobind never auto-constructs this token, keeping @optional() @inject(...) correct (undefined when unbound)\nexport const WEBHOOK_AUTH_CALLBACK = Symbol.for('WebhookAuthCallback');\n\n/**\n * HeaderReader - read-only access to the inbound request's headers, and the ONLY thing an\n * {@link ApiKeyHook} is handed besides the regime name.\n *\n * It is an INTERFACE, not a class, because it is behaviour rather than data (per the guidelines) —\n * and it is NARROWER than {@link HttpRequest} on purpose. An api-key hook's job is to read the\n * credential headers and look them up; giving it the whole request would also give it the retained\n * raw bytes and the parsed body, none of which it has any business deciding authentication on.\n * `HttpRequest` satisfies this structurally, so the framework passes the live request and a spec can\n * pass a two-line stub.\n */\nexport interface HeaderReader {\n    /** First value of the header, by lowercased name, or undefined when absent. */\n    getHeader(name: string): string | undefined;\n}\n\n/**\n * ApiKeyHook - the OPTIONAL mechanism behind `@AuthApiKey(name)`: authenticate a CUSTOMER-held api key\n * against the app's own datastore and return the context to seed. Its DI token is the\n * {@link API_KEY_HOOK} Symbol injected via `@inject(API_KEY_HOOK)` (a Symbol, because the app container\n * uses autobind; rebindable in tests). The fourth hook, symmetric with {@link JwtHook} /\n * {@link OidcHook} / {@link WebhookAuthCallback}:\n *\n * ```typescript\n * // AppModule.ts, beside the CompanyJwtHook binding\n * options.bind(API_KEY_HOOK).to(OneTabletApiKeyHook);\n * ```\n *\n * When NO ApiKeyHook is bound, the framework {@link AuthFilter} 401s every `@AuthApiKey` endpoint,\n * exactly as it does for an unbound JwtHook. There is no framework default and there never will be\n * one: the key regime lives in the app's datastore, under the app's hashing scheme, behind the app's\n * choice of header names.\n *\n * THE ONE THING THIS HAS THAT `JwtHook.parseJwt` DOES NOT: it receives a {@link HeaderReader}, not one\n * pre-extracted token. A real key regime validates the key TOGETHER WITH a second header — the\n * organization the caller is acting for — and a hook handed one header's value physically cannot do\n * that cross-check. The framework therefore configures no api-key header name: which headers carry the\n * credential is the app's business. (Being ASYNC is no longer a difference — every hook here is, and\n * for the same reason: an app's strategy reaches the network.)\n *\n * ONE hook serves EVERY regime: `name` selects which, so a server with a partner-api regime and an\n * internal-tooling regime switches on it rather than binding a token per regime.\n */\nexport abstract class ApiKeyHook {\n    /**\n     * AUTHENTICATE one inbound request. Return who the caller is plus the {@link AuthValues.entries}\n     * the framework seeds into `RequestContext` via `putTrusted`, or throw\n     * {@link HttpUnauthorizedError} to deny.\n     *\n     * NOTE the seeded entries are TRUSTED context keys, so return only what THIS hook proved from the\n     * credential it just verified. Anything the caller merely asserted on the wire is not admitted by\n     * `@AuthApiKey` — the mode is deliberately caller-NOT-verified (see `AuthFilter.verifiesCaller`),\n     * because a customer is not an internal service.\n     *\n     * @param name    the string on the contract's `@AuthApiKey(name)` — which key regime this route is.\n     * @param headers the inbound request's headers; read as many as the regime needs.\n     */\n    abstract verifyApiKey(name: string, headers: HeaderReader): Promise<AuthValues>;\n}\n\n/**\n * DI identifier for the optional {@link ApiKeyHook} binding. It is a Symbol (not the class) so the app\n * container's inversify autobind never auto-constructs this token, keeping `@optional() @inject(API_KEY_HOOK)`\n * correct — undefined when unbound. The ApiKeyHook class stays the TYPE and the impl base.\n */\n// webpieces-disable no-symbol-di-tokens -- optional DI token: must be a Symbol so the app container's autobind never auto-constructs this token, keeping @optional() @inject(...) correct (undefined when unbound)\nexport const API_KEY_HOOK = Symbol.for('ApiKeyHook');\n"]}
+{"version":3,"file":"AuthHooks.js","sourceRoot":"","sources":["../../../../../packages/http/http-routing/src/AuthHooks.ts"],"names":[],"mappings":";;;AAAA,oDAAyF;AAIzF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAsB,OAAO;IAgBzB;;;;OAIG;IACH,KAAK,CAAC,YAAY,CAAC,MAA2B,EAAE,WAA2B;QACvE,qFAAqF;QACrF,0FAA0F;QAC1F,MAAM,KAAK,GAAG,IAAA,yBAAa,EAAC,WAAW,CAAC,CAAC;QACzC,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAY,EAAE,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC;YACjF,MAAM,IAAI,8BAAkB,CAAC,mCAAmC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACxF,CAAC;IACL,CAAC;CACJ;AA7BD,0BA6BC;AAED;;;;GAIG;AACH,mNAAmN;AACtM,QAAA,QAAQ,GAAG,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;AAE9C;;;;;;;;;GASG;AACH,MAAsB,QAAQ;CAE7B;AAFD,4BAEC;AAED;;;;GAIG;AACH,mNAAmN;AACtM,QAAA,SAAS,GAAG,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAsB,mBAAmB;CAuBxC;AAvBD,kDAuBC;AAED;;;;GAIG;AACH,mNAAmN;AACtM,QAAA,qBAAqB,GAAG,MAAM,CAAC,GAAG,CAAC,qBAAqB,CAAC,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAsB,UAAU;CAgB/B;AAhBD,gCAgBC;AAED;;;;GAIG;AACH,mNAAmN;AACtM,QAAA,YAAY,GAAG,MAAM,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC","sourcesContent":["import { JwtRequirement, rolesRequired, HttpForbiddenError } from '@webpieces/core-util';\nimport { HttpRequest, RawHttpRequest } from '@webpieces/core-context';\nimport { AuthenticatedCaller } from './AuthConfig';\n\n/**\n * JwtHook - the OPTIONAL user-JWT mechanism. Its DI token is the {@link JWT_HOOK} Symbol injected via\n * `@inject(JWT_HOOK)` (a Symbol, because the app container uses autobind; rebindable in tests). Bind one\n * to turn on `@AuthJwt({...})` endpoints. When NO JwtHook is bound, the framework\n * {@link AuthFilter} treats every jwt endpoint as \"not enabled\" and fails fast (401) — there is no\n * default JWT verification because it needs an app secret + payload shape the framework can't guess.\n *\n *  - `parseJwt`     — AUTHENTICATION: decode/verify a user JWT into {@link AuthenticatedCaller}, or throw. The\n *                     app owns the strategy (HS256 secret, RS256 + JWKS, a provider SDK, ...).\n *  - `authorizeJwt` — AUTHORIZATION: check the authenticated user against the endpoint's\n *                     {@link JwtRequirement}. The DEFAULT enforces the roles any-of; override for\n *                     app-defined requirements carried by the SAME decorator, e.g.\n *                     `@AuthJwt({allRolesAllowed: true, inOrg: true})` →\n *                     `if (requirement['inOrg'] && !values.claims['orgId']) ...`.\n *\n * BOTH ARE ASYNC, and both for the same reason: the strategy is the app's, and an app's strategy\n * reaches the network. `parseJwt` may fetch a JWKS or call a provider SDK; `authorizeJwt`'s own\n * motivating example — `@AuthJwt({allRolesAllowed: true, inOrg: true})` — is a membership question a\n * real app answers from a datastore. A sync signature makes both of those unwritable, and it made\n * `JwtHook` the last sync hook: {@link OidcHook.verifyOidc}, {@link WebhookAuthCallback.verifyWebhook} and\n * {@link ApiKeyHook.verifyApiKey} all return promises. An implementation that needs no I/O simply has\n * no `await` in its body — {@link DefaultJwtHook} is exactly that and pays nothing for it.\n */\nexport abstract class JwtHook {\n    /**\n     * Parse a user JWT (kind:'jwt') — AUTHENTICATION only. Return who the user is, or throw.\n     * ASYNC so an app can reach a JWKS endpoint or a provider SDK; see the class doc.\n     *\n     * IT TAKES THE TOKEN, NOT THE REQUEST — the one deliberate asymmetry among the four hooks, and\n     * NOT an oversight to be \"fixed\". {@link ApiKeyHook.verifyApiKey} and\n     * {@link WebhookAuthCallback.verifyWebhook} take the whole {@link HttpRequest} because their\n     * credential regime is the APP's: which headers carry an api key, and how a vendor signs, are\n     * things the framework cannot know. A user JWT is different — the framework owns the\n     * `Authorization: Bearer` scheme and has already extracted the token from it. Widening this to\n     * the request would only invite a JwtHook to authenticate off some OTHER header, which is a\n     * second, ungoverned credential path on the mode that guards browser traffic.\n     */\n    abstract parseJwt(token: string): Promise<AuthenticatedCaller>;\n\n    /**\n     * DEFAULT authorization: enforce the endpoint's roles (any-of). Override to enforce app-defined\n     * requirements. Throw HttpForbiddenError to deny; return to allow. ASYNC so an app-defined\n     * requirement can be answered from a datastore; see the class doc.\n     */\n    async authorizeJwt(caller: AuthenticatedCaller, requirement: JwtRequirement): Promise<void> {\n        // rolesRequired is the ONE reader of the JwtRoles union: [] means the endpoint typed\n        // `allRolesAllowed: true`, never \"the field was missing\" — that state no longer compiles.\n        const roles = rolesRequired(requirement);\n        if (roles.length > 0 && !roles.some((role: string) => caller.roles.includes(role))) {\n            throw new HttpForbiddenError(`Endpoint requires one of roles: ${roles.join(', ')}`);\n        }\n    }\n}\n\n/**\n * DI identifier for the optional {@link JwtHook} binding. It is a Symbol (not the class) so the app\n * container's inversify autobind never auto-constructs this token, keeping `@optional() @inject(JWT_HOOK)`\n * correct — undefined when unbound. The JwtHook class stays the TYPE and the impl base.\n */\n// webpieces-disable no-symbol-di-tokens -- optional DI token: must be a Symbol so the app container's autobind never auto-constructs this token, keeping @optional() @inject(...) correct (undefined when unbound)\nexport const JWT_HOOK = Symbol.for('JwtHook');\n\n/**\n * OidcHook - the OPTIONAL override for Google OIDC service-to-service verification. Its DI token is the\n * {@link OIDC_HOOK} Symbol injected via `@inject(OIDC_HOOK)` (a Symbol, because the app container uses\n * autobind; rebindable in tests). Bind one ONLY to customize the caller policy — e.g. an app that reads an\n * `ALLOWED_OIDC_CALLERS` env var at its composition root and enforces that allow-list. When NO\n * OidcHook is bound, the framework {@link AuthFilter} runs the built-in {@link DefaultOidcVerifier}\n * directly, so a server that wires nothing still verifies Google OIDC against its `@AuthOidc(...callers)`\n * (else trusts the edge — any Google-signed caller). `verifyOidc` verifies the token against `callers`;\n * throw on failure.\n */\nexport abstract class OidcHook {\n    abstract verifyOidc(token: string, callers: string[]): Promise<void>;\n}\n\n/**\n * DI identifier for the optional {@link OidcHook} binding. It is a Symbol (not the class) so the app\n * container's inversify autobind never auto-constructs this token, keeping `@optional() @inject(OIDC_HOOK)`\n * correct — undefined when unbound. The OidcHook class stays the TYPE and the impl base.\n */\n// webpieces-disable no-symbol-di-tokens -- optional DI token: must be a Symbol so the app container's autobind never auto-constructs this token, keeping @optional() @inject(...) correct (undefined when unbound)\nexport const OIDC_HOOK = Symbol.for('OidcHook');\n\n/**\n * WebhookAuthCallback - the OPTIONAL mechanism behind `@AuthWebhook(name)`: prove that an inbound request was\n * really authored by the outside vendor the contract names. Its DI token is the {@link WEBHOOK_AUTH_CALLBACK}\n * Symbol injected via `@inject(WEBHOOK_AUTH_CALLBACK)` (a Symbol, because the app container uses autobind;\n * rebindable in tests). The third hook, symmetric with {@link JwtHook} / {@link OidcHook}:\n *\n * ```typescript\n * // AppModule.ts, beside the CompanyJwtHook binding\n * options.bind(WEBHOOK_AUTH_CALLBACK).to(CompanyWebhookAuthCallback);\n * ```\n *\n * When NO WebhookAuthCallback is bound, the framework {@link AuthFilter} 401s every `@AuthWebhook` endpoint,\n * exactly as it does for an unbound JwtHook. There is no framework default and there never will be\n * one: silently allowing an unverified webhook is the single default that must not exist, and the\n * framework ships no vendor crypto by design (see {@link AuthWebhook} for why reimplementing five\n * vendors' schemes is a losing trade).\n *\n * ONE hook serves EVERY vendor: `name` selects which, so an app with a Sentry hook and a Twilio hook\n * switches on it rather than binding a token per vendor. What arrives is enough of the raw request to\n * call the vendor's OWN validator — `request.raw.rawBody` for a body-signing vendor (Sentry, GitHub,\n * Stripe, Slack), `request.raw.absoluteUrl` for one that signs the url instead (Twilio).\n */\nexport abstract class WebhookAuthCallback {\n    /**\n     * Verify ONE inbound request. Return the {@link AuthenticatedCaller} the vendor's signature\n     * proved; throw {@link HttpUnauthorizedError} to deny.\n     *\n     * IT RETURNS A CALLER, not `void`, for the same reason {@link ApiKeyHook.verifyApiKey} does: once\n     * the signature checks out, the payload's vendor account is a PROVEN fact, and a hook that could\n     * only return `void` had no way to say so. The framework seeds `entries` with\n     * `RequestContext.putTrusted` exactly as it does for a jwt or api-key caller, so a controller\n     * reads which vendor account this webhook is for off the context instead of re-deriving it.\n     *\n     * Return only what THIS hook proved from the signature it just verified. `webhook` remains\n     * caller-NOT-verified (see `AuthFilter.verifiesCaller`): a vendor is not a peer service, so\n     * nothing the vendor merely ASSERTED on the wire is admitted.\n     *\n     * @param name    the string on the contract's `@AuthWebhook(name)` — which vendor this route is.\n     * @param request the transport-neutral request, narrowed to {@link RawHttpRequest}: `request.raw`\n     *                holds the verbatim bytes + absolute url and is PRESENT, never optional.\n     *                `@AuthWebhook` requires `@Endpoint(..., { rawBody: true })` at wiring time, and\n     *                AuthFilter 401s rather than calling this hook with nothing to check — so an\n     *                implementation never writes `raw!` or a guard of its own.\n     */\n    abstract verifyWebhook(name: string, request: RawHttpRequest): Promise<AuthenticatedCaller>;\n}\n\n/**\n * DI identifier for the optional {@link WebhookAuthCallback} binding. It is a Symbol (not the class) so the app\n * container's inversify autobind never auto-constructs this token, keeping `@optional() @inject(WEBHOOK_AUTH_CALLBACK)`\n * correct — undefined when unbound. The WebhookAuthCallback class stays the TYPE and the impl base.\n */\n// webpieces-disable no-symbol-di-tokens -- optional DI token: must be a Symbol so the app container's autobind never auto-constructs this token, keeping @optional() @inject(...) correct (undefined when unbound)\nexport const WEBHOOK_AUTH_CALLBACK = Symbol.for('WebhookAuthCallback');\n\n/**\n * ApiKeyHook - the OPTIONAL mechanism behind `@AuthApiKey(name)`: authenticate a CUSTOMER-held api key\n * against the app's own datastore and return the context to seed. Its DI token is the\n * {@link API_KEY_HOOK} Symbol injected via `@inject(API_KEY_HOOK)` (a Symbol, because the app container\n * uses autobind; rebindable in tests). The fourth hook, symmetric with {@link JwtHook} /\n * {@link OidcHook} / {@link WebhookAuthCallback}:\n *\n * ```typescript\n * // AppModule.ts, beside the CompanyJwtHook binding\n * options.bind(API_KEY_HOOK).to(OneTabletApiKeyHook);\n * ```\n *\n * When NO ApiKeyHook is bound, the framework {@link AuthFilter} 401s every `@AuthApiKey` endpoint,\n * exactly as it does for an unbound JwtHook. There is no framework default and there never will be\n * one: the key regime lives in the app's datastore, under the app's hashing scheme, behind the app's\n * choice of header names.\n *\n * THE ONE THING THIS HAS THAT `JwtHook.parseJwt` DOES NOT: it receives the whole {@link HttpRequest},\n * not one pre-extracted token. A real key regime validates the key TOGETHER WITH a second header — the\n * organization the caller is acting for — and a hook handed one header's value physically cannot do\n * that cross-check. The framework therefore configures no api-key header name: which headers carry the\n * credential is the app's business, and `getHeader` / `getHeaderValues` read as many as the regime\n * needs. (Being ASYNC is no longer a difference — every hook here is, and for the same reason: an\n * app's strategy reaches the network.)\n *\n * ONE hook serves EVERY regime: `name` selects which, so a server with a partner-api regime and an\n * internal-tooling regime switches on it rather than binding a token per regime.\n */\nexport abstract class ApiKeyHook {\n    /**\n     * AUTHENTICATE one inbound request. Return who the caller is plus the {@link AuthenticatedCaller.entries}\n     * the framework seeds into `RequestContext` via `putTrusted`, or throw\n     * {@link HttpUnauthorizedError} to deny.\n     *\n     * NOTE the seeded entries are TRUSTED context keys, so return only what THIS hook proved from the\n     * credential it just verified. Anything the caller merely asserted on the wire is not admitted by\n     * `@AuthApiKey` — the mode is deliberately caller-NOT-verified (see `AuthFilter.verifiesCaller`),\n     * because a customer is not an internal service.\n     *\n     * @param name    the string on the contract's `@AuthApiKey(name)` — which key regime this route is.\n     * @param request the inbound request; read as many headers as the regime needs with\n     *                `getHeader` / `getHeaderValues`, either by raw name or by {@link ContextKey}.\n     */\n    abstract verifyApiKey(name: string, request: HttpRequest): Promise<AuthenticatedCaller>;\n}\n\n/**\n * DI identifier for the optional {@link ApiKeyHook} binding. It is a Symbol (not the class) so the app\n * container's inversify autobind never auto-constructs this token, keeping `@optional() @inject(API_KEY_HOOK)`\n * correct — undefined when unbound. The ApiKeyHook class stays the TYPE and the impl base.\n */\n// webpieces-disable no-symbol-di-tokens -- optional DI token: must be a Symbol so the app container's autobind never auto-constructs this token, keeping @optional() @inject(...) correct (undefined when unbound)\nexport const API_KEY_HOOK = Symbol.for('ApiKeyHook');\n"]}

package/src/AuthHooksCompileAssertions.d.ts

@@ -0,0 +1,31 @@
+/**
+ * COMPILE-TIME assertions that the four auth hooks share ONE shape, and that every spelling this
+ * change deleted has actually stopped compiling. Each `@ts-expect-error` FAILS THE BUILD (TS2578,
+ * "unused '@ts-expect-error' directive") the moment the thing it guards starts compiling again.
+ *
+ * WHY THIS IS NOT A `.spec.ts` FILE — the same reason as {@link JwtHookCompileAssertions}:
+ * tsconfig.lib.json EXCLUDES specs and vitest strips types with esbuild, so a `@ts-expect-error` in a
+ * spec is inert and the suite passes either way. A type-level guarantee has to be asserted in a file
+ * the type-checker actually compiles.
+ *
+ * WHY IT MATTERS HERE. This repo ships no backwards-compatibility shims: the compile error IS the
+ * migration. An implementor that kept `verify(name, request, raw)` or a `HeaderReader` parameter
+ * would otherwise sit there compiling, and an accepted shape is never migrated.
+ */
+export declare class AuthHooksCompileAssertions {
+    /**
+     * The DELETED type names, kept referenced so the two `@ts-expect-error`s above are load-bearing
+     * rather than decorative. Both resolve to `any` under the suppressed error; the assertion is the
+     * IMPORT failing, not what these aliases denote.
+     */
+    deletedNames(): void;
+    /** The ALIGNED spellings must keep compiling; asserted by the ABSENCE of an error. */
+    legitimate(): void;
+    /** Every spelling this change deleted must now be UNWRITABLE. */
+    rejected(): void;
+    /**
+     * An {@link HttpRequest} whose `raw` is merely OPTIONAL is NOT a {@link RawHttpRequest}. This is
+     * the assignment that makes the narrowing real: without it, `RawHttpRequest` would be a comment.
+     */
+    rawIsNotOptional(): void;
+}

package/src/AuthHooksCompileAssertions.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthHooksCompileAssertions = void 0;
+const core_context_1 = require("@webpieces/core-context");
+const AuthHooks_1 = require("./AuthHooks");
+const AuthConfig_1 = require("./AuthConfig");
+/**
+ * COMPILE-TIME assertions that the four auth hooks share ONE shape, and that every spelling this
+ * change deleted has actually stopped compiling. Each `@ts-expect-error` FAILS THE BUILD (TS2578,
+ * "unused '@ts-expect-error' directive") the moment the thing it guards starts compiling again.
+ *
+ * WHY THIS IS NOT A `.spec.ts` FILE — the same reason as {@link JwtHookCompileAssertions}:
+ * tsconfig.lib.json EXCLUDES specs and vitest strips types with esbuild, so a `@ts-expect-error` in a
+ * spec is inert and the suite passes either way. A type-level guarantee has to be asserted in a file
+ * the type-checker actually compiles.
+ *
+ * WHY IT MATTERS HERE. This repo ships no backwards-compatibility shims: the compile error IS the
+ * migration. An implementor that kept `verify(name, request, raw)` or a `HeaderReader` parameter
+ * would otherwise sit there compiling, and an accepted shape is never migrated.
+ */
+class AuthHooksCompileAssertions {
+    /**
+     * The DELETED type names, kept referenced so the two `@ts-expect-error`s above are load-bearing
+     * rather than decorative. Both resolve to `any` under the suppressed error; the assertion is the
+     * IMPORT failing, not what these aliases denote.
+     */
+    // webpieces-disable no-any-unknown -- a suppressed import of a deleted symbol resolves to any; the assertion is the import error itself
+    deletedNames() {
+        const headerReaderIsGone = undefined;
+        const authValuesIsGone = undefined;
+        void headerReaderIsGone;
+        void authValuesIsGone;
+    }
+    /** The ALIGNED spellings must keep compiling; asserted by the ABSENCE of an error. */
+    legitimate() {
+        void class extends AuthHooks_1.WebhookAuthCallback {
+            async verifyWebhook(_name, request) {
+                // No `raw!`, no `if (!raw) throw`: AuthFilter checked once and the TYPE carries it.
+                const bytes = request.raw.rawBody;
+                return new AuthConfig_1.AuthenticatedCaller(`sentry:${bytes.length}`);
+            }
+        };
+        void class extends AuthHooks_1.ApiKeyHook {
+            async verifyApiKey(_name, request) {
+                // Both of these were UNREACHABLE through the deleted one-method HeaderReader.
+                const all = request.getHeaderValues('x-api-key');
+                return new AuthConfig_1.AuthenticatedCaller(all?.[0] ?? 'anonymous');
+            }
+        };
+    }
+    /** Every spelling this change deleted must now be UNWRITABLE. */
+    rejected() {
+        void class extends AuthHooks_1.WebhookAuthCallback {
+            async verifyWebhook(_name, _request) {
+                return new AuthConfig_1.AuthenticatedCaller('u1');
+            }
+            // @ts-expect-error `verify` was renamed to `verifyWebhook`: the old name overrides nothing
+            async verify(_name, _request, _raw) {
+                // the three-parameter, void-returning spelling this change deletes
+            }
+        };
+        void class extends AuthHooks_1.WebhookAuthCallback {
+            // @ts-expect-error verifyWebhook returns the caller it proved: a void override must not compile
+            async verifyWebhook(_name, _request) {
+                // a hook that verifies and then has no way to say what it proved
+            }
+        };
+    }
+    /**
+     * An {@link HttpRequest} whose `raw` is merely OPTIONAL is NOT a {@link RawHttpRequest}. This is
+     * the assignment that makes the narrowing real: without it, `RawHttpRequest` would be a comment.
+     */
+    rawIsNotOptional() {
+        const maybeRaw = new core_context_1.HttpRequest('POST', '/hook/sentry/issue', new Map());
+        // @ts-expect-error HttpRequest.raw is optional, so it is not assignable to RawHttpRequest
+        const narrowed = maybeRaw;
+        void narrowed;
+        // The other direction is free: a RawHttpRequest IS an HttpRequest everywhere one is wanted.
+        const proven = new core_context_1.HttpRequest('POST', '/hook/sentry/issue', new Map(), new core_context_1.RawRequest('https://example.com/hook', Buffer.from('{}', 'utf8'), '1.2.3.4'));
+        const widened = proven;
+        void widened;
+    }
+}
+exports.AuthHooksCompileAssertions = AuthHooksCompileAssertions;
+//# sourceMappingURL=AuthHooksCompileAssertions.js.map

package/src/AuthHooksCompileAssertions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AuthHooksCompileAssertions.js","sourceRoot":"","sources":["../../../../../packages/http/http-routing/src/AuthHooksCompileAssertions.ts"],"names":[],"mappings":";;;AAAA,0DAAkF;AAMlF,2CAA8D;AAC9D,6CAAmD;AAEnD;;;;;;;;;;;;;GAaG;AACH,MAAa,0BAA0B;IACnC;;;;OAIG;IACH,wIAAwI;IACxI,YAAY;QACR,MAAM,kBAAkB,GAA6B,SAAS,CAAC;QAC/D,MAAM,gBAAgB,GAA2B,SAAS,CAAC;QAC3D,KAAK,kBAAkB,CAAC;QACxB,KAAK,gBAAgB,CAAC;IAC1B,CAAC;IAED,sFAAsF;IACtF,UAAU;QACN,KAAK,KAAM,SAAQ,+BAAmB;YACzB,KAAK,CAAC,aAAa,CAAC,KAAa,EAAE,OAAuB;gBAC/D,oFAAoF;gBACpF,MAAM,KAAK,GAAW,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC;gBAC1C,OAAO,IAAI,gCAAmB,CAAC,UAAU,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC;YAC7D,CAAC;SACJ,CAAC;QACF,KAAK,KAAM,SAAQ,sBAAU;YAChB,KAAK,CAAC,YAAY,CAAC,KAAa,EAAE,OAAoB;gBAC3D,8EAA8E;gBAC9E,MAAM,GAAG,GAAyB,OAAO,CAAC,eAAe,CAAC,WAAW,CAAC,CAAC;gBACvE,OAAO,IAAI,gCAAmB,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,IAAI,WAAW,CAAC,CAAC;YAC5D,CAAC;SACJ,CAAC;IACN,CAAC;IAED,iEAAiE;IACjE,QAAQ;QACJ,KAAK,KAAM,SAAQ,+BAAmB;YACzB,KAAK,CAAC,aAAa,CAAC,KAAa,EAAE,QAAwB;gBAChE,OAAO,IAAI,gCAAmB,CAAC,IAAI,CAAC,CAAC;YACzC,CAAC;YAED,2FAA2F;YAClF,KAAK,CAAC,MAAM,CAAC,KAAa,EAAE,QAAqB,EAAE,IAAgB;gBACxE,mEAAmE;YACvE,CAAC;SACJ,CAAC;QACF,KAAK,KAAM,SAAQ,+BAAmB;YAClC,gGAAgG;YACvF,KAAK,CAAC,aAAa,CAAC,KAAa,EAAE,QAAwB;gBAChE,iEAAiE;YACrE,CAAC;SACJ,CAAC;IACN,CAAC;IAED;;;OAGG;IACH,gBAAgB;QACZ,MAAM,QAAQ,GAAG,IAAI,0BAAW,CAAC,MAAM,EAAE,oBAAoB,EAAE,IAAI,GAAG,EAAoB,CAAC,CAAC;QAC5F,0FAA0F;QAC1F,MAAM,QAAQ,GAAmB,QAAQ,CAAC;QAC1C,KAAK,QAAQ,CAAC;QAEd,4FAA4F;QAC5F,MAAM,MAAM,GAAG,IAAI,0BAAW,CAC1B,MAAM,EACN,oBAAoB,EACpB,IAAI,GAAG,EAAoB,EAC3B,IAAI,yBAAU,CAAC,0BAA0B,EAAE,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC,EAAE,SAAS,CAAC,CACjE,CAAC;QACpB,MAAM,OAAO,GAAgB,MAAM,CAAC;QACpC,KAAK,OAAO,CAAC;IACjB,CAAC;CACJ;AAxED,gEAwEC","sourcesContent":["import { HttpRequest, RawHttpRequest, RawRequest } from '@webpieces/core-context';\n// @ts-expect-error HeaderReader is DELETED — an ApiKeyHook now receives the whole HttpRequest, so it\n// reaches getHeaderValues and the ContextKey overload of getHeader that the narrow reader hid.\nimport type { HeaderReader } from './AuthHooks';\n// @ts-expect-error AuthValues is RENAMED to AuthenticatedCaller — there is no alias, by policy.\nimport type { AuthValues } from './AuthConfig';\nimport { ApiKeyHook, WebhookAuthCallback } from './AuthHooks';\nimport { AuthenticatedCaller } from './AuthConfig';\n\n/**\n * COMPILE-TIME assertions that the four auth hooks share ONE shape, and that every spelling this\n * change deleted has actually stopped compiling. Each `@ts-expect-error` FAILS THE BUILD (TS2578,\n * \"unused '@ts-expect-error' directive\") the moment the thing it guards starts compiling again.\n *\n * WHY THIS IS NOT A `.spec.ts` FILE — the same reason as {@link JwtHookCompileAssertions}:\n * tsconfig.lib.json EXCLUDES specs and vitest strips types with esbuild, so a `@ts-expect-error` in a\n * spec is inert and the suite passes either way. A type-level guarantee has to be asserted in a file\n * the type-checker actually compiles.\n *\n * WHY IT MATTERS HERE. This repo ships no backwards-compatibility shims: the compile error IS the\n * migration. An implementor that kept `verify(name, request, raw)` or a `HeaderReader` parameter\n * would otherwise sit there compiling, and an accepted shape is never migrated.\n */\nexport class AuthHooksCompileAssertions {\n    /**\n     * The DELETED type names, kept referenced so the two `@ts-expect-error`s above are load-bearing\n     * rather than decorative. Both resolve to `any` under the suppressed error; the assertion is the\n     * IMPORT failing, not what these aliases denote.\n     */\n    // webpieces-disable no-any-unknown -- a suppressed import of a deleted symbol resolves to any; the assertion is the import error itself\n    deletedNames(): void {\n        const headerReaderIsGone: HeaderReader | undefined = undefined;\n        const authValuesIsGone: AuthValues | undefined = undefined;\n        void headerReaderIsGone;\n        void authValuesIsGone;\n    }\n\n    /** The ALIGNED spellings must keep compiling; asserted by the ABSENCE of an error. */\n    legitimate(): void {\n        void class extends WebhookAuthCallback {\n            override async verifyWebhook(_name: string, request: RawHttpRequest): Promise<AuthenticatedCaller> {\n                // No `raw!`, no `if (!raw) throw`: AuthFilter checked once and the TYPE carries it.\n                const bytes: Buffer = request.raw.rawBody;\n                return new AuthenticatedCaller(`sentry:${bytes.length}`);\n            }\n        };\n        void class extends ApiKeyHook {\n            override async verifyApiKey(_name: string, request: HttpRequest): Promise<AuthenticatedCaller> {\n                // Both of these were UNREACHABLE through the deleted one-method HeaderReader.\n                const all: string[] | undefined = request.getHeaderValues('x-api-key');\n                return new AuthenticatedCaller(all?.[0] ?? 'anonymous');\n            }\n        };\n    }\n\n    /** Every spelling this change deleted must now be UNWRITABLE. */\n    rejected(): void {\n        void class extends WebhookAuthCallback {\n            override async verifyWebhook(_name: string, _request: RawHttpRequest): Promise<AuthenticatedCaller> {\n                return new AuthenticatedCaller('u1');\n            }\n\n            // @ts-expect-error `verify` was renamed to `verifyWebhook`: the old name overrides nothing\n            override async verify(_name: string, _request: HttpRequest, _raw: RawRequest): Promise<void> {\n                // the three-parameter, void-returning spelling this change deletes\n            }\n        };\n        void class extends WebhookAuthCallback {\n            // @ts-expect-error verifyWebhook returns the caller it proved: a void override must not compile\n            override async verifyWebhook(_name: string, _request: RawHttpRequest): Promise<void> {\n                // a hook that verifies and then has no way to say what it proved\n            }\n        };\n    }\n\n    /**\n     * An {@link HttpRequest} whose `raw` is merely OPTIONAL is NOT a {@link RawHttpRequest}. This is\n     * the assignment that makes the narrowing real: without it, `RawHttpRequest` would be a comment.\n     */\n    rawIsNotOptional(): void {\n        const maybeRaw = new HttpRequest('POST', '/hook/sentry/issue', new Map<string, string[]>());\n        // @ts-expect-error HttpRequest.raw is optional, so it is not assignable to RawHttpRequest\n        const narrowed: RawHttpRequest = maybeRaw;\n        void narrowed;\n\n        // The other direction is free: a RawHttpRequest IS an HttpRequest everywhere one is wanted.\n        const proven = new HttpRequest(\n            'POST',\n            '/hook/sentry/issue',\n            new Map<string, string[]>(),\n            new RawRequest('https://example.com/hook', Buffer.from('{}', 'utf8'), '1.2.3.4'),\n        ) as RawHttpRequest;\n        const widened: HttpRequest = proven;\n        void widened;\n    }\n}\n"]}

package/src/DefaultJwtHook.d.ts

@@ -1,5 +1,5 @@
 import { JwtHook } from './AuthHooks';
-import { AuthValues } from './AuthConfig';
+import { AuthenticatedCaller } from './AuthConfig';
 /**
  * DefaultJwtHook - a batteries-included {@link JwtHook} for the common case: HS256 user JWTs signed
  * with ONE shared secret. Construct it with the secret and bind it — `new DefaultJwtHook(secret)` —
@@ -18,7 +18,7 @@ import { AuthValues } from './AuthConfig';
 export declare class DefaultJwtHook extends JwtHook {
     private readonly secret;
     constructor(secret: string);
-    parseJwt(token: string): Promise<AuthValues>;
+    parseJwt(token: string): Promise<AuthenticatedCaller>;
     /** Verify HS256 signature + expiry; translate jsonwebtoken's raw error into a framework 401. */
     private verifyToken;
     private extractRoles;

package/src/DefaultJwtHook.js

@@ -32,7 +32,7 @@ class DefaultJwtHook extends AuthHooks_1.JwtHook {
         if (!userId) {
             throw new core_util_1.HttpUnauthorizedError('JWT is missing the required "sub" (subject) claim');
         }
-        return new AuthConfig_1.AuthValues(userId, this.extractRoles(payload), [], payload);
+        return new AuthConfig_1.AuthenticatedCaller(userId, this.extractRoles(payload), [], payload);
     }
     /** Verify HS256 signature + expiry; translate jsonwebtoken's raw error into a framework 401. */
     verifyToken(token) {

package/src/DefaultJwtHook.js.map

@@ -1 +1 @@
-{"version":3,"file":"DefaultJwtHook.js","sourceRoot":"","sources":["../../../../../packages/http/http-routing/src/DefaultJwtHook.ts"],"names":[],"mappings":";;;AAAA,+CAAkD;AAClD,oDAAsE;AACtE,2CAAsC;AACtC,6CAA0C;AAE1C;;;;;;;;;;;;;;GAcG;AACH,MAAa,cAAe,SAAQ,mBAAO;IACtB,MAAM,CAAS;IAEhC,YAAY,MAAc;QACtB,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACzB,CAAC;IAEQ,KAAK,CAAC,QAAQ,CAAC,KAAa;QACjC,MAAM,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;QACxC,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC;QAC3B,IAAI,CAAC,MAAM,EAAE,CAAC;YACV,MAAM,IAAI,iCAAqB,CAAC,mDAAmD,CAAC,CAAC;QACzF,CAAC;QACD,OAAO,IAAI,uBAAU,CAAC,MAAM,EAAE,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,EAAE,EAAE,EAAE,OAAO,CAAC,CAAC;IAC3E,CAAC;IAED,gGAAgG;IACxF,WAAW,CAAC,KAAa;QAC7B,8QAA8Q;QAC9Q,IAAI,CAAC;YACD,MAAM,OAAO,GAAG,IAAA,qBAAM,EAAC,KAAK,EAAE,IAAI,CAAC,MAAM,EAAE,EAAE,UAAU,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;YACtE,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE,CAAC;gBAC9B,MAAM,IAAI,iCAAqB,CAAC,iDAAiD,CAAC,CAAC;YACvF,CAAC;YACD,OAAO,OAAO,CAAC;QACnB,CAAC;QAAC,OAAO,GAAY,EAAE,CAAC;YACpB,MAAM,KAAK,GAAG,IAAA,mBAAO,EAAC,GAAG,CAAC,CAAC;YAC3B,IAAI,KAAK,YAAY,iCAAqB,EAAE,CAAC;gBACzC,MAAM,KAAK,CAAC;YAChB,CAAC;YACD,MAAM,IAAI,iCAAqB,CAAC,yBAAyB,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;QACjF,CAAC;IACL,CAAC;IAEO,YAAY,CAAC,OAAmB;QACpC,MAAM,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;QAC/B,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YACvB,OAAO,KAAK,CAAC,MAAM,CAAC,CAAC,IAAY,EAAE,EAAE,CAAC,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC;QACpE,CAAC;QACD,OAAO,EAAE,CAAC;IACd,CAAC;CACJ;AA1CD,wCA0CC","sourcesContent":["import { verify, JwtPayload } from 'jsonwebtoken';\nimport { HttpUnauthorizedError, toError } from '@webpieces/core-util';\nimport { JwtHook } from './AuthHooks';\nimport { AuthValues } from './AuthConfig';\n\n/**\n * DefaultJwtHook - a batteries-included {@link JwtHook} for the common case: HS256 user JWTs signed\n * with ONE shared secret. Construct it with the secret and bind it — `new DefaultJwtHook(secret)` —\n * and `@AuthJwt` endpoints work with NO custom verification code.\n *\n * `parseJwt` verifies the signature + expiry (jsonwebtoken, HS256 only) and maps standard claims:\n * `sub` → userId, a string[] `roles` claim → roles, the whole payload → claims. `authorizeJwt`\n * (role enforcement) is inherited from JwtHook. For RS256 + JWKS, a provider SDK, or a non-standard\n * payload, write your own JwtHook subclass instead.\n *\n * It satisfies {@link JwtHook}'s ASYNC signature with a body that awaits NOTHING, and that is the\n * point rather than an oversight: HS256 against a local secret is pure CPU. The signature is async\n * because the hook is the APP's seam and an app's strategy reaches the network — not because this\n * implementation does. No fake await is added to justify it.\n */\nexport class DefaultJwtHook extends JwtHook {\n    private readonly secret: string;\n\n    constructor(secret: string) {\n        super();\n        this.secret = secret;\n    }\n\n    override async parseJwt(token: string): Promise<AuthValues> {\n        const payload = this.verifyToken(token);\n        const userId = payload.sub;\n        if (!userId) {\n            throw new HttpUnauthorizedError('JWT is missing the required \"sub\" (subject) claim');\n        }\n        return new AuthValues(userId, this.extractRoles(payload), [], payload);\n    }\n\n    /** Verify HS256 signature + expiry; translate jsonwebtoken's raw error into a framework 401. */\n    private verifyToken(token: string): JwtPayload {\n        // eslint-disable-next-line @webpieces/no-unmanaged-exceptions -- AUTH TRANSLATION CHOKEPOINT: jsonwebtoken.verify throws on a bad/expired token; that must surface as a 401 Unauthorized, not bubble to the global handler as a 500. The original error is chained via cause.\n        try {\n            const decoded = verify(token, this.secret, { algorithms: ['HS256'] });\n            if (typeof decoded === 'string') {\n                throw new HttpUnauthorizedError('JWT payload must be a JSON object, not a string');\n            }\n            return decoded;\n        } catch (err: unknown) {\n            const error = toError(err);\n            if (error instanceof HttpUnauthorizedError) {\n                throw error;\n            }\n            throw new HttpUnauthorizedError('JWT verification failed', undefined, error);\n        }\n    }\n\n    private extractRoles(payload: JwtPayload): string[] {\n        const roles = payload['roles'];\n        if (Array.isArray(roles)) {\n            return roles.filter((role: string) => typeof role === 'string');\n        }\n        return [];\n    }\n}\n"]}
+{"version":3,"file":"DefaultJwtHook.js","sourceRoot":"","sources":["../../../../../packages/http/http-routing/src/DefaultJwtHook.ts"],"names":[],"mappings":";;;AAAA,+CAAkD;AAClD,oDAAsE;AACtE,2CAAsC;AACtC,6CAAmD;AAEnD;;;;;;;;;;;;;;GAcG;AACH,MAAa,cAAe,SAAQ,mBAAO;IACtB,MAAM,CAAS;IAEhC,YAAY,MAAc;QACtB,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACzB,CAAC;IAEQ,KAAK,CAAC,QAAQ,CAAC,KAAa;QACjC,MAAM,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;QACxC,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC;QAC3B,IAAI,CAAC,MAAM,EAAE,CAAC;YACV,MAAM,IAAI,iCAAqB,CAAC,mDAAmD,CAAC,CAAC;QACzF,CAAC;QACD,OAAO,IAAI,gCAAmB,CAAC,MAAM,EAAE,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,EAAE,EAAE,EAAE,OAAO,CAAC,CAAC;IACpF,CAAC;IAED,gGAAgG;IACxF,WAAW,CAAC,KAAa;QAC7B,8QAA8Q;QAC9Q,IAAI,CAAC;YACD,MAAM,OAAO,GAAG,IAAA,qBAAM,EAAC,KAAK,EAAE,IAAI,CAAC,MAAM,EAAE,EAAE,UAAU,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;YACtE,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE,CAAC;gBAC9B,MAAM,IAAI,iCAAqB,CAAC,iDAAiD,CAAC,CAAC;YACvF,CAAC;YACD,OAAO,OAAO,CAAC;QACnB,CAAC;QAAC,OAAO,GAAY,EAAE,CAAC;YACpB,MAAM,KAAK,GAAG,IAAA,mBAAO,EAAC,GAAG,CAAC,CAAC;YAC3B,IAAI,KAAK,YAAY,iCAAqB,EAAE,CAAC;gBACzC,MAAM,KAAK,CAAC;YAChB,CAAC;YACD,MAAM,IAAI,iCAAqB,CAAC,yBAAyB,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;QACjF,CAAC;IACL,CAAC;IAEO,YAAY,CAAC,OAAmB;QACpC,MAAM,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;QAC/B,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YACvB,OAAO,KAAK,CAAC,MAAM,CAAC,CAAC,IAAY,EAAE,EAAE,CAAC,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC;QACpE,CAAC;QACD,OAAO,EAAE,CAAC;IACd,CAAC;CACJ;AA1CD,wCA0CC","sourcesContent":["import { verify, JwtPayload } from 'jsonwebtoken';\nimport { HttpUnauthorizedError, toError } from '@webpieces/core-util';\nimport { JwtHook } from './AuthHooks';\nimport { AuthenticatedCaller } from './AuthConfig';\n\n/**\n * DefaultJwtHook - a batteries-included {@link JwtHook} for the common case: HS256 user JWTs signed\n * with ONE shared secret. Construct it with the secret and bind it — `new DefaultJwtHook(secret)` —\n * and `@AuthJwt` endpoints work with NO custom verification code.\n *\n * `parseJwt` verifies the signature + expiry (jsonwebtoken, HS256 only) and maps standard claims:\n * `sub` → userId, a string[] `roles` claim → roles, the whole payload → claims. `authorizeJwt`\n * (role enforcement) is inherited from JwtHook. For RS256 + JWKS, a provider SDK, or a non-standard\n * payload, write your own JwtHook subclass instead.\n *\n * It satisfies {@link JwtHook}'s ASYNC signature with a body that awaits NOTHING, and that is the\n * point rather than an oversight: HS256 against a local secret is pure CPU. The signature is async\n * because the hook is the APP's seam and an app's strategy reaches the network — not because this\n * implementation does. No fake await is added to justify it.\n */\nexport class DefaultJwtHook extends JwtHook {\n    private readonly secret: string;\n\n    constructor(secret: string) {\n        super();\n        this.secret = secret;\n    }\n\n    override async parseJwt(token: string): Promise<AuthenticatedCaller> {\n        const payload = this.verifyToken(token);\n        const userId = payload.sub;\n        if (!userId) {\n            throw new HttpUnauthorizedError('JWT is missing the required \"sub\" (subject) claim');\n        }\n        return new AuthenticatedCaller(userId, this.extractRoles(payload), [], payload);\n    }\n\n    /** Verify HS256 signature + expiry; translate jsonwebtoken's raw error into a framework 401. */\n    private verifyToken(token: string): JwtPayload {\n        // eslint-disable-next-line @webpieces/no-unmanaged-exceptions -- AUTH TRANSLATION CHOKEPOINT: jsonwebtoken.verify throws on a bad/expired token; that must surface as a 401 Unauthorized, not bubble to the global handler as a 500. The original error is chained via cause.\n        try {\n            const decoded = verify(token, this.secret, { algorithms: ['HS256'] });\n            if (typeof decoded === 'string') {\n                throw new HttpUnauthorizedError('JWT payload must be a JSON object, not a string');\n            }\n            return decoded;\n        } catch (err: unknown) {\n            const error = toError(err);\n            if (error instanceof HttpUnauthorizedError) {\n                throw error;\n            }\n            throw new HttpUnauthorizedError('JWT verification failed', undefined, error);\n        }\n    }\n\n    private extractRoles(payload: JwtPayload): string[] {\n        const roles = payload['roles'];\n        if (Array.isArray(roles)) {\n            return roles.filter((role: string) => typeof role === 'string');\n        }\n        return [];\n    }\n}\n"]}

package/src/JwtHookCompileAssertions.js

@@ -24,7 +24,7 @@ class JwtHookCompileAssertions {
     legitimate() {
         void class extends AuthHooks_1.JwtHook {
             async parseJwt(_token) {
-                return new AuthConfig_1.AuthValues('u1');
+                return new AuthConfig_1.AuthenticatedCaller('u1');
             }
             async authorizeJwt(_values, _requirement) {
                 // An implementation that needs no I/O simply has no await — that is allowed and free.
@@ -34,14 +34,14 @@ class JwtHookCompileAssertions {
     /** The SYNC spellings — what every implementor wrote before — must now be UNWRITABLE. */
     rejected() {
         void class extends AuthHooks_1.JwtHook {
-            // @ts-expect-error parseJwt is async now: returning AuthValues instead of Promise<AuthValues> must not compile
+            // @ts-expect-error parseJwt is async now: returning AuthenticatedCaller instead of Promise<AuthenticatedCaller> must not compile
             parseJwt(_token) {
-                return new AuthConfig_1.AuthValues('u1');
+                return new AuthConfig_1.AuthenticatedCaller('u1');
             }
         };
         void class extends AuthHooks_1.JwtHook {
             async parseJwt(_token) {
-                return new AuthConfig_1.AuthValues('u1');
+                return new AuthConfig_1.AuthenticatedCaller('u1');
             }
             // @ts-expect-error authorizeJwt is async now: a void override must not compile either
             authorizeJwt(_values, _requirement) {

package/src/JwtHookCompileAssertions.js.map

@@ -1 +1 @@
-{"version":3,"file":"JwtHookCompileAssertions.js","sourceRoot":"","sources":["../../../../../packages/http/http-routing/src/JwtHookCompileAssertions.ts"],"names":[],"mappings":";;;AACA,2CAAsC;AACtC,6CAA0C;AAE1C;;;;;;;;;;;;;;;GAeG;AACH,MAAa,wBAAwB;IACjC,oFAAoF;IACpF,UAAU;QACN,KAAK,KAAM,SAAQ,mBAAO;YACb,KAAK,CAAC,QAAQ,CAAC,MAAc;gBAClC,OAAO,IAAI,uBAAU,CAAC,IAAI,CAAC,CAAC;YAChC,CAAC;YAEQ,KAAK,CAAC,YAAY,CAAC,OAAmB,EAAE,YAA4B;gBACzE,sFAAsF;YAC1F,CAAC;SACJ,CAAC;IACN,CAAC;IAED,yFAAyF;IACzF,QAAQ;QACJ,KAAK,KAAM,SAAQ,mBAAO;YACtB,+GAA+G;YACtG,QAAQ,CAAC,MAAc;gBAC5B,OAAO,IAAI,uBAAU,CAAC,IAAI,CAAC,CAAC;YAChC,CAAC;SACJ,CAAC;QACF,KAAK,KAAM,SAAQ,mBAAO;YACb,KAAK,CAAC,QAAQ,CAAC,MAAc;gBAClC,OAAO,IAAI,uBAAU,CAAC,IAAI,CAAC,CAAC;YAChC,CAAC;YAED,sFAAsF;YAC7E,YAAY,CAAC,OAAmB,EAAE,YAA4B;gBACnE,wEAAwE;YAC5E,CAAC;SACJ,CAAC;IACN,CAAC;CACJ;AAjCD,4DAiCC","sourcesContent":["import { JwtRequirement } from '@webpieces/core-util';\nimport { JwtHook } from './AuthHooks';\nimport { AuthValues } from './AuthConfig';\n\n/**\n * COMPILE-TIME assertions that {@link JwtHook} is ASYNC on BOTH halves, and that the old SYNC spelling\n * of either one no longer compiles. Each `@ts-expect-error` below FAILS THE BUILD (TS2578, \"unused\n * '@ts-expect-error' directive\") if the override it guards ever starts compiling again.\n *\n * WHY THIS IS NOT A `.spec.ts` FILE — the same reason as `core-util`'s `AuthJwtCompileAssertions.ts`:\n * tsconfig.lib.json EXCLUDES specs and vitest strips types with esbuild, so a `@ts-expect-error` in a\n * spec is inert and the suite passes either way. A type-level guarantee has to be asserted in a file\n * the type-checker actually compiles.\n *\n * WHY IT MATTERS HERE SPECIFICALLY. This repo ships no backwards-compatibility shims, so making the\n * hook async means every existing implementor's sync override must STOP COMPILING — the compile error\n * IS the migration. A sync `parseJwt` that kept compiling would be silently awaited to the same value\n * and the break would look optional, which is precisely how an old spelling survives. Pinning both\n * directions here means the async-ness cannot be quietly relaxed later either.\n */\nexport class JwtHookCompileAssertions {\n    /** The async spellings must keep compiling; asserted by the ABSENCE of an error. */\n    legitimate(): void {\n        void class extends JwtHook {\n            override async parseJwt(_token: string): Promise<AuthValues> {\n                return new AuthValues('u1');\n            }\n\n            override async authorizeJwt(_values: AuthValues, _requirement: JwtRequirement): Promise<void> {\n                // An implementation that needs no I/O simply has no await — that is allowed and free.\n            }\n        };\n    }\n\n    /** The SYNC spellings — what every implementor wrote before — must now be UNWRITABLE. */\n    rejected(): void {\n        void class extends JwtHook {\n            // @ts-expect-error parseJwt is async now: returning AuthValues instead of Promise<AuthValues> must not compile\n            override parseJwt(_token: string): AuthValues {\n                return new AuthValues('u1');\n            }\n        };\n        void class extends JwtHook {\n            override async parseJwt(_token: string): Promise<AuthValues> {\n                return new AuthValues('u1');\n            }\n\n            // @ts-expect-error authorizeJwt is async now: a void override must not compile either\n            override authorizeJwt(_values: AuthValues, _requirement: JwtRequirement): void {\n                // an app rule enforced synchronously — the spelling this change deletes\n            }\n        };\n    }\n}\n"]}
+{"version":3,"file":"JwtHookCompileAssertions.js","sourceRoot":"","sources":["../../../../../packages/http/http-routing/src/JwtHookCompileAssertions.ts"],"names":[],"mappings":";;;AACA,2CAAsC;AACtC,6CAAmD;AAEnD;;;;;;;;;;;;;;;GAeG;AACH,MAAa,wBAAwB;IACjC,oFAAoF;IACpF,UAAU;QACN,KAAK,KAAM,SAAQ,mBAAO;YACb,KAAK,CAAC,QAAQ,CAAC,MAAc;gBAClC,OAAO,IAAI,gCAAmB,CAAC,IAAI,CAAC,CAAC;YACzC,CAAC;YAEQ,KAAK,CAAC,YAAY,CAAC,OAA4B,EAAE,YAA4B;gBAClF,sFAAsF;YAC1F,CAAC;SACJ,CAAC;IACN,CAAC;IAED,yFAAyF;IACzF,QAAQ;QACJ,KAAK,KAAM,SAAQ,mBAAO;YACtB,iIAAiI;YACxH,QAAQ,CAAC,MAAc;gBAC5B,OAAO,IAAI,gCAAmB,CAAC,IAAI,CAAC,CAAC;YACzC,CAAC;SACJ,CAAC;QACF,KAAK,KAAM,SAAQ,mBAAO;YACb,KAAK,CAAC,QAAQ,CAAC,MAAc;gBAClC,OAAO,IAAI,gCAAmB,CAAC,IAAI,CAAC,CAAC;YACzC,CAAC;YAED,sFAAsF;YAC7E,YAAY,CAAC,OAA4B,EAAE,YAA4B;gBAC5E,wEAAwE;YAC5E,CAAC;SACJ,CAAC;IACN,CAAC;CACJ;AAjCD,4DAiCC","sourcesContent":["import { JwtRequirement } from '@webpieces/core-util';\nimport { JwtHook } from './AuthHooks';\nimport { AuthenticatedCaller } from './AuthConfig';\n\n/**\n * COMPILE-TIME assertions that {@link JwtHook} is ASYNC on BOTH halves, and that the old SYNC spelling\n * of either one no longer compiles. Each `@ts-expect-error` below FAILS THE BUILD (TS2578, \"unused\n * '@ts-expect-error' directive\") if the override it guards ever starts compiling again.\n *\n * WHY THIS IS NOT A `.spec.ts` FILE — the same reason as `core-util`'s `AuthJwtCompileAssertions.ts`:\n * tsconfig.lib.json EXCLUDES specs and vitest strips types with esbuild, so a `@ts-expect-error` in a\n * spec is inert and the suite passes either way. A type-level guarantee has to be asserted in a file\n * the type-checker actually compiles.\n *\n * WHY IT MATTERS HERE SPECIFICALLY. This repo ships no backwards-compatibility shims, so making the\n * hook async means every existing implementor's sync override must STOP COMPILING — the compile error\n * IS the migration. A sync `parseJwt` that kept compiling would be silently awaited to the same value\n * and the break would look optional, which is precisely how an old spelling survives. Pinning both\n * directions here means the async-ness cannot be quietly relaxed later either.\n */\nexport class JwtHookCompileAssertions {\n    /** The async spellings must keep compiling; asserted by the ABSENCE of an error. */\n    legitimate(): void {\n        void class extends JwtHook {\n            override async parseJwt(_token: string): Promise<AuthenticatedCaller> {\n                return new AuthenticatedCaller('u1');\n            }\n\n            override async authorizeJwt(_values: AuthenticatedCaller, _requirement: JwtRequirement): Promise<void> {\n                // An implementation that needs no I/O simply has no await — that is allowed and free.\n            }\n        };\n    }\n\n    /** The SYNC spellings — what every implementor wrote before — must now be UNWRITABLE. */\n    rejected(): void {\n        void class extends JwtHook {\n            // @ts-expect-error parseJwt is async now: returning AuthenticatedCaller instead of Promise<AuthenticatedCaller> must not compile\n            override parseJwt(_token: string): AuthenticatedCaller {\n                return new AuthenticatedCaller('u1');\n            }\n        };\n        void class extends JwtHook {\n            override async parseJwt(_token: string): Promise<AuthenticatedCaller> {\n                return new AuthenticatedCaller('u1');\n            }\n\n            // @ts-expect-error authorizeJwt is async now: a void override must not compile either\n            override authorizeJwt(_values: AuthenticatedCaller, _requirement: JwtRequirement): void {\n                // an app rule enforced synchronously — the spelling this change deletes\n            }\n        };\n    }\n}\n"]}

package/src/filters/AuthFilter.d.ts

@@ -50,8 +50,19 @@ export declare class AuthFilter extends Filter<MethodMeta, WpResponse<unknown>>
      *    an in-process caller (a spec) that published an HttpRequest with no {@link RawRequest}. The
      *    message says which fix applies rather than leaving a bare 401.
      * 3. The hook threw — the signature did not verify.
+     *
+     * Case 2 is checked HERE and nowhere else. {@link hasRawBytes} narrows the request to
+     * {@link RawHttpRequest} at this one gate, so the hook's signature promises `raw` is present and
+     * no vendor implementation ever writes `raw!` or a guard of its own.
      */
     private enforceWebhook;
+    /**
+     * The ONE place the framework decides a request carries the verbatim bytes. A TYPE PREDICATE, so
+     * the `true` branch hands {@link enforceWebhook} a {@link RawHttpRequest} with no cast and no
+     * non-null assertion — the bad state stops being representable past this line rather than being
+     * re-thrown about by every hook.
+     */
+    private hasRawBytes;
     /**
      * `@AuthApiKey(name)`: hand the app's {@link ApiKeyHook} the regime name and the inbound headers and
      * let it look the CUSTOMER's key up. Three ways to fail, all 401, all before the controller:
@@ -63,8 +74,8 @@ export declare class AuthFilter extends Filter<MethodMeta, WpResponse<unknown>>
      *    than leaving a bare 401.
      * 3. The hook threw — the key, or the key/organization pair, did not check out.
      *
-     * On success the hook's {@link AuthValues} are stamped exactly as a jwt parse's are, which is what
-     * puts the resolved organization into `RequestContext` for every downstream repository call.
+     * On success the hook's {@link AuthenticatedCaller} is stamped exactly as a jwt parse's is, which is
+     * what puts the resolved organization into `RequestContext` for every downstream repository call.
      */
     private enforceApiKey;
     /**
@@ -119,7 +130,7 @@ export declare class AuthFilter extends Filter<MethodMeta, WpResponse<unknown>>
      * else is rejected — see {@link requireVouched}.
      *
      * Runs AFTER the mode enforcement above, because that is what stamps the authenticator's own
-     * values (`applyAuthValues`); comparing before it ran would compare against nothing.
+     * values (`applyAuthenticatedCaller`); comparing before it ran would compare against nothing.
      */
     private reconcileWireTrust;
     /**
@@ -164,8 +175,12 @@ export declare class AuthFilter extends Filter<MethodMeta, WpResponse<unknown>>
     private matchesEither;
     /** Parse a JWT if one is present, else do nothing — used on public routes; never throws. */
     private bestEffortJwt;
-    /** Stamp the authenticated caller's context entries + the principal into the RequestContext. */
-    private applyAuthValues;
+    /**
+     * Stamp the authenticated caller's context entries + the caller itself into the RequestContext.
+     * ONE path for all three authenticating hooks — jwt, api-key and webhook — so a vendor hook that
+     * proved which account a payload belongs to seeds context exactly as a JwtHook does.
+     */
+    private applyAuthenticatedCaller;
     /**
      * The credential value IF the header carries the expected scheme, else undefined.
      *

package/src/filters/AuthFilter.js

@@ -31,8 +31,6 @@ const AUTHORIZATION_HEADER = 'authorization';
  */
 const BEARER_SCHEME = 'Bearer';
 const SHARED_SECRET_SCHEME = 'Webpieces';
-/** Reserved context key holding the authenticated {@link AuthValues} (stamped after a jwt parse). */
-const PRINCIPAL_KEY = '__webpieces_principal__';
 /**
  * AuthFilter - the ONE framework auth filter, auto-installed just below the error filter on every
  * route. It is TRANSPORT-NEUTRAL: it reads the raw credential from the {@link HttpRequest} in
@@ -122,6 +120,10 @@ let AuthFilter = AuthFilter_1 = class AuthFilter extends Filter_1.Filter {
      *    an in-process caller (a spec) that published an HttpRequest with no {@link RawRequest}. The
      *    message says which fix applies rather than leaving a bare 401.
      * 3. The hook threw — the signature did not verify.
+     *
+     * Case 2 is checked HERE and nowhere else. {@link hasRawBytes} narrows the request to
+     * {@link RawHttpRequest} at this one gate, so the hook's signature promises `raw` is present and
+     * no vendor implementation ever writes `raw!` or a guard of its own.
      */
     async enforceWebhook(name, meta) {
         if (!this.webhookAuthCallback) {
@@ -130,14 +132,25 @@ let AuthFilter = AuthFilter_1 = class AuthFilter extends Filter_1.Filter {
             throw new core_util_1.HttpUnauthorizedError('Webhook auth is not enabled on this server');
         }
         const request = core_context_1.RequestContext.getRequest();
-        const raw = request?.raw;
-        if (!request || !raw) {
+        if (!this.hasRawBytes(request)) {
             log.warn(`Refusing @AuthWebhook('${name}') endpoint ${meta.routeMeta.path}: the inbound request carries ` +
                 `no raw bytes. Declare @Endpoint(path, 'external', { calledBy: '${name}', rawBody: true }); a ` +
                 `spec driving this route in-process must publish an HttpRequest built with a RawRequest.`);
             throw new core_util_1.HttpUnauthorizedError('Webhook signature cannot be verified: no raw request was retained');
         }
-        await this.webhookAuthCallback.verify(name, request, raw); // throws HttpUnauthorizedError to deny
+        // Throws HttpUnauthorizedError to deny. On success the vendor account the signature proved is
+        // stamped through the SAME path a jwt or api-key caller takes.
+        const caller = await this.webhookAuthCallback.verifyWebhook(name, request);
+        this.applyAuthenticatedCaller(caller);
+    }
+    /**
+     * The ONE place the framework decides a request carries the verbatim bytes. A TYPE PREDICATE, so
+     * the `true` branch hands {@link enforceWebhook} a {@link RawHttpRequest} with no cast and no
+     * non-null assertion — the bad state stops being representable past this line rather than being
+     * re-thrown about by every hook.
+     */
+    hasRawBytes(request) {
+        return request?.raw !== undefined;
     }
     /**
      * `@AuthApiKey(name)`: hand the app's {@link ApiKeyHook} the regime name and the inbound headers and
@@ -150,8 +163,8 @@ let AuthFilter = AuthFilter_1 = class AuthFilter extends Filter_1.Filter {
      *    than leaving a bare 401.
      * 3. The hook threw — the key, or the key/organization pair, did not check out.
      *
-     * On success the hook's {@link AuthValues} are stamped exactly as a jwt parse's are, which is what
-     * puts the resolved organization into `RequestContext` for every downstream repository call.
+     * On success the hook's {@link AuthenticatedCaller} is stamped exactly as a jwt parse's is, which is
+     * what puts the resolved organization into `RequestContext` for every downstream repository call.
      */
     async enforceApiKey(name, meta) {
         if (!this.apiKeyHook) {
@@ -166,9 +179,10 @@ let AuthFilter = AuthFilter_1 = class AuthFilter extends Filter_1.Filter {
                 `publish an HttpRequest carrying the api-key headers.`);
             throw new core_util_1.HttpUnauthorizedError('API key cannot be verified: no inbound request was published');
         }
-        // Throws HttpUnauthorizedError to deny. HttpRequest satisfies HeaderReader structurally.
-        const values = await this.apiKeyHook.verifyApiKey(name, request);
-        this.applyAuthValues(values);
+        // Throws HttpUnauthorizedError to deny. The hook gets the WHOLE request so it can cross-check
+        // the key against a second header (the organization the customer is acting for).
+        const caller = await this.apiKeyHook.verifyApiKey(name, request);
+        this.applyAuthenticatedCaller(caller);
     }
     /**
      * A body that failed to parse is held on the {@link RawRequest} and surfaces HERE, after auth, as
@@ -228,7 +242,7 @@ let AuthFilter = AuthFilter_1 = class AuthFilter extends Filter_1.Filter {
             // `apikey` authenticates the SENDER — but the sender is a CUSTOMER's codebase, not a peer
             // service in this repo, so its forwarded trusted context is exactly what must NOT be
             // believed: admitting it would let a partner assert another customer's org id on the wire.
-            // The hook's OWN derived entries still land (applyAuthValues), and reconcileWireTrust then
+            // The hook's OWN derived entries still land (applyAuthenticatedCaller), and reconcileWireTrust then
             // admits an inbound trusted header only when the hook independently derived the same value.
             case 'apikey':
             case 'local-only':
@@ -250,7 +264,7 @@ let AuthFilter = AuthFilter_1 = class AuthFilter extends Filter_1.Filter {
      * else is rejected — see {@link requireVouched}.
      *
      * Runs AFTER the mode enforcement above, because that is what stamps the authenticator's own
-     * values (`applyAuthValues`); comparing before it ran would compare against nothing.
+     * values (`applyAuthenticatedCaller`); comparing before it ran would compare against nothing.
      */
     reconcileWireTrust(callerVerified) {
         const pending = core_context_1.PendingWireTrust.takeAll();
@@ -325,9 +339,9 @@ let AuthFilter = AuthFilter_1 = class AuthFilter extends Filter_1.Filter {
         if (!this.jwtHook) {
             throw new core_util_1.HttpUnauthorizedError('User-JWT auth is not enabled on this server');
         }
-        const values = await this.jwtHook.parseJwt(token); // AUTHENTICATE — throws HttpUnauthorizedError if invalid
-        this.applyAuthValues(values);
-        await this.jwtHook.authorizeJwt(values, requirement); // AUTHORIZE — app policy; throws HttpForbiddenError to deny
+        const caller = await this.jwtHook.parseJwt(token); // AUTHENTICATE — throws HttpUnauthorizedError if invalid
+        this.applyAuthenticatedCaller(caller);
+        await this.jwtHook.authorizeJwt(caller, requirement); // AUTHORIZE — app policy; throws HttpForbiddenError to deny
     }
     async enforceOidc(header, callers) {
         const token = this.credential(header, BEARER_SCHEME);
@@ -362,21 +376,27 @@ let AuthFilter = AuthFilter_1 = class AuthFilter extends Filter_1.Filter {
         }
         // eslint-disable-next-line @webpieces/no-unmanaged-exceptions -- best-effort on a public route: a bad/absent token just means "not logged in", must not fail the request
         try {
-            this.applyAuthValues(await this.jwtHook.parseJwt(token));
+            this.applyAuthenticatedCaller(await this.jwtHook.parseJwt(token));
         }
         catch (err) {
             const error = (0, core_util_1.toError)(err);
             log.debug('Best-effort JWT parse on a public endpoint failed (treating as anonymous): ', error);
         }
     }
-    /** Stamp the authenticated caller's context entries + the principal into the RequestContext. */
-    applyAuthValues(values) {
-        for (const entry of values.entries) {
+    /**
+     * Stamp the authenticated caller's context entries + the caller itself into the RequestContext.
+     * ONE path for all three authenticating hooks — jwt, api-key and webhook — so a vendor hook that
+     * proved which account a payload belongs to seeds context exactly as a JwtHook does.
+     */
+    applyAuthenticatedCaller(caller) {
+        for (const entry of caller.entries) {
             // ContextTuple.key is a TRUSTED key by type, so this is the one sanctioned write of a
-            // proven identity: the app's JwtHook or ApiKeyHook derived it from a credential we just verified.
+            // proven identity: the app's hook derived it from a credential we just verified.
             core_context_1.RequestContext.putTrusted(entry.key, entry.value);
         }
-        core_context_1.RequestContext.put(PRINCIPAL_KEY, values);
+        // A real TRUSTED ContextKey, not a raw string slot: the caller IS the framework's own proof,
+        // so it is written with the same typed verb every other proven value goes through.
+        core_context_1.RequestContext.putTrusted(AuthConfig_1.AUTHENTICATED_CALLER_KEY, caller);
     }
     /**
      * The credential value IF the header carries the expected scheme, else undefined.

package/src/filters/AuthFilter.js.map

@@ -1 +1 @@
-{"version":3,"file":"AuthFilter.js","sourceRoot":"","sources":["../../../../../../packages/http/http-routing/src/filters/AuthFilter.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, optional } from 'inversify';\nimport { timingSafeEqual } from 'crypto';\nimport { provideFrameworkSingleton, PendingWireTrust, PendingTrustedValue, RequestContext } from '@webpieces/core-context';\nimport { AuthMode, EndpointNotFoundError, HttpBadRequestError, HttpUnauthorizedError, JwtRequirement, LogManager, RuntimeLocality, toError } from '@webpieces/core-util';\nimport { Filter, WpResponse, Service } from '../Filter';\nimport { MethodMeta } from '../MethodMeta';\nimport { AuthConfig, AUTH_CONFIG, AuthValues, SharedSecrets } from '../AuthConfig';\nimport { ApiKeyHook, API_KEY_HOOK, JwtHook, JWT_HOOK, OidcHook, OIDC_HOOK, WebhookAuthCallback, WEBHOOK_AUTH_CALLBACK } from '../AuthHooks';\nimport { DefaultOidcVerifier } from '../DefaultOidcVerifier';\n\nconst log = LogManager.getLogger('AuthFilter');\n\n/**\n * The ONE credential header, read straight off the inbound HttpRequest.\n *\n * Deliberately NOT a ContextKey: a ContextKey with an httpHeader is a TRANSFERRED key, which would\n * put the caller's credential into RequestContext and hence onto every outbound call this service\n * makes, and onto every Cloud Task it enqueues. A credential belongs to ONE request hop.\n */\nconst AUTHORIZATION_HEADER = 'authorization';\n\n/**\n * The scheme (first word of the Authorization value) names WHICH credential follows, so a secret\n * can never be mistaken for a token, nor accepted where the other was expected:\n *\n *   Authorization: Bearer <user JWT | service OIDC token>\n *   Authorization: Webpieces <@AuthSharedSecret value>\n *\n * The scheme is REQUIRED. A bare value with no scheme is rejected.\n */\nconst BEARER_SCHEME = 'Bearer';\nconst SHARED_SECRET_SCHEME = 'Webpieces';\n\n/** Reserved context key holding the authenticated {@link AuthValues} (stamped after a jwt parse). */\nconst PRINCIPAL_KEY = '__webpieces_principal__';\n\n/**\n * AuthFilter - the ONE framework auth filter, auto-installed just below the error filter on every\n * route. It is TRANSPORT-NEUTRAL: it reads the raw credential from the {@link HttpRequest} in\n * RequestContext (never express), so the SAME check runs over HTTP and via createApiClient.\n *\n * It enforces the endpoint's AuthMode from separately-bound pieces, each OPTIONAL except the OIDC\n * default:\n *  - shared-secret → constant-time compare vs the {@link AuthConfig} secret VALUE (state). No\n *                    AuthConfig bound → no accepted secret → fail fast (401).\n *  - jwt           → the bound {@link JwtHook} (`parseJwt` + `authorizeJwt`, both awaited — an app's\n *                    strategy may reach a JWKS or a datastore). No JwtHook bound → \"not enabled\"\n *                    (401): JWT needs an app secret + payload shape.\n *  - oidc          → the bound {@link OidcHook} if any, else the framework {@link DefaultOidcVerifier}\n *                    run DIRECTLY — so a server that wires NOTHING still verifies Google OIDC.\n *  - webhook       → the bound {@link WebhookAuthCallback} verifies the VENDOR's signature over the retained\n *                    raw request. No WebhookAuthCallback bound → 401, like jwt: an unverified webhook is\n *                    never waved through because wiring was forgotten.\n *  - apikey        → the bound {@link ApiKeyHook} looks the CUSTOMER's key up (async, over the whole\n *                    header set) and returns the context to seed. No ApiKeyHook bound → 401, like jwt.\n *  - public        → BEST-EFFORT jwt parse (only if a JwtHook is bound): stamp the user's context so\n *                    a logged-out page still knows who is logged in; never fails.\n *  - local-only    → serve only when {@link RuntimeLocality} says this process is a developer's\n *                    machine; otherwise 404, indistinguishable from the route not existing (which,\n *                    off-local, it does not — `ApiRoutingFactory` never registered it).\n *\n * Zero wiring = OIDC just works; an app only binds the hooks it actually uses.\n */\n@provideFrameworkSingleton()\n// webpieces-disable no-any-unknown -- Filter generic params use unknown for response flexibility\nexport class AuthFilter extends Filter<MethodMeta, WpResponse<unknown>> {\n    constructor(\n        // Framework default, always available — verifies Google OIDC with zero app wiring.\n        // webpieces-disable inject-annotation-not-needed-for-concrete-class -- AuthFilter is DI-resolved via the esbuild/vitest path, which elides type-only imports (no design:paramtypes), so every param needs its explicit token\n        @inject(DefaultOidcVerifier) private readonly oidcVerifier: DefaultOidcVerifier,\n        // @optional: only bind an AuthConfig to enable @AuthSharedSecret endpoints.\n        // webpieces-disable inject-annotation-not-needed-for-concrete-class -- see above: explicit token required for DI-resolved param\n        @optional() @inject(AUTH_CONFIG) private readonly authConfig?: AuthConfig,\n        // @optional: only bind a JwtHook to enable @AuthJwt endpoints.\n        // webpieces-disable inject-annotation-not-needed-for-concrete-class -- see above: explicit token required for DI-resolved param\n        @optional() @inject(JWT_HOOK) private readonly jwtHook?: JwtHook,\n        // @optional: only bind an OidcHook to OVERRIDE the DefaultOidcVerifier caller policy.\n        // webpieces-disable inject-annotation-not-needed-for-concrete-class -- see above: explicit token required for DI-resolved param\n        @optional() @inject(OIDC_HOOK) private readonly oidcHook?: OidcHook,\n        // @optional: only bind a WebhookAuthCallback to enable @AuthWebhook endpoints. Unbound = every such\n        // endpoint 401s, which is the ONE default that must not be the other way round.\n        // webpieces-disable inject-annotation-not-needed-for-concrete-class -- see above: explicit token required for DI-resolved param\n        @optional() @inject(WEBHOOK_AUTH_CALLBACK) private readonly webhookAuthCallback?: WebhookAuthCallback,\n        // @optional: only bind an ApiKeyHook to enable @AuthApiKey endpoints. Unbound = every such\n        // endpoint 401s, for the same reason as the webhook hook above.\n        // webpieces-disable inject-annotation-not-needed-for-concrete-class -- see above: explicit token required for DI-resolved param\n        @optional() @inject(API_KEY_HOOK) private readonly apiKeyHook?: ApiKeyHook,\n    ) {\n        super();\n    }\n\n    // webpieces-disable no-any-unknown -- Filter generic params use unknown for response flexibility\n    override async filter(\n        meta: MethodMeta,\n        nextFilter: Service<MethodMeta, WpResponse<unknown>>,\n    ): Promise<WpResponse<unknown>> {\n        const mode = meta.routeMeta.authMeta?.mode;\n        const authHeader = RequestContext.getRequest()?.getHeader(AUTHORIZATION_HEADER);\n\n        if (!mode || mode.kind === 'public') {\n            // Public: best-effort parse so a logged-out page can still know the logged-in user.\n            await this.bestEffortJwt(authHeader);\n            this.reconcileWireTrust(/*callerVerified*/ false);\n            this.rethrowDeferredBodyError();\n            return nextFilter.invoke(meta);\n        }\n\n        switch (mode.kind) {\n            case 'jwt':\n                await this.enforceJwt(authHeader, mode.requirement);\n                break;\n            case 'oidc':\n                await this.enforceOidc(authHeader, mode.callers);\n                break;\n            case 'shared-secret':\n                this.enforceSharedSecret(this.credential(authHeader, SHARED_SECRET_SCHEME), mode.secretKey);\n                break;\n            case 'webhook':\n                await this.enforceWebhook(mode.name, meta);\n                break;\n            case 'apikey':\n                await this.enforceApiKey(mode.name, meta);\n                break;\n            case 'local-only':\n                this.enforceLocalOnly(meta);\n                break;\n        }\n        this.reconcileWireTrust(AuthFilter.verifiesCaller(mode));\n        this.rethrowDeferredBodyError();\n        return nextFilter.invoke(meta);\n    }\n\n    /**\n     * `@AuthWebhook(name)`: hand the app's {@link WebhookAuthCallback} the verbatim request and let it call the\n     * VENDOR's own validator. Three ways to fail, all 401, all before the controller is entered:\n     *\n     * 1. NO hook bound — the endpoint is not enabled. Matches {@link JwtHook}'s documented behavior;\n     *    an unverified webhook must never be waved through because wiring was forgotten.\n     * 2. NO raw request — the transport kept no bytes. `assertEveryWebhookEndpointRetainsRawBody`\n     *    normally makes this a startup error, so reaching it means either a hand-registered route or\n     *    an in-process caller (a spec) that published an HttpRequest with no {@link RawRequest}. The\n     *    message says which fix applies rather than leaving a bare 401.\n     * 3. The hook threw — the signature did not verify.\n     */\n    private async enforceWebhook(name: string, meta: MethodMeta): Promise<void> {\n        if (!this.webhookAuthCallback) {\n            log.warn(\n                `Refusing @AuthWebhook('${name}') endpoint ${meta.routeMeta.path}: no WebhookAuthCallback is bound. ` +\n                `Bind one (options.bind(WEBHOOK_AUTH_CALLBACK).to(YourWebhookAuthCallback)) to enable webhook verification.`,\n            );\n            throw new HttpUnauthorizedError('Webhook auth is not enabled on this server');\n        }\n        const request = RequestContext.getRequest();\n        const raw = request?.raw;\n        if (!request || !raw) {\n            log.warn(\n                `Refusing @AuthWebhook('${name}') endpoint ${meta.routeMeta.path}: the inbound request carries ` +\n                `no raw bytes. Declare @Endpoint(path, 'external', { calledBy: '${name}', rawBody: true }); a ` +\n                `spec driving this route in-process must publish an HttpRequest built with a RawRequest.`,\n            );\n            throw new HttpUnauthorizedError('Webhook signature cannot be verified: no raw request was retained');\n        }\n        await this.webhookAuthCallback.verify(name, request, raw); // throws HttpUnauthorizedError to deny\n    }\n\n    /**\n     * `@AuthApiKey(name)`: hand the app's {@link ApiKeyHook} the regime name and the inbound headers and\n     * let it look the CUSTOMER's key up. Three ways to fail, all 401, all before the controller:\n     *\n     * 1. NO hook bound — the endpoint is not enabled. Matches {@link JwtHook}'s documented behavior; an\n     *    unverified partner request must never be waved through because wiring was forgotten.\n     * 2. NO inbound request in scope — there are no headers to read, so there is nothing to verify. That\n     *    means a caller drove this route without publishing an HttpRequest; the message says so rather\n     *    than leaving a bare 401.\n     * 3. The hook threw — the key, or the key/organization pair, did not check out.\n     *\n     * On success the hook's {@link AuthValues} are stamped exactly as a jwt parse's are, which is what\n     * puts the resolved organization into `RequestContext` for every downstream repository call.\n     */\n    private async enforceApiKey(name: string, meta: MethodMeta): Promise<void> {\n        if (!this.apiKeyHook) {\n            log.warn(\n                `Refusing @AuthApiKey('${name}') endpoint ${meta.routeMeta.path}: no ApiKeyHook is bound. ` +\n                `Bind one (options.bind(API_KEY_HOOK).to(YourApiKeyHook)) to enable api-key verification.`,\n            );\n            throw new HttpUnauthorizedError('API-key auth is not enabled on this server');\n        }\n        const request = RequestContext.getRequest();\n        if (!request) {\n            log.warn(\n                `Refusing @AuthApiKey('${name}') endpoint ${meta.routeMeta.path}: no inbound HttpRequest is ` +\n                `in scope, so the hook has no headers to read. A spec driving this route in-process must ` +\n                `publish an HttpRequest carrying the api-key headers.`,\n            );\n            throw new HttpUnauthorizedError('API key cannot be verified: no inbound request was published');\n        }\n        // Throws HttpUnauthorizedError to deny. HttpRequest satisfies HeaderReader structurally.\n        const values = await this.apiKeyHook.verifyApiKey(name, request);\n        this.applyAuthValues(values);\n    }\n\n    /**\n     * A body that failed to parse is held on the {@link RawRequest} and surfaces HERE, after auth, as\n     * the 400 it always was — never before it.\n     *\n     * The order is the whole point. A malformed body from an unauthenticated caller must answer 401,\n     * because \"your JSON was bad\" also says \"I got past auth\", and on a webhook endpoint — whose url\n     * is public by construction — that is a free oracle for anyone probing. Parsing first made the\n     * framework hand that out for nothing.\n     *\n     * Only routes that retain raw bytes can defer at all; every other route still fails at parse time\n     * in the transport, exactly as before.\n     */\n    private rethrowDeferredBodyError(): void {\n        const parseError = RequestContext.getRequest()?.raw?.bodyParseError;\n        if (parseError) {\n            throw new HttpBadRequestError('Request body is not valid JSON', undefined, undefined, parseError);\n        }\n    }\n\n    /**\n     * Does this mode authenticate the CALLER ITSELF (as opposed to a user, or nobody)? The INBOUND\n     * twin of {@link DestinationTrust.forAuthMode}, and deliberately the same question: the client\n     * omits trusted keys for a destination that cannot verify it, and the server rejects trusted keys\n     * on a route that cannot verify the sender. One rule, two ends — if they disagreed, every call\n     * would fail with a 401 that looks like a framework bug.\n     *\n     * - `oidc` / `shared-secret` → TRUE. An internal service is on the other end and the trusted\n     *   context it forwarded may be believed. This is what makes cross-service identity propagation\n     *   work.\n     * - `jwt` / `public` → FALSE. A user JWT proves who the USER is; the SENDER is still whoever\n     *   holds the token, i.e. a browser.\n     * - `local-only` → FALSE. It verifies WHERE WE ARE RUNNING, not who is calling — anything on\n     *   localhost reaches it, and it has no authenticator, so nothing can ever vouch for an inbound\n     *   trusted header. Any such header therefore rejects the request, which is exactly right.\n     *\n     * - `apikey` → FALSE. See the comment on that branch: the sender is a CUSTOMER.\n     *\n     * An exhaustive switch with NO `default`, returning on every branch: a new AuthMode kind is a\n     * COMPILE error here (TS7030, no ending return) rather than silently landing on one posture. The\n     * boolean expression this replaced defaulted every future mode to \"not verified\" — the safe\n     * answer, but arrived at by accident rather than by decision.\n     */\n    // webpieces-disable no-function-outside-class -- static pure mapping from the AuthMode union, kept beside its only caller (mirrors DestinationTrust.forAuthMode)\n    private static verifiesCaller(mode: AuthMode): boolean {\n        switch (mode.kind) {\n            case 'oidc':\n            case 'shared-secret':\n                return true;\n            case 'jwt':\n            case 'public':\n            // `webhook` DOES authenticate its sender — but the sender is an outside VENDOR, not a\n            // peer in this repo, and a vendor neither speaks nor forwards webpieces context headers.\n            // So there is no forwarded identity to believe, and admitting one would mean trusting a\n            // key a vendor's payload could carry. Same answer as the OUTBOUND half\n            // (DestinationTrust.forAuthMode), which is the invariant that keeps the two ends agreeing.\n            case 'webhook':\n            // `apikey` authenticates the SENDER — but the sender is a CUSTOMER's codebase, not a peer\n            // service in this repo, so its forwarded trusted context is exactly what must NOT be\n            // believed: admitting it would let a partner assert another customer's org id on the wire.\n            // The hook's OWN derived entries still land (applyAuthValues), and reconcileWireTrust then\n            // admits an inbound trusted header only when the hook independently derived the same value.\n            case 'apikey':\n            case 'local-only':\n                return false;\n        }\n    }\n\n    /**\n     * Decide what happens to the trusted keys that arrived on the WIRE and were held back by\n     * {@link PendingWireTrust} (read that class for why they are held rather than written).\n     *\n     * `callerVerified` — the endpoint authenticated the SENDER **as a peer service** (`@AuthOidc`,\n     * `@AuthSharedSecret`).\n     * The sender is a service we trust, this is the service-to-service hop, and its forwarded\n     * identity is admitted as-is. This is the case that makes propagating a verified userId across\n     * internal services work.\n     *\n     * Otherwise the sender is a browser or anyone else with curl, and the ONLY acceptable inbound\n     * trusted value is one the authenticator independently derived to the same value. Everything\n     * else is rejected — see {@link requireVouched}.\n     *\n     * Runs AFTER the mode enforcement above, because that is what stamps the authenticator's own\n     * values (`applyAuthValues`); comparing before it ran would compare against nothing.\n     */\n    private reconcileWireTrust(callerVerified: boolean): void {\n        const pending = PendingWireTrust.takeAll();\n        for (const item of pending) {\n            if (callerVerified) {\n                RequestContext.putTrusted(item.key, item.value);\n            } else {\n                this.requireVouched(item);\n            }\n        }\n    }\n\n    /**\n     * On a browser-reachable route, an inbound trusted header must match what the authenticator\n     * itself derived, or the request dies. Both failure shapes are rejections, not repairs:\n     *\n     * - DIFFERENT value — the caller said `alice`, the credential says `bob`. Silently letting the\n     *   credential win is not safe, because upstream rate limiters commonly bucket on the header\n     *   rather than the token: the request was already counted against the wrong principal, so\n     *   every forged header would be a free rate-limit bypass. No honest caller contradicts its own\n     *   credential.\n     * - NOTHING vouched for it — nobody derived this key at all, so there is no evidence behind a\n     *   value a stranger typed. This is the common case, not the exotic one: the framework's\n     *   {@link DefaultJwtHook} stamps NO entries, and an app hook (jwt or api-key) only stamps the keys it can prove,\n     *   so any other trusted key a caller sends lands here.\n     *\n     * The pending value is discarded either way — the throw is what leaves the request.\n     */\n    private requireVouched(item: PendingTrustedValue): void {\n        const vouched = RequestContext.getTrusted(item.key);\n        if (vouched === item.value) {\n            return;\n        }\n        log.error(\n            `Rejecting inbound '${item.key.httpHeader}': it is a TRUSTED context key, this route does ` +\n            `not authenticate its caller, and the credential ` +\n            (vouched === undefined ? 'vouched for no such value' : 'derived a different value') + '.',\n        );\n        throw new HttpUnauthorizedError(\n            `Header '${item.key.httpHeader}' cannot be supplied by the caller on this endpoint`,\n        );\n    }\n\n    /**\n     * `@AuthLocalOnly`: serve only on a developer's machine, and off-local behave EXACTLY as if the\n     * endpoint did not exist.\n     *\n     * WHY 404 AND NOT THE 403 APPS HAND-ROLLED. Off-local the route is not registered at all\n     * (`ApiRoutingFactory` skips it), so the ordinary way to reach this path already answers 404. A\n     * 403 from here would be a DIFFERENT answer from the same framework for the same endpoint, and\n     * the difference is itself the leak: 403 confirms \"this path exists in production, you merely\n     * lack permission\", which is a map of the dev-only surface for anyone probing. A local-only\n     * endpoint should not admit it exists. Both gates therefore return the same 404, and this one is\n     * the backstop for routes registered by hand through `RouteBuilder` rather than by\n     * `ApiRoutingFactory`.\n     *\n     * The log line names WHICH reason applies, because \"you are deployed\" and \"nobody declared a\n     * locality\" have completely different fixes and both look like a bare 404 from outside.\n     */\n    private enforceLocalOnly(meta: MethodMeta): void {\n        if (RuntimeLocality.isLocalDevelopment()) {\n            return;\n        }\n        log.warn(\n            `Refusing @AuthLocalOnly endpoint ${meta.routeMeta.path}: ` +\n            (RuntimeLocality.isDeclared()\n                ? 'this process declared itself DEPLOYED.'\n                : 'no startup declared a RuntimeLocality, so this process is treated as DEPLOYED. ' +\n                  'Pass the locality into RuntimeSetupOptions if this really is a developer machine.'),\n        );\n        // Same shape as an unregistered route — see the method doc for why this is not a 403.\n        throw new EndpointNotFoundError(`No endpoint at ${meta.routeMeta.path}`);\n    }\n\n    private async enforceJwt(header: string | undefined, requirement: JwtRequirement): Promise<void> {\n        const token = this.credential(header, BEARER_SCHEME);\n        if (!token) {\n            throw new HttpUnauthorizedError('Authentication required');\n        }\n        if (!this.jwtHook) {\n            throw new HttpUnauthorizedError('User-JWT auth is not enabled on this server');\n        }\n        const values = await this.jwtHook.parseJwt(token); // AUTHENTICATE — throws HttpUnauthorizedError if invalid\n        this.applyAuthValues(values);\n        await this.jwtHook.authorizeJwt(values, requirement); // AUTHORIZE — app policy; throws HttpForbiddenError to deny\n    }\n\n    private async enforceOidc(header: string | undefined, callers: string[]): Promise<void> {\n        const token = this.credential(header, BEARER_SCHEME);\n        if (!token) {\n            throw new HttpUnauthorizedError('Missing OIDC bearer token for @AuthOidc endpoint');\n        }\n        // App-bound OidcHook overrides the caller policy; otherwise the framework default runs directly.\n        if (this.oidcHook) {\n            await this.oidcHook.verifyOidc(token, callers);\n        } else {\n            await this.oidcVerifier.verify(token, callers);\n        }\n    }\n\n    /** `provided` is the Authorization bearer value — the secret itself, same header as a JWT. */\n    private enforceSharedSecret(provided: string | undefined, secretKey: string): void {\n        const accepted = this.authConfig?.sharedSecrets[secretKey];\n        if (!accepted || !provided || !this.matchesEither(provided, accepted)) {\n            throw new HttpUnauthorizedError('Invalid shared secret for @AuthSharedSecret endpoint');\n        }\n    }\n\n    /** EITHER secret1 or secret2 passes — the rotation window. Constant-time on each non-empty slot. */\n    private matchesEither(provided: string, accepted: SharedSecrets): boolean {\n        return (\n            (accepted.secret1 !== '' && this.constantTimeEquals(provided, accepted.secret1)) ||\n            (accepted.secret2 !== '' && this.constantTimeEquals(provided, accepted.secret2))\n        );\n    }\n\n    /** Parse a JWT if one is present, else do nothing — used on public routes; never throws. */\n    private async bestEffortJwt(header: string | undefined): Promise<void> {\n        const token = this.credential(header, BEARER_SCHEME);\n        if (!this.jwtHook || !token) {\n            return;\n        }\n        // eslint-disable-next-line @webpieces/no-unmanaged-exceptions -- best-effort on a public route: a bad/absent token just means \"not logged in\", must not fail the request\n        try {\n            this.applyAuthValues(await this.jwtHook.parseJwt(token));\n        } catch (err: unknown) {\n            const error = toError(err);\n            log.debug('Best-effort JWT parse on a public endpoint failed (treating as anonymous): ', error);\n        }\n    }\n\n    /** Stamp the authenticated caller's context entries + the principal into the RequestContext. */\n    private applyAuthValues(values: AuthValues): void {\n        for (const entry of values.entries) {\n            // ContextTuple.key is a TRUSTED key by type, so this is the one sanctioned write of a\n            // proven identity: the app's JwtHook or ApiKeyHook derived it from a credential we just verified.\n            RequestContext.putTrusted(entry.key, entry.value);\n        }\n        RequestContext.put(PRINCIPAL_KEY, values);\n    }\n\n    /**\n     * The credential value IF the header carries the expected scheme, else undefined.\n     *\n     * Strict: a bare value with no scheme, or a value under the WRONG scheme (a shared secret sent\n     * where a JWT is expected), yields undefined and the caller 401s.\n     */\n    private credential(header: string | undefined, scheme: string): string | undefined {\n        if (!header) {\n            return undefined;\n        }\n        const prefix = `${scheme} `;\n        return header.startsWith(prefix) ? header.substring(prefix.length) : undefined;\n    }\n\n    private constantTimeEquals(a: string, b: string): boolean {\n        const bufA = Buffer.from(a, 'utf8');\n        const bufB = Buffer.from(b, 'utf8');\n        if (bufA.length !== bufB.length) {\n            return false;\n        }\n        return timingSafeEqual(bufA, bufB);\n    }\n}\n"]}
+{"version":3,"file":"AuthFilter.js","sourceRoot":"","sources":["../../../../../../packages/http/http-routing/src/filters/AuthFilter.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, optional } from 'inversify';\nimport { timingSafeEqual } from 'crypto';\nimport { provideFrameworkSingleton, HttpRequest, PendingWireTrust, PendingTrustedValue, RawHttpRequest, RequestContext } from '@webpieces/core-context';\nimport { AuthMode, EndpointNotFoundError, HttpBadRequestError, HttpUnauthorizedError, JwtRequirement, LogManager, RuntimeLocality, toError } from '@webpieces/core-util';\nimport { Filter, WpResponse, Service } from '../Filter';\nimport { MethodMeta } from '../MethodMeta';\nimport { AuthConfig, AUTH_CONFIG, AuthenticatedCaller, AUTHENTICATED_CALLER_KEY, SharedSecrets } from '../AuthConfig';\nimport { ApiKeyHook, API_KEY_HOOK, JwtHook, JWT_HOOK, OidcHook, OIDC_HOOK, WebhookAuthCallback, WEBHOOK_AUTH_CALLBACK } from '../AuthHooks';\nimport { DefaultOidcVerifier } from '../DefaultOidcVerifier';\n\nconst log = LogManager.getLogger('AuthFilter');\n\n/**\n * The ONE credential header, read straight off the inbound HttpRequest.\n *\n * Deliberately NOT a ContextKey: a ContextKey with an httpHeader is a TRANSFERRED key, which would\n * put the caller's credential into RequestContext and hence onto every outbound call this service\n * makes, and onto every Cloud Task it enqueues. A credential belongs to ONE request hop.\n */\nconst AUTHORIZATION_HEADER = 'authorization';\n\n/**\n * The scheme (first word of the Authorization value) names WHICH credential follows, so a secret\n * can never be mistaken for a token, nor accepted where the other was expected:\n *\n *   Authorization: Bearer <user JWT | service OIDC token>\n *   Authorization: Webpieces <@AuthSharedSecret value>\n *\n * The scheme is REQUIRED. A bare value with no scheme is rejected.\n */\nconst BEARER_SCHEME = 'Bearer';\nconst SHARED_SECRET_SCHEME = 'Webpieces';\n\n/**\n * AuthFilter - the ONE framework auth filter, auto-installed just below the error filter on every\n * route. It is TRANSPORT-NEUTRAL: it reads the raw credential from the {@link HttpRequest} in\n * RequestContext (never express), so the SAME check runs over HTTP and via createApiClient.\n *\n * It enforces the endpoint's AuthMode from separately-bound pieces, each OPTIONAL except the OIDC\n * default:\n *  - shared-secret → constant-time compare vs the {@link AuthConfig} secret VALUE (state). No\n *                    AuthConfig bound → no accepted secret → fail fast (401).\n *  - jwt           → the bound {@link JwtHook} (`parseJwt` + `authorizeJwt`, both awaited — an app's\n *                    strategy may reach a JWKS or a datastore). No JwtHook bound → \"not enabled\"\n *                    (401): JWT needs an app secret + payload shape.\n *  - oidc          → the bound {@link OidcHook} if any, else the framework {@link DefaultOidcVerifier}\n *                    run DIRECTLY — so a server that wires NOTHING still verifies Google OIDC.\n *  - webhook       → the bound {@link WebhookAuthCallback} verifies the VENDOR's signature over the retained\n *                    raw request. No WebhookAuthCallback bound → 401, like jwt: an unverified webhook is\n *                    never waved through because wiring was forgotten.\n *  - apikey        → the bound {@link ApiKeyHook} looks the CUSTOMER's key up (async, over the whole\n *                    header set) and returns the context to seed. No ApiKeyHook bound → 401, like jwt.\n *  - public        → BEST-EFFORT jwt parse (only if a JwtHook is bound): stamp the user's context so\n *                    a logged-out page still knows who is logged in; never fails.\n *  - local-only    → serve only when {@link RuntimeLocality} says this process is a developer's\n *                    machine; otherwise 404, indistinguishable from the route not existing (which,\n *                    off-local, it does not — `ApiRoutingFactory` never registered it).\n *\n * Zero wiring = OIDC just works; an app only binds the hooks it actually uses.\n */\n@provideFrameworkSingleton()\n// webpieces-disable no-any-unknown -- Filter generic params use unknown for response flexibility\nexport class AuthFilter extends Filter<MethodMeta, WpResponse<unknown>> {\n    constructor(\n        // Framework default, always available — verifies Google OIDC with zero app wiring.\n        // webpieces-disable inject-annotation-not-needed-for-concrete-class -- AuthFilter is DI-resolved via the esbuild/vitest path, which elides type-only imports (no design:paramtypes), so every param needs its explicit token\n        @inject(DefaultOidcVerifier) private readonly oidcVerifier: DefaultOidcVerifier,\n        // @optional: only bind an AuthConfig to enable @AuthSharedSecret endpoints.\n        // webpieces-disable inject-annotation-not-needed-for-concrete-class -- see above: explicit token required for DI-resolved param\n        @optional() @inject(AUTH_CONFIG) private readonly authConfig?: AuthConfig,\n        // @optional: only bind a JwtHook to enable @AuthJwt endpoints.\n        // webpieces-disable inject-annotation-not-needed-for-concrete-class -- see above: explicit token required for DI-resolved param\n        @optional() @inject(JWT_HOOK) private readonly jwtHook?: JwtHook,\n        // @optional: only bind an OidcHook to OVERRIDE the DefaultOidcVerifier caller policy.\n        // webpieces-disable inject-annotation-not-needed-for-concrete-class -- see above: explicit token required for DI-resolved param\n        @optional() @inject(OIDC_HOOK) private readonly oidcHook?: OidcHook,\n        // @optional: only bind a WebhookAuthCallback to enable @AuthWebhook endpoints. Unbound = every such\n        // endpoint 401s, which is the ONE default that must not be the other way round.\n        // webpieces-disable inject-annotation-not-needed-for-concrete-class -- see above: explicit token required for DI-resolved param\n        @optional() @inject(WEBHOOK_AUTH_CALLBACK) private readonly webhookAuthCallback?: WebhookAuthCallback,\n        // @optional: only bind an ApiKeyHook to enable @AuthApiKey endpoints. Unbound = every such\n        // endpoint 401s, for the same reason as the webhook hook above.\n        // webpieces-disable inject-annotation-not-needed-for-concrete-class -- see above: explicit token required for DI-resolved param\n        @optional() @inject(API_KEY_HOOK) private readonly apiKeyHook?: ApiKeyHook,\n    ) {\n        super();\n    }\n\n    // webpieces-disable no-any-unknown -- Filter generic params use unknown for response flexibility\n    override async filter(\n        meta: MethodMeta,\n        nextFilter: Service<MethodMeta, WpResponse<unknown>>,\n    ): Promise<WpResponse<unknown>> {\n        const mode = meta.routeMeta.authMeta?.mode;\n        const authHeader = RequestContext.getRequest()?.getHeader(AUTHORIZATION_HEADER);\n\n        if (!mode || mode.kind === 'public') {\n            // Public: best-effort parse so a logged-out page can still know the logged-in user.\n            await this.bestEffortJwt(authHeader);\n            this.reconcileWireTrust(/*callerVerified*/ false);\n            this.rethrowDeferredBodyError();\n            return nextFilter.invoke(meta);\n        }\n\n        switch (mode.kind) {\n            case 'jwt':\n                await this.enforceJwt(authHeader, mode.requirement);\n                break;\n            case 'oidc':\n                await this.enforceOidc(authHeader, mode.callers);\n                break;\n            case 'shared-secret':\n                this.enforceSharedSecret(this.credential(authHeader, SHARED_SECRET_SCHEME), mode.secretKey);\n                break;\n            case 'webhook':\n                await this.enforceWebhook(mode.name, meta);\n                break;\n            case 'apikey':\n                await this.enforceApiKey(mode.name, meta);\n                break;\n            case 'local-only':\n                this.enforceLocalOnly(meta);\n                break;\n        }\n        this.reconcileWireTrust(AuthFilter.verifiesCaller(mode));\n        this.rethrowDeferredBodyError();\n        return nextFilter.invoke(meta);\n    }\n\n    /**\n     * `@AuthWebhook(name)`: hand the app's {@link WebhookAuthCallback} the verbatim request and let it call the\n     * VENDOR's own validator. Three ways to fail, all 401, all before the controller is entered:\n     *\n     * 1. NO hook bound — the endpoint is not enabled. Matches {@link JwtHook}'s documented behavior;\n     *    an unverified webhook must never be waved through because wiring was forgotten.\n     * 2. NO raw request — the transport kept no bytes. `assertEveryWebhookEndpointRetainsRawBody`\n     *    normally makes this a startup error, so reaching it means either a hand-registered route or\n     *    an in-process caller (a spec) that published an HttpRequest with no {@link RawRequest}. The\n     *    message says which fix applies rather than leaving a bare 401.\n     * 3. The hook threw — the signature did not verify.\n     *\n     * Case 2 is checked HERE and nowhere else. {@link hasRawBytes} narrows the request to\n     * {@link RawHttpRequest} at this one gate, so the hook's signature promises `raw` is present and\n     * no vendor implementation ever writes `raw!` or a guard of its own.\n     */\n    private async enforceWebhook(name: string, meta: MethodMeta): Promise<void> {\n        if (!this.webhookAuthCallback) {\n            log.warn(\n                `Refusing @AuthWebhook('${name}') endpoint ${meta.routeMeta.path}: no WebhookAuthCallback is bound. ` +\n                `Bind one (options.bind(WEBHOOK_AUTH_CALLBACK).to(YourWebhookAuthCallback)) to enable webhook verification.`,\n            );\n            throw new HttpUnauthorizedError('Webhook auth is not enabled on this server');\n        }\n        const request = RequestContext.getRequest();\n        if (!this.hasRawBytes(request)) {\n            log.warn(\n                `Refusing @AuthWebhook('${name}') endpoint ${meta.routeMeta.path}: the inbound request carries ` +\n                `no raw bytes. Declare @Endpoint(path, 'external', { calledBy: '${name}', rawBody: true }); a ` +\n                `spec driving this route in-process must publish an HttpRequest built with a RawRequest.`,\n            );\n            throw new HttpUnauthorizedError('Webhook signature cannot be verified: no raw request was retained');\n        }\n        // Throws HttpUnauthorizedError to deny. On success the vendor account the signature proved is\n        // stamped through the SAME path a jwt or api-key caller takes.\n        const caller = await this.webhookAuthCallback.verifyWebhook(name, request);\n        this.applyAuthenticatedCaller(caller);\n    }\n\n    /**\n     * The ONE place the framework decides a request carries the verbatim bytes. A TYPE PREDICATE, so\n     * the `true` branch hands {@link enforceWebhook} a {@link RawHttpRequest} with no cast and no\n     * non-null assertion — the bad state stops being representable past this line rather than being\n     * re-thrown about by every hook.\n     */\n    private hasRawBytes(request: HttpRequest | undefined): request is RawHttpRequest {\n        return request?.raw !== undefined;\n    }\n\n    /**\n     * `@AuthApiKey(name)`: hand the app's {@link ApiKeyHook} the regime name and the inbound headers and\n     * let it look the CUSTOMER's key up. Three ways to fail, all 401, all before the controller:\n     *\n     * 1. NO hook bound — the endpoint is not enabled. Matches {@link JwtHook}'s documented behavior; an\n     *    unverified partner request must never be waved through because wiring was forgotten.\n     * 2. NO inbound request in scope — there are no headers to read, so there is nothing to verify. That\n     *    means a caller drove this route without publishing an HttpRequest; the message says so rather\n     *    than leaving a bare 401.\n     * 3. The hook threw — the key, or the key/organization pair, did not check out.\n     *\n     * On success the hook's {@link AuthenticatedCaller} is stamped exactly as a jwt parse's is, which is\n     * what puts the resolved organization into `RequestContext` for every downstream repository call.\n     */\n    private async enforceApiKey(name: string, meta: MethodMeta): Promise<void> {\n        if (!this.apiKeyHook) {\n            log.warn(\n                `Refusing @AuthApiKey('${name}') endpoint ${meta.routeMeta.path}: no ApiKeyHook is bound. ` +\n                `Bind one (options.bind(API_KEY_HOOK).to(YourApiKeyHook)) to enable api-key verification.`,\n            );\n            throw new HttpUnauthorizedError('API-key auth is not enabled on this server');\n        }\n        const request = RequestContext.getRequest();\n        if (!request) {\n            log.warn(\n                `Refusing @AuthApiKey('${name}') endpoint ${meta.routeMeta.path}: no inbound HttpRequest is ` +\n                `in scope, so the hook has no headers to read. A spec driving this route in-process must ` +\n                `publish an HttpRequest carrying the api-key headers.`,\n            );\n            throw new HttpUnauthorizedError('API key cannot be verified: no inbound request was published');\n        }\n        // Throws HttpUnauthorizedError to deny. The hook gets the WHOLE request so it can cross-check\n        // the key against a second header (the organization the customer is acting for).\n        const caller = await this.apiKeyHook.verifyApiKey(name, request);\n        this.applyAuthenticatedCaller(caller);\n    }\n\n    /**\n     * A body that failed to parse is held on the {@link RawRequest} and surfaces HERE, after auth, as\n     * the 400 it always was — never before it.\n     *\n     * The order is the whole point. A malformed body from an unauthenticated caller must answer 401,\n     * because \"your JSON was bad\" also says \"I got past auth\", and on a webhook endpoint — whose url\n     * is public by construction — that is a free oracle for anyone probing. Parsing first made the\n     * framework hand that out for nothing.\n     *\n     * Only routes that retain raw bytes can defer at all; every other route still fails at parse time\n     * in the transport, exactly as before.\n     */\n    private rethrowDeferredBodyError(): void {\n        const parseError = RequestContext.getRequest()?.raw?.bodyParseError;\n        if (parseError) {\n            throw new HttpBadRequestError('Request body is not valid JSON', undefined, undefined, parseError);\n        }\n    }\n\n    /**\n     * Does this mode authenticate the CALLER ITSELF (as opposed to a user, or nobody)? The INBOUND\n     * twin of {@link DestinationTrust.forAuthMode}, and deliberately the same question: the client\n     * omits trusted keys for a destination that cannot verify it, and the server rejects trusted keys\n     * on a route that cannot verify the sender. One rule, two ends — if they disagreed, every call\n     * would fail with a 401 that looks like a framework bug.\n     *\n     * - `oidc` / `shared-secret` → TRUE. An internal service is on the other end and the trusted\n     *   context it forwarded may be believed. This is what makes cross-service identity propagation\n     *   work.\n     * - `jwt` / `public` → FALSE. A user JWT proves who the USER is; the SENDER is still whoever\n     *   holds the token, i.e. a browser.\n     * - `local-only` → FALSE. It verifies WHERE WE ARE RUNNING, not who is calling — anything on\n     *   localhost reaches it, and it has no authenticator, so nothing can ever vouch for an inbound\n     *   trusted header. Any such header therefore rejects the request, which is exactly right.\n     *\n     * - `apikey` → FALSE. See the comment on that branch: the sender is a CUSTOMER.\n     *\n     * An exhaustive switch with NO `default`, returning on every branch: a new AuthMode kind is a\n     * COMPILE error here (TS7030, no ending return) rather than silently landing on one posture. The\n     * boolean expression this replaced defaulted every future mode to \"not verified\" — the safe\n     * answer, but arrived at by accident rather than by decision.\n     */\n    // webpieces-disable no-function-outside-class -- static pure mapping from the AuthMode union, kept beside its only caller (mirrors DestinationTrust.forAuthMode)\n    private static verifiesCaller(mode: AuthMode): boolean {\n        switch (mode.kind) {\n            case 'oidc':\n            case 'shared-secret':\n                return true;\n            case 'jwt':\n            case 'public':\n            // `webhook` DOES authenticate its sender — but the sender is an outside VENDOR, not a\n            // peer in this repo, and a vendor neither speaks nor forwards webpieces context headers.\n            // So there is no forwarded identity to believe, and admitting one would mean trusting a\n            // key a vendor's payload could carry. Same answer as the OUTBOUND half\n            // (DestinationTrust.forAuthMode), which is the invariant that keeps the two ends agreeing.\n            case 'webhook':\n            // `apikey` authenticates the SENDER — but the sender is a CUSTOMER's codebase, not a peer\n            // service in this repo, so its forwarded trusted context is exactly what must NOT be\n            // believed: admitting it would let a partner assert another customer's org id on the wire.\n            // The hook's OWN derived entries still land (applyAuthenticatedCaller), and reconcileWireTrust then\n            // admits an inbound trusted header only when the hook independently derived the same value.\n            case 'apikey':\n            case 'local-only':\n                return false;\n        }\n    }\n\n    /**\n     * Decide what happens to the trusted keys that arrived on the WIRE and were held back by\n     * {@link PendingWireTrust} (read that class for why they are held rather than written).\n     *\n     * `callerVerified` — the endpoint authenticated the SENDER **as a peer service** (`@AuthOidc`,\n     * `@AuthSharedSecret`).\n     * The sender is a service we trust, this is the service-to-service hop, and its forwarded\n     * identity is admitted as-is. This is the case that makes propagating a verified userId across\n     * internal services work.\n     *\n     * Otherwise the sender is a browser or anyone else with curl, and the ONLY acceptable inbound\n     * trusted value is one the authenticator independently derived to the same value. Everything\n     * else is rejected — see {@link requireVouched}.\n     *\n     * Runs AFTER the mode enforcement above, because that is what stamps the authenticator's own\n     * values (`applyAuthenticatedCaller`); comparing before it ran would compare against nothing.\n     */\n    private reconcileWireTrust(callerVerified: boolean): void {\n        const pending = PendingWireTrust.takeAll();\n        for (const item of pending) {\n            if (callerVerified) {\n                RequestContext.putTrusted(item.key, item.value);\n            } else {\n                this.requireVouched(item);\n            }\n        }\n    }\n\n    /**\n     * On a browser-reachable route, an inbound trusted header must match what the authenticator\n     * itself derived, or the request dies. Both failure shapes are rejections, not repairs:\n     *\n     * - DIFFERENT value — the caller said `alice`, the credential says `bob`. Silently letting the\n     *   credential win is not safe, because upstream rate limiters commonly bucket on the header\n     *   rather than the token: the request was already counted against the wrong principal, so\n     *   every forged header would be a free rate-limit bypass. No honest caller contradicts its own\n     *   credential.\n     * - NOTHING vouched for it — nobody derived this key at all, so there is no evidence behind a\n     *   value a stranger typed. This is the common case, not the exotic one: the framework's\n     *   {@link DefaultJwtHook} stamps NO entries, and an app hook (jwt or api-key) only stamps the keys it can prove,\n     *   so any other trusted key a caller sends lands here.\n     *\n     * The pending value is discarded either way — the throw is what leaves the request.\n     */\n    private requireVouched(item: PendingTrustedValue): void {\n        const vouched = RequestContext.getTrusted(item.key);\n        if (vouched === item.value) {\n            return;\n        }\n        log.error(\n            `Rejecting inbound '${item.key.httpHeader}': it is a TRUSTED context key, this route does ` +\n            `not authenticate its caller, and the credential ` +\n            (vouched === undefined ? 'vouched for no such value' : 'derived a different value') + '.',\n        );\n        throw new HttpUnauthorizedError(\n            `Header '${item.key.httpHeader}' cannot be supplied by the caller on this endpoint`,\n        );\n    }\n\n    /**\n     * `@AuthLocalOnly`: serve only on a developer's machine, and off-local behave EXACTLY as if the\n     * endpoint did not exist.\n     *\n     * WHY 404 AND NOT THE 403 APPS HAND-ROLLED. Off-local the route is not registered at all\n     * (`ApiRoutingFactory` skips it), so the ordinary way to reach this path already answers 404. A\n     * 403 from here would be a DIFFERENT answer from the same framework for the same endpoint, and\n     * the difference is itself the leak: 403 confirms \"this path exists in production, you merely\n     * lack permission\", which is a map of the dev-only surface for anyone probing. A local-only\n     * endpoint should not admit it exists. Both gates therefore return the same 404, and this one is\n     * the backstop for routes registered by hand through `RouteBuilder` rather than by\n     * `ApiRoutingFactory`.\n     *\n     * The log line names WHICH reason applies, because \"you are deployed\" and \"nobody declared a\n     * locality\" have completely different fixes and both look like a bare 404 from outside.\n     */\n    private enforceLocalOnly(meta: MethodMeta): void {\n        if (RuntimeLocality.isLocalDevelopment()) {\n            return;\n        }\n        log.warn(\n            `Refusing @AuthLocalOnly endpoint ${meta.routeMeta.path}: ` +\n            (RuntimeLocality.isDeclared()\n                ? 'this process declared itself DEPLOYED.'\n                : 'no startup declared a RuntimeLocality, so this process is treated as DEPLOYED. ' +\n                  'Pass the locality into RuntimeSetupOptions if this really is a developer machine.'),\n        );\n        // Same shape as an unregistered route — see the method doc for why this is not a 403.\n        throw new EndpointNotFoundError(`No endpoint at ${meta.routeMeta.path}`);\n    }\n\n    private async enforceJwt(header: string | undefined, requirement: JwtRequirement): Promise<void> {\n        const token = this.credential(header, BEARER_SCHEME);\n        if (!token) {\n            throw new HttpUnauthorizedError('Authentication required');\n        }\n        if (!this.jwtHook) {\n            throw new HttpUnauthorizedError('User-JWT auth is not enabled on this server');\n        }\n        const caller = await this.jwtHook.parseJwt(token); // AUTHENTICATE — throws HttpUnauthorizedError if invalid\n        this.applyAuthenticatedCaller(caller);\n        await this.jwtHook.authorizeJwt(caller, requirement); // AUTHORIZE — app policy; throws HttpForbiddenError to deny\n    }\n\n    private async enforceOidc(header: string | undefined, callers: string[]): Promise<void> {\n        const token = this.credential(header, BEARER_SCHEME);\n        if (!token) {\n            throw new HttpUnauthorizedError('Missing OIDC bearer token for @AuthOidc endpoint');\n        }\n        // App-bound OidcHook overrides the caller policy; otherwise the framework default runs directly.\n        if (this.oidcHook) {\n            await this.oidcHook.verifyOidc(token, callers);\n        } else {\n            await this.oidcVerifier.verify(token, callers);\n        }\n    }\n\n    /** `provided` is the Authorization bearer value — the secret itself, same header as a JWT. */\n    private enforceSharedSecret(provided: string | undefined, secretKey: string): void {\n        const accepted = this.authConfig?.sharedSecrets[secretKey];\n        if (!accepted || !provided || !this.matchesEither(provided, accepted)) {\n            throw new HttpUnauthorizedError('Invalid shared secret for @AuthSharedSecret endpoint');\n        }\n    }\n\n    /** EITHER secret1 or secret2 passes — the rotation window. Constant-time on each non-empty slot. */\n    private matchesEither(provided: string, accepted: SharedSecrets): boolean {\n        return (\n            (accepted.secret1 !== '' && this.constantTimeEquals(provided, accepted.secret1)) ||\n            (accepted.secret2 !== '' && this.constantTimeEquals(provided, accepted.secret2))\n        );\n    }\n\n    /** Parse a JWT if one is present, else do nothing — used on public routes; never throws. */\n    private async bestEffortJwt(header: string | undefined): Promise<void> {\n        const token = this.credential(header, BEARER_SCHEME);\n        if (!this.jwtHook || !token) {\n            return;\n        }\n        // eslint-disable-next-line @webpieces/no-unmanaged-exceptions -- best-effort on a public route: a bad/absent token just means \"not logged in\", must not fail the request\n        try {\n            this.applyAuthenticatedCaller(await this.jwtHook.parseJwt(token));\n        } catch (err: unknown) {\n            const error = toError(err);\n            log.debug('Best-effort JWT parse on a public endpoint failed (treating as anonymous): ', error);\n        }\n    }\n\n    /**\n     * Stamp the authenticated caller's context entries + the caller itself into the RequestContext.\n     * ONE path for all three authenticating hooks — jwt, api-key and webhook — so a vendor hook that\n     * proved which account a payload belongs to seeds context exactly as a JwtHook does.\n     */\n    private applyAuthenticatedCaller(caller: AuthenticatedCaller): void {\n        for (const entry of caller.entries) {\n            // ContextTuple.key is a TRUSTED key by type, so this is the one sanctioned write of a\n            // proven identity: the app's hook derived it from a credential we just verified.\n            RequestContext.putTrusted(entry.key, entry.value);\n        }\n        // A real TRUSTED ContextKey, not a raw string slot: the caller IS the framework's own proof,\n        // so it is written with the same typed verb every other proven value goes through.\n        RequestContext.putTrusted(AUTHENTICATED_CALLER_KEY, caller);\n    }\n\n    /**\n     * The credential value IF the header carries the expected scheme, else undefined.\n     *\n     * Strict: a bare value with no scheme, or a value under the WRONG scheme (a shared secret sent\n     * where a JWT is expected), yields undefined and the caller 401s.\n     */\n    private credential(header: string | undefined, scheme: string): string | undefined {\n        if (!header) {\n            return undefined;\n        }\n        const prefix = `${scheme} `;\n        return header.startsWith(prefix) ? header.substring(prefix.length) : undefined;\n    }\n\n    private constantTimeEquals(a: string, b: string): boolean {\n        const bufA = Buffer.from(a, 'utf8');\n        const bufB = Buffer.from(b, 'utf8');\n        if (bufA.length !== bufB.length) {\n            return false;\n        }\n        return timingSafeEqual(bufA, bufB);\n    }\n}\n"]}

package/src/index.d.ts

@@ -5,7 +5,7 @@ export { provideSingletonDefaultForApi } from '@webpieces/core-context';
 export { provideFrameworkSingleton, provideFrameworkSingletonDefaultForApi, buildFrameworkModule, } from '@webpieces/core-context';
 export { ApiRoutingFactory, ClassType } from './ApiRoutingFactory';
 export { Routes, RouteBuilder, RouteDefinition, FilterDefinition, } from './WebAppMeta';
-export { HttpRequest, RawRequest } from '@webpieces/core-context';
+export { HttpRequest, RawHttpRequest, RawRequest } from '@webpieces/core-context';
 export { Filter, WpResponse, Service } from './Filter';
 export { FilterChain } from './FilterChain';
 export { MethodMeta } from './MethodMeta';
@@ -15,8 +15,8 @@ export { FilterMatcher, HttpFilter } from './FilterMatcher';
 export { AppModules, RouteModule } from './AppModules';
 export { ApiFactory } from './ApiFactory';
 export { ApiClient, ApiClientProxy } from './ApiClient';
-export { AuthConfig, AUTH_CONFIG, AuthValues, SharedSecrets } from './AuthConfig';
-export { JwtHook, JWT_HOOK, OidcHook, OIDC_HOOK, WebhookAuthCallback, WEBHOOK_AUTH_CALLBACK, ApiKeyHook, API_KEY_HOOK, HeaderReader, } from './AuthHooks';
+export { AuthConfig, AUTH_CONFIG, AuthenticatedCaller, AUTHENTICATED_CALLER_KEY, SharedSecrets } from './AuthConfig';
+export { JwtHook, JWT_HOOK, OidcHook, OIDC_HOOK, WebhookAuthCallback, WEBHOOK_AUTH_CALLBACK, ApiKeyHook, API_KEY_HOOK, } from './AuthHooks';
 export { DefaultOidcVerifier } from './DefaultOidcVerifier';
 export { DefaultJwtHook } from './DefaultJwtHook';
 export { WebpiecesRouter, WebpiecesRouterFactory, WebpiecesRouterOptions } from './WebpiecesRouter';

package/src/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AuthConfig = exports.ApiClient = exports.FilterMatcher = exports.LogApiFilter = exports.RouteHandler = exports.MethodMeta = exports.FilterChain = exports.WpResponse = exports.Filter = exports.RawRequest = exports.HttpRequest = exports.FilterDefinition = exports.RouteDefinition = exports.ApiRoutingFactory = exports.buildFrameworkModule = exports.provideFrameworkSingletonDefaultForApi = exports.provideFrameworkSingleton = exports.provideSingletonDefaultForApi = exports.ROUTING_METADATA_KEYS = exports.SourceFile = exports.isDocumentDesign = exports.DocumentDesign = exports.METADATA_KEYS = exports.RouteMetadata = exports.AuthMeta = exports.getQueueName = exports.assertPubSubConventions = exports.assertApiKind = exports.getApiKind = exports.assertEveryEndpointHasAuthMode = exports.getAuthMode = exports.getAuthMeta = exports.isApiPath = exports.isRawBody = exports.isFormPost = exports.getEndpointOptions = exports.getEndpoints = exports.getApiPath = exports.Queue = exports.PubSub = exports.Rpc = exports.AuthLocalOnly = exports.AuthWebhook = exports.AuthSharedSecret = exports.AuthOidc = exports.rolesRequired = exports.AuthJwt = exports.Public = exports.Endpoint = exports.ApiPath = void 0;
-exports.WEBPIECES_CONFIG_TOKEN = exports.WebpiecesConfig = exports.RuntimeSetupOptions = exports.setupRuntime = exports.WebpiecesRouterFactory = exports.WebpiecesRouter = exports.DefaultJwtHook = exports.DefaultOidcVerifier = exports.API_KEY_HOOK = exports.ApiKeyHook = exports.WEBHOOK_AUTH_CALLBACK = exports.WebhookAuthCallback = exports.OIDC_HOOK = exports.OidcHook = exports.JWT_HOOK = exports.JwtHook = exports.SharedSecrets = exports.AuthValues = exports.AUTH_CONFIG = void 0;
+exports.WEBPIECES_CONFIG_TOKEN = exports.WebpiecesConfig = exports.RuntimeSetupOptions = exports.setupRuntime = exports.WebpiecesRouterFactory = exports.WebpiecesRouter = exports.DefaultJwtHook = exports.DefaultOidcVerifier = exports.API_KEY_HOOK = exports.ApiKeyHook = exports.WEBHOOK_AUTH_CALLBACK = exports.WebhookAuthCallback = exports.OIDC_HOOK = exports.OidcHook = exports.JWT_HOOK = exports.JwtHook = exports.SharedSecrets = exports.AUTHENTICATED_CALLER_KEY = exports.AuthenticatedCaller = exports.AUTH_CONFIG = void 0;
 // Re-export API decorators from core-util for convenience
 var core_util_1 = require("@webpieces/core-util");
 Object.defineProperty(exports, "ApiPath", { enumerable: true, get: function () { return core_util_1.ApiPath; } });
@@ -88,7 +88,8 @@ Object.defineProperty(exports, "ApiClient", { enumerable: true, get: function ()
 var AuthConfig_1 = require("./AuthConfig");
 Object.defineProperty(exports, "AuthConfig", { enumerable: true, get: function () { return AuthConfig_1.AuthConfig; } });
 Object.defineProperty(exports, "AUTH_CONFIG", { enumerable: true, get: function () { return AuthConfig_1.AUTH_CONFIG; } });
-Object.defineProperty(exports, "AuthValues", { enumerable: true, get: function () { return AuthConfig_1.AuthValues; } });
+Object.defineProperty(exports, "AuthenticatedCaller", { enumerable: true, get: function () { return AuthConfig_1.AuthenticatedCaller; } });
+Object.defineProperty(exports, "AUTHENTICATED_CALLER_KEY", { enumerable: true, get: function () { return AuthConfig_1.AUTHENTICATED_CALLER_KEY; } });
 Object.defineProperty(exports, "SharedSecrets", { enumerable: true, get: function () { return AuthConfig_1.SharedSecrets; } });
 var AuthHooks_1 = require("./AuthHooks");
 Object.defineProperty(exports, "JwtHook", { enumerable: true, get: function () { return AuthHooks_1.JwtHook; } });

package/src/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../packages/http/http-routing/src/index.ts"],"names":[],"mappings":"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","sourcesContent":["// Re-export API decorators from core-util for convenience\nexport {\n    ApiPath,\n    Endpoint,\n    Public,\n    AuthJwt,\n    rolesRequired,\n    AuthOidc,\n    AuthSharedSecret,\n    AuthWebhook,\n    AuthLocalOnly,\n    Rpc,\n    PubSub,\n    Queue,\n    getApiPath,\n    getEndpoints,\n    getEndpointOptions,\n    isFormPost,\n    isRawBody,\n    isApiPath,\n    getAuthMeta,\n    getAuthMode,\n    assertEveryEndpointHasAuthMode,\n    getApiKind,\n    assertApiKind,\n    assertPubSubConventions,\n    getQueueName,\n    AuthMeta,\n    RouteMetadata,\n    METADATA_KEYS,\n    ValidateImplementation,\n    // @DocumentDesign moved to core-util (design-root marker, browser + Node);\n    // re-exported here for back-compat.\n    DocumentDesign,\n    isDocumentDesign,\n} from '@webpieces/core-util';\nexport type { AuthMode, ApiKind, EndpointOptions } from '@webpieces/core-util';\n\n// Server-side routing decorators and utilities\nexport {\n    SourceFile,\n    ROUTING_METADATA_KEYS,\n} from './decorators';\n\n// DI provider decorators moved to core-context; re-exported here for back-compat\nexport { provideSingletonDefaultForApi } from '@webpieces/core-context';\n// Framework-only DI registry (packages/** framework classes use these; see frameworkProvide.ts)\nexport {\n    provideFrameworkSingleton,\n    provideFrameworkSingletonDefaultForApi,\n    buildFrameworkModule,\n} from '@webpieces/core-context';\n\nexport { ApiRoutingFactory, ClassType } from './ApiRoutingFactory';\n\n// Core routing types\nexport {\n    Routes,\n    RouteBuilder,\n    RouteDefinition,\n    FilterDefinition,\n} from './WebAppMeta';\n\n// The transport-neutral request type (defined in core-context; this is http-routing's\n// public request — a transport adapter builds one and the chain reads it from RequestContext).\nexport { HttpRequest, RawRequest } from '@webpieces/core-context';\n\n// Filter-chain primitives (absorbed from the former @webpieces/http-filters package)\nexport { Filter, WpResponse, Service } from './Filter';\nexport { FilterChain } from './FilterChain';\nexport { MethodMeta } from './MethodMeta';\nexport { RouteHandler } from './RouteHandler';\n\n// LogApiFilter: the fixed OUTERMOST framework filter (auto-installed at 1,000,000 above\n// AuthFilter). Exported for reference/testing only — apps must NOT install it themselves.\nexport { LogApiFilter } from './filters/LogApiFilter';\n\n// RouteBuilderImpl (the route table + chain composer) is now INTERNAL — it is never\n// handed to upper layers. The express layer consumes ApiFactory.apiClients() instead.\n\n// Filter matching\nexport { FilterMatcher, HttpFilter } from './FilterMatcher';\n\n// The app's server-surface declaration: DI binding modules + route groups + headers.\nexport { AppModules, RouteModule } from './AppModules';\n\n// The public API-surface abstraction: declare routes/filters, get them back as ApiClient[].\nexport { ApiFactory } from './ApiFactory';\nexport { ApiClient, ApiClientProxy } from './ApiClient';\n\n// Auth: the app-provided, container-bound pieces the framework AuthFilter injects.\n//  - AuthConfig: shared-secret STATE (@AuthSharedSecret values).\n//  - JwtHook / OidcHook / WebhookAuthCallback / ApiKeyHook: OPTIONAL verification mechanisms\n//    (bind only what you use; unbound means the matching endpoints 401, never open).\n//  - DefaultOidcVerifier: the built-in Google OIDC verifier used when no OidcHook is bound.\nexport { AuthConfig, AUTH_CONFIG, AuthValues, SharedSecrets } from './AuthConfig';\nexport {\n    JwtHook, JWT_HOOK,\n    OidcHook, OIDC_HOOK,\n    WebhookAuthCallback, WEBHOOK_AUTH_CALLBACK,\n    ApiKeyHook, API_KEY_HOOK, HeaderReader,\n} from './AuthHooks';\nexport { DefaultOidcVerifier } from './DefaultOidcVerifier';\n// DefaultJwtHook: batteries-included HS256 JwtHook — `new DefaultJwtHook(secret)` and go.\nexport { DefaultJwtHook } from './DefaultJwtHook';\n\n// Above-boundary context setup shared by every transport adapter.\n\n// Node-only router (the express-free heart: container + filter chain + in-process client)\nexport { WebpiecesRouter, WebpiecesRouterFactory, WebpiecesRouterOptions } from './WebpiecesRouter';\n\n// The ONE transport-free startup sequence (headers → logging → router → routes) → ApiFactory.\n// Reusable by any company/app and any framework adapter; a company wraps it with its own headers.\nexport { setupRuntime, RuntimeSetupOptions } from './setupRuntime';\n\n// Server configuration\nexport { WebpiecesConfig, WEBPIECES_CONFIG_TOKEN } from './WebpiecesConfig';\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../packages/http/http-routing/src/index.ts"],"names":[],"mappings":"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","sourcesContent":["// Re-export API decorators from core-util for convenience\nexport {\n    ApiPath,\n    Endpoint,\n    Public,\n    AuthJwt,\n    rolesRequired,\n    AuthOidc,\n    AuthSharedSecret,\n    AuthWebhook,\n    AuthLocalOnly,\n    Rpc,\n    PubSub,\n    Queue,\n    getApiPath,\n    getEndpoints,\n    getEndpointOptions,\n    isFormPost,\n    isRawBody,\n    isApiPath,\n    getAuthMeta,\n    getAuthMode,\n    assertEveryEndpointHasAuthMode,\n    getApiKind,\n    assertApiKind,\n    assertPubSubConventions,\n    getQueueName,\n    AuthMeta,\n    RouteMetadata,\n    METADATA_KEYS,\n    ValidateImplementation,\n    // @DocumentDesign moved to core-util (design-root marker, browser + Node);\n    // re-exported here for back-compat.\n    DocumentDesign,\n    isDocumentDesign,\n} from '@webpieces/core-util';\nexport type { AuthMode, ApiKind, EndpointOptions } from '@webpieces/core-util';\n\n// Server-side routing decorators and utilities\nexport {\n    SourceFile,\n    ROUTING_METADATA_KEYS,\n} from './decorators';\n\n// DI provider decorators moved to core-context; re-exported here for back-compat\nexport { provideSingletonDefaultForApi } from '@webpieces/core-context';\n// Framework-only DI registry (packages/** framework classes use these; see frameworkProvide.ts)\nexport {\n    provideFrameworkSingleton,\n    provideFrameworkSingletonDefaultForApi,\n    buildFrameworkModule,\n} from '@webpieces/core-context';\n\nexport { ApiRoutingFactory, ClassType } from './ApiRoutingFactory';\n\n// Core routing types\nexport {\n    Routes,\n    RouteBuilder,\n    RouteDefinition,\n    FilterDefinition,\n} from './WebAppMeta';\n\n// The transport-neutral request type (defined in core-context; this is http-routing's\n// public request — a transport adapter builds one and the chain reads it from RequestContext).\nexport { HttpRequest, RawHttpRequest, RawRequest } from '@webpieces/core-context';\n\n// Filter-chain primitives (absorbed from the former @webpieces/http-filters package)\nexport { Filter, WpResponse, Service } from './Filter';\nexport { FilterChain } from './FilterChain';\nexport { MethodMeta } from './MethodMeta';\nexport { RouteHandler } from './RouteHandler';\n\n// LogApiFilter: the fixed OUTERMOST framework filter (auto-installed at 1,000,000 above\n// AuthFilter). Exported for reference/testing only — apps must NOT install it themselves.\nexport { LogApiFilter } from './filters/LogApiFilter';\n\n// RouteBuilderImpl (the route table + chain composer) is now INTERNAL — it is never\n// handed to upper layers. The express layer consumes ApiFactory.apiClients() instead.\n\n// Filter matching\nexport { FilterMatcher, HttpFilter } from './FilterMatcher';\n\n// The app's server-surface declaration: DI binding modules + route groups + headers.\nexport { AppModules, RouteModule } from './AppModules';\n\n// The public API-surface abstraction: declare routes/filters, get them back as ApiClient[].\nexport { ApiFactory } from './ApiFactory';\nexport { ApiClient, ApiClientProxy } from './ApiClient';\n\n// Auth: the app-provided, container-bound pieces the framework AuthFilter injects.\n//  - AuthConfig: shared-secret STATE (@AuthSharedSecret values).\n//  - JwtHook / OidcHook / WebhookAuthCallback / ApiKeyHook: OPTIONAL verification mechanisms\n//    (bind only what you use; unbound means the matching endpoints 401, never open).\n//  - DefaultOidcVerifier: the built-in Google OIDC verifier used when no OidcHook is bound.\nexport { AuthConfig, AUTH_CONFIG, AuthenticatedCaller, AUTHENTICATED_CALLER_KEY, SharedSecrets } from './AuthConfig';\nexport {\n    JwtHook, JWT_HOOK,\n    OidcHook, OIDC_HOOK,\n    WebhookAuthCallback, WEBHOOK_AUTH_CALLBACK,\n    ApiKeyHook, API_KEY_HOOK,\n} from './AuthHooks';\nexport { DefaultOidcVerifier } from './DefaultOidcVerifier';\n// DefaultJwtHook: batteries-included HS256 JwtHook — `new DefaultJwtHook(secret)` and go.\nexport { DefaultJwtHook } from './DefaultJwtHook';\n\n// Above-boundary context setup shared by every transport adapter.\n\n// Node-only router (the express-free heart: container + filter chain + in-process client)\nexport { WebpiecesRouter, WebpiecesRouterFactory, WebpiecesRouterOptions } from './WebpiecesRouter';\n\n// The ONE transport-free startup sequence (headers → logging → router → routes) → ApiFactory.\n// Reusable by any company/app and any framework adapter; a company wraps it with its own headers.\nexport { setupRuntime, RuntimeSetupOptions } from './setupRuntime';\n\n// Server configuration\nexport { WebpiecesConfig, WEBPIECES_CONFIG_TOKEN } from './WebpiecesConfig';\n"]}