@idp.global/sdk 19.2.1 → 19.4.0

package/dist_ts_browser/secret-delivery.js

@@ -87,4 +87,4 @@ export const decryptSecretDeliveryEnvelope = async (contextArg, envelopeArg) =>
     }
     return secret;
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_relyingparty/classes.authorityobserver.d.ts

@@ -44,6 +44,8 @@ export interface IAuthorityObserverOptions<TGrant> {
     maxEntries?: number;
     now?: () => number;
 }
+/** a session's token is rotated for an inactive answer at most once in this long */
+export declare const AUTHORITY_FORCED_REFRESH_INTERVAL_MS = 60000;
 /**
  * Live organization authority through idp.global: one `POST /oauth/introspect`
  * observation of a login session's subject in one organization, projected by
@@ -54,6 +56,20 @@ export interface IAuthorityObserverOptions<TGrant> {
  * every attempt while the provider is unreachable. A session that is forgotten
  * while its observation is in flight never stores a positive answer. Nothing
  * runs on a timer: the cache is pruned when it is written to.
+ *
+ * idp.global answers inactive both for a login that ended and for a
+ * membership that is gone, so an inactive answer rotates the session's token
+ * (`rejectedAccessToken`) before it counts. A refused rotation is the ended
+ * login: it throws `authority_login_required` and stores nothing. Only an
+ * inactive answer on a token from a rotation that started after the
+ * observation's own inactive answer is a refusal (`idp_membership_absent`). A session's token is
+ * rotated so at most once per `AUTHORITY_FORCED_REFRESH_INTERVAL_MS`. An inactive
+ * answer that no rotation followed — it came within that time of the last
+ * one, the rotation started before it, or the source did not mark the token
+ * as its own rotation — confirms nothing: it throws `authority_unavailable`
+ * and stores nothing, and after the interval the next one rotates and
+ * decides. One monotonic sequence orders answers and rotation starts, so no
+ * token is compared with another and no clock with another's.
  */
 export declare class AuthorityObserver<TGrant> {
     #private;
@@ -76,6 +92,13 @@ export declare class AuthorityObserver<TGrant> {
     private liveEntry;
     private observeOnce;
     private makeObservation;
+    private introspect;
+    /**
+     * The session's one forced rotation within `AUTHORITY_FORCED_REFRESH_INTERVAL_MS`,
+     * started for `rejectedArg` when there is none. Its failure is every
+     * caller's failure until the interval is over.
+     */
+    private forcedRefresh;
     /** Expired entries go first; if that is not enough, the oldest do. */
     private prune;
 }

package/dist_ts_relyingparty/classes.authorityobserver.js

@@ -21,6 +21,8 @@ export class AuthorityRefusedError extends Error {
 const DEFAULT_MAX_ENTRIES = 2_000;
 /** how much room an eviction makes, so it does not run on every insert */
 const EVICTION_HEADROOM = 0.1;
+/** a session's token is rotated for an inactive answer at most once in this long */
+export const AUTHORITY_FORCED_REFRESH_INTERVAL_MS = 60_000;
 const assertTtl = (valueArg, labelArg) => {
     if (!Number.isSafeInteger(valueArg) || valueArg < 0) {
         throw new Error(labelArg + ' must be a non-negative integer of milliseconds');
@@ -37,11 +39,28 @@ const assertTtl = (valueArg, labelArg) => {
  * every attempt while the provider is unreachable. A session that is forgotten
  * while its observation is in flight never stores a positive answer. Nothing
  * runs on a timer: the cache is pruned when it is written to.
+ *
+ * idp.global answers inactive both for a login that ended and for a
+ * membership that is gone, so an inactive answer rotates the session's token
+ * (`rejectedAccessToken`) before it counts. A refused rotation is the ended
+ * login: it throws `authority_login_required` and stores nothing. Only an
+ * inactive answer on a token from a rotation that started after the
+ * observation's own inactive answer is a refusal (`idp_membership_absent`). A session's token is
+ * rotated so at most once per `AUTHORITY_FORCED_REFRESH_INTERVAL_MS`. An inactive
+ * answer that no rotation followed — it came within that time of the last
+ * one, the rotation started before it, or the source did not mark the token
+ * as its own rotation — confirms nothing: it throws `authority_unavailable`
+ * and stores nothing, and after the interval the next one rotates and
+ * decides. One monotonic sequence orders answers and rotation starts, so no
+ * token is compared with another and no clock with another's.
  */
 export class AuthorityObserver {
     #cache = new Map();
     #inFlight = new Map();
     #forgotten = new Set();
+    #forcedRefreshes = new Map();
+    /** counts inactive answers and forced rotation starts, in the order they happen */
+    #sequence = 0;
     #provider;
     #tokens;
     #project;
@@ -89,6 +108,7 @@ export class AuthorityObserver {
     }
     /** Drops every observation of a session; wire it to the session layer's `onSessionEnded`. */
     forgetSession(sessionIdArg) {
+        this.#forcedRefreshes.delete(sessionIdArg);
         const prefix = `${sessionIdArg} `;
         for (const key of this.#cache.keys()) {
             if (key.startsWith(prefix)) {
@@ -119,19 +139,15 @@ export class AuthorityObserver {
     }
     async makeObservation(keyArg, optionsArg) {
         const token = await this.#tokens.liveProviderToken(optionsArg.loginSessionId, optionsArg.principalId);
-        let answer;
-        try {
-            answer = await this.#provider.introspectOrganization({
-                accessToken: token.accessToken,
-                subject: token.subject,
-                organizationId: optionsArg.idpOrganizationId,
-            });
-        }
-        catch (error) {
-            if (error instanceof OidcAuthorityUnavailableError) {
-                throw new AuthorityTokenError('authority_unavailable', error);
+        let answer = await this.introspect(token, optionsArg.idpOrganizationId);
+        if (!answer.active) {
+            const answeredAt = ++this.#sequence;
+            const forced = this.forcedRefresh(optionsArg.loginSessionId, optionsArg.principalId, token.accessToken);
+            const rotated = await forced.token;
+            if (forced.sequence < answeredAt || rotated.rotatedAfterRejection !== true) {
+                throw new AuthorityTokenError('authority_unavailable');
             }
-            throw error;
+            answer = await this.introspect(rotated, optionsArg.idpOrganizationId);
         }
         const grant = answer.active ? this.#project(answer.roles) : undefined;
         const active = answer.active && grant !== undefined;
@@ -159,6 +175,45 @@ export class AuthorityObserver {
         this.prune();
         return entry;
     }
+    async introspect(tokenArg, organizationIdArg) {
+        try {
+            return await this.#provider.introspectOrganization({
+                accessToken: tokenArg.accessToken,
+                subject: tokenArg.subject,
+                organizationId: organizationIdArg,
+            });
+        }
+        catch (error) {
+            if (error instanceof OidcAuthorityUnavailableError) {
+                throw new AuthorityTokenError('authority_unavailable', error);
+            }
+            throw error;
+        }
+    }
+    /**
+     * The session's one forced rotation within `AUTHORITY_FORCED_REFRESH_INTERVAL_MS`,
+     * started for `rejectedArg` when there is none. Its failure is every
+     * caller's failure until the interval is over.
+     */
+    forcedRefresh(sessionIdArg, principalIdArg, rejectedArg) {
+        const now = this.#now();
+        const last = this.#forcedRefreshes.get(sessionIdArg);
+        if (last && now - last.startedAt < AUTHORITY_FORCED_REFRESH_INTERVAL_MS) {
+            return last;
+        }
+        for (const [sessionId, forced] of this.#forcedRefreshes) {
+            if (now - forced.startedAt >= AUTHORITY_FORCED_REFRESH_INTERVAL_MS) {
+                this.#forcedRefreshes.delete(sessionId);
+            }
+        }
+        const forced = {
+            startedAt: now,
+            sequence: ++this.#sequence,
+            token: this.#tokens.liveProviderToken(sessionIdArg, principalIdArg, { rejectedAccessToken: rejectedArg }),
+        };
+        this.#forcedRefreshes.set(sessionIdArg, forced);
+        return forced;
+    }
     /** Expired entries go first; if that is not enough, the oldest do. */
     prune() {
         if (this.#cache.size <= this.#maxEntries) {
@@ -182,4 +237,4 @@ export class AuthorityObserver {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.authorityobserver.js","sourceRoot":"","sources":["../../ts_relyingparty/classes.authorityobserver.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.authorityobserver.js","sourceRoot":"","sources":["../../ts_relyingparty/classes.authorityobserver.ts"],"names":[],"mappings":"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"}

package/dist_ts_relyingparty/classes.errors.d.ts

@@ -1,5 +1,15 @@
 import type { TLoginCallbackStage } from './interfaces.js';
-export type TRelyingPartyErrorCode = 'login_method_unavailable' | 'invalid_login_callback' | 'missing_login_intent' | 'invalid_or_replayed_login' | 'invalid_login_finalize';
+export type TRelyingPartyErrorCode = 'login_method_unavailable' | 'invalid_login_callback' | 'missing_login_intent' | 'invalid_or_replayed_login' | 'invalid_login_finalize'
+/** a bearer login start the relying party cannot accept: a missing or malformed parameter */
+ | 'invalid_bearer_request'
+/** a bearer client named a return target that is not configured for its kind, exactly */
+ | 'return_target_not_allowed'
+/** a hand-off code that is unknown, expired, already claimed, or claimed with the wrong verifier */
+ | 'invalid_bearer_handoff'
+/** a refresh token that is unknown, rotated, expired, or of a session that is over */
+ | 'invalid_bearer_grant'
+/** a `sessionsOfPrincipal` cursor that no page of it answered */
+ | 'invalid_sessions_cursor';
 /** A request the login flow refuses; the code is safe to answer, the browser learns nothing more. */
 export declare class RelyingPartyError extends Error {
     readonly code: TRelyingPartyErrorCode;

package/dist_ts_relyingparty/classes.errors.js

@@ -4,6 +4,11 @@ const RELYING_PARTY_ERROR_STATUS = {
     missing_login_intent: 400,
     invalid_or_replayed_login: 400,
     invalid_login_finalize: 400,
+    invalid_bearer_request: 400,
+    return_target_not_allowed: 400,
+    invalid_bearer_handoff: 400,
+    invalid_bearer_grant: 400,
+    invalid_sessions_cursor: 400,
 };
 /** A request the login flow refuses; the code is safe to answer, the browser learns nothing more. */
 export class RelyingPartyError extends Error {
@@ -66,4 +71,4 @@ export class RelyingPartyDatabaseUnavailableError extends Error {
         this.name = 'RelyingPartyDatabaseUnavailableError';
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_relyingparty/classes.relyingpartyroutes.d.ts

@@ -40,7 +40,7 @@ export interface IRelyingPartyRoutesOptions<TPrincipal extends object | undefine
         session: IRelyingPartySession;
         endedLiveSession: boolean;
     }): Promise<void>;
-    /** the largest logout body read, in bytes; a longer one is cancelled as soon as it passes the limit */
+    /** the largest logout, claim or refresh body read, in bytes; a longer one is cancelled as soon as it passes the limit */
     maxBodyBytes?: number;
     /**
      * diagnostics of a failed start or callback; the default writes one JSON
@@ -49,6 +49,10 @@ export interface IRelyingPartyRoutesOptions<TPrincipal extends object | undefine
      */
     onRouteEvent?(eventArg: {
         event: 'auth_login_start_failed' | 'auth_callback_failed' | 'auth_callback_declined' | 'auth_callback_refused'
+        /** a bearer login start named something the relying party does not accept; `code` says what */
+         | 'auth_bearer_start_refused'
+        /** a bearer claim, refresh, session or logout failed for a reason other than its credential */
+         | 'auth_bearer_failed'
         /** an application hook of the routes threw; the step it belonged to is complete */
          | 'hook_failed';
         hook?: 'onLogout';
@@ -72,6 +76,30 @@ export interface IRelyingPartyRoutesOptions<TPrincipal extends object | undefine
  * - `POST logout` ends the session; it needs this origin and the CSRF token,
  *   and `onLogout` runs before it answers
  *
+ * With bearer mode on (`RelyingPartySessions` `bearer`), the routes of the
+ * application's own clients join them; none of them reads or sets a cookie:
+ *
+ * - `GET bearer/login?client_kind=…&return_target=…&code_challenge=…&code_challenge_method=S256[&state=…]`
+ *   redirects to the provider
+ * - `GET callback` answers a bearer login's callback by delivering the
+ *   hand-off code — or the `error` — to the return target: a redirect with
+ *   `code` (or `error`) and `state` in the query, or for a popup a page that
+ *   posts them to its opener at the registered origin
+ * - `POST bearer/claim` `{ code, codeVerifier }` and `POST bearer/refresh`
+ *   `{ refreshToken }` answer the tokens
+ * - `GET bearer/session` answers the session of `Authorization: Bearer <access token>`
+ * - `POST bearer/logout` ends the session of the `Authorization` access token
+ *   or of the body's `{ refreshToken }`
+ *
+ * The four API routes answer CORS requests from the popup return targets'
+ * origins, exactly, and no others; they never allow credentials.
+ *
+ * In bearer-only mode (`RelyingPartySessions` `cookieSessions: false`) only
+ * the bearer routes and the callback answer, and no answer sets a cookie: a
+ * callback that is no bearer login fails without clearing an intent cookie
+ * that was never set, and `login`, `finalize`, `session` and `logout` answer
+ * `null`.
+ *
  * `handle()` answers `null` for every other request, so the application
  * chains its own routes (a local password login) around it. Cookies are only
  * ever set here: a `/typedrequest` answer cannot carry `Set-Cookie`.
@@ -79,13 +107,18 @@ export interface IRelyingPartyRoutesOptions<TPrincipal extends object | undefine
 export declare class RelyingPartyRoutes<TPrincipal extends object | undefined = undefined> {
     #private;
     constructor(optionsArg: IRelyingPartyRoutesOptions<TPrincipal>);
-    /** The paths the routes answer, for registering them one by one. */
+    /** The paths the routes answer, for registering them one by one; the `bearer…` paths answer only in bearer mode. */
     get paths(): {
         login: string;
         callback: string;
         finalize: string;
         session: string;
         logout: string;
+        bearerLogin: string;
+        bearerClaim: string;
+        bearerRefresh: string;
+        bearerSession: string;
+        bearerLogout: string;
     };
     readonly handle: (contextArg: IRelyingPartyHttpContext) => Promise<Response | null>;
     private login;
@@ -96,6 +129,45 @@ export declare class RelyingPartyRoutes<TPrincipal extends object | undefined =
      */
     private refusalLocationOf;
     private callback;
+    /**
+     * A callback of no bearer login in bearer-only mode: no attempt of this
+     * relying party can be completed with it, and no cookie is cleared because
+     * none was ever set.
+     */
+    private callbackOfNoBearerLogin;
+    /** A callback that failed for a reason other than a refusal: reported when it is the relying party's fault. */
+    private callbackFailure;
+    private callbackFailureStatus;
+    private handleBearer;
+    /**
+     * The CORS answer for a request from a popup return target's origin, which
+     * is matched exactly; `null` for every other origin, which gets none.
+     * Credentials are never allowed: bearer mode carries no cookie.
+     */
+    private bearerCorsHeaders;
+    private bearerLogin;
+    /**
+     * The callback of a bearer login, delivered to its return target whatever
+     * the outcome: the hand-off code, `access_denied` when the provider came
+     * back without one, the code of an application refusal (its `location` is
+     * a page of the cookie flow and not followed), or `authentication_failed`.
+     */
+    private bearerCallback;
+    /**
+     * A redirect to the return target with the outcome in its query, or for a
+     * popup the page that posts it to the opener. Neither sends a referrer, and
+     * the popup page runs its one nonce script and nothing else.
+     */
+    private deliverBearerOutcome;
+    /**
+     * Runs one bearer API step and answers its JSON. A refused credential
+     * answers its code with 400; an unreachable provider answers
+     * `authority_unavailable` with 503 and spends nothing; any other failure is
+     * reported and answers `authentication_unavailable`.
+     */
+    private bearerApi;
+    private bearerTokenAnswer;
+    private bearerSessionAnswer;
     private logout;
     private sessionAnswer;
     /**