@idp.global/sdk 18.0.0 → 18.1.0

package/dist_ts_relyingparty/classes.relyingpartysessions.js

@@ -0,0 +1,786 @@
+import { SecretBox } from './classes.secretbox.js';
+import { AuthorityTokenError, LoginCallbackError, RelyingPartyError, RelyingPartyRefusal, } from './classes.errors.js';
+import { OidcCompletionError, OidcRefreshRefusedError, } from './classes.idpoidcprovider.js';
+import { parseCookies, serializeClearedCookie, serializeCookie } from './helpers.cookies.js';
+import { deriveCsrfToken, randomToken, sha256, timingSafeEqualString } from './helpers.crypto.js';
+import { sanitizeReturnPath } from './helpers.returnpath.js';
+export const RELYING_PARTY_DEFAULT_SESSION_MAX_AGE_SECONDS = 12 * 60 * 60;
+export const RELYING_PARTY_DEFAULT_LOGIN_PATH_PREFIX = '/auth/';
+/** The label the CSRF HMAC starts with unless the application names its own. */
+export const RELYING_PARTY_DEFAULT_CSRF_LABEL = 'idp.global/sdk relyingparty csrf' + String.fromCharCode(0);
+const MAX_COOKIE_TOKEN_LENGTH = 256;
+const SESSION_TOUCH_INTERVAL_MS = 60_000;
+/** A sign-in transaction has to survive an interactive login at the provider, not a working day. */
+export const LOGIN_ATTEMPT_MAX_AGE_SECONDS = 10 * 60;
+/** Attempts are swept once they are this much older than their expiry. */
+const LOGIN_ATTEMPT_SWEEP_GRACE_MS = 60 * 60 * 1_000;
+/** How many of them one sign-in removes; the next sign-in takes the following page. */
+const LOGIN_ATTEMPT_SWEEP_BATCH = 100;
+/**
+ * How long ending a session waits for the provider to take its tokens back.
+ * The local session is already revoked when that call runs.
+ */
+export const TOKEN_REVOCATION_BUDGET_MS = 3_000;
+/** How long before its expiry the provider access token is rotated. */
+export const ACCESS_TOKEN_REFRESH_SKEW_MS = 60_000;
+/**
+ * What the refresh lock adds on top of the provider request it has to cover:
+ * the claim and the store around it, and clock disagreement between replicas.
+ */
+export const REFRESH_LOCK_MARGIN_MS = 20_000;
+const REVOKED_TOKEN_FIELDS = { sealedAccessToken: '', sealedRefreshToken: '', refreshLockUntil: 0 };
+const errorMessage = (errorArg) => (errorArg instanceof Error ? errorArg.message : String(errorArg));
+/** Browsers store a cookie with one of these prefixes only when it is set `Secure`; they match it case-insensitively. */
+const SECURE_COOKIE_NAME_PREFIX = /^__(host|secure)-/i;
+const cookieNameFor = (configuredArg, defaultArg, secureArg, labelArg) => {
+    if (configuredArg === undefined) {
+        return defaultArg;
+    }
+    if (!secureArg && SECURE_COOKIE_NAME_PREFIX.test(configuredArg)) {
+        throw new Error(`cookieNames.${labelArg} "${configuredArg}" needs an https publicOrigin: `
+            + 'browsers drop a __Host- or __Secure- cookie that is not set Secure');
+    }
+    return configuredArg;
+};
+/**
+ * The relying-party session layer: provider logins through the authorization
+ * code flow with PKCE, HttpOnly cookie sessions with a session-bound CSRF
+ * token, provider tokens sealed at rest and rotated under a cross-replica
+ * lock, and session ends that hand the tokens back.
+ *
+ * Nothing here runs on a timer: expired login attempts are swept when the next
+ * login starts, and the only timer — the revocation budget — is unreferenced
+ * and cleared on every path.
+ */
+export class RelyingPartySessions {
+    publicOrigin;
+    secureCookies;
+    sessionCookieName;
+    intentCookieName;
+    loginPathPrefix;
+    sessionMaxAgeSeconds;
+    #models;
+    #principals;
+    #provider;
+    #secretBox;
+    #csrfKey;
+    #csrfLabel;
+    #hooks;
+    #now;
+    /** one rotation per session in this process, however many requests need it at once */
+    #refreshesInFlight = new Map();
+    constructor(optionsArg) {
+        const origin = new URL(optionsArg.publicOrigin);
+        if (origin.origin !== optionsArg.publicOrigin) {
+            throw new Error('publicOrigin must be a bare origin such as https://app.example');
+        }
+        if (!Buffer.isBuffer(optionsArg.csrfKey) || optionsArg.csrfKey.length !== 32) {
+            throw new Error('csrfKey must be 32 bytes');
+        }
+        const maxAge = optionsArg.sessionMaxAgeSeconds ?? RELYING_PARTY_DEFAULT_SESSION_MAX_AGE_SECONDS;
+        if (!Number.isSafeInteger(maxAge) || maxAge < 1) {
+            throw new Error('sessionMaxAgeSeconds must be a positive integer');
+        }
+        this.publicOrigin = origin.origin;
+        this.secureCookies = origin.protocol === 'https:';
+        const prefix = this.secureCookies ? '__Host-' : '';
+        this.sessionCookieName = cookieNameFor(optionsArg.cookieNames?.session, prefix + 'idp_rp_session', this.secureCookies, 'session');
+        this.intentCookieName = cookieNameFor(optionsArg.cookieNames?.intent, prefix + 'idp_rp_intent', this.secureCookies, 'intent');
+        this.loginPathPrefix = optionsArg.loginPathPrefix ?? RELYING_PARTY_DEFAULT_LOGIN_PATH_PREFIX;
+        if (!this.loginPathPrefix.startsWith('/') || !this.loginPathPrefix.endsWith('/')) {
+            throw new Error('loginPathPrefix must start and end with a slash');
+        }
+        this.sessionMaxAgeSeconds = maxAge;
+        this.#models = optionsArg.models;
+        this.#principals = optionsArg.principals;
+        this.#provider = optionsArg.provider;
+        this.#secretBox = new SecretBox(optionsArg.sessionEncryptionKey);
+        this.#csrfKey = Buffer.from(optionsArg.csrfKey);
+        this.#csrfLabel = optionsArg.csrfLabel ?? RELYING_PARTY_DEFAULT_CSRF_LABEL;
+        this.#hooks = optionsArg.hooks ?? {};
+        this.#now = optionsArg.now ?? (() => Date.now());
+    }
+    /** Whether provider logins are offered at all. */
+    get providerLoginEnabled() {
+        return this.#provider !== undefined;
+    }
+    /**
+     * How long one replica holds the right to rotate a session's tokens. The
+     * provider detects reuse of a superseded refresh token and kills the family,
+     * so the lock strictly outlives its longest possible holder: one provider
+     * request at its full deadline plus the margin.
+     */
+    get refreshLockMs() {
+        return (this.#provider?.requestTimeoutSeconds ?? 0) * 1_000 + REFRESH_LOCK_MARGIN_MS;
+    }
+    // ==========================================================================
+    // sessions
+    // ==========================================================================
+    /**
+     * Opens a session the application authenticated itself (a local password
+     * login). It carries no provider tokens.
+     */
+    async openSession(optionsArg) {
+        if (typeof optionsArg?.principalId !== 'string' || optionsArg.principalId.length === 0) {
+            throw new Error('openSession needs a principal id');
+        }
+        const token = randomToken(32);
+        const session = this.newSessionDoc(token, optionsArg.principalId);
+        await session.save();
+        return this.opening(session, token);
+    }
+    /** The live session behind the session cookie, or `null`. A read touches it at most once a minute. */
+    async resolveCookieSession(cookieHeaderArg) {
+        const token = parseCookies(cookieHeaderArg).get(this.sessionCookieName);
+        if (!token || token.length > MAX_COOKIE_TOKEN_LENGTH) {
+            return null;
+        }
+        const session = await this.#models.Session.getInstance({ tokenHash: sha256(token) });
+        const live = await this.liveSession(session);
+        if (!live) {
+            return null;
+        }
+        return { session: this.snapshot(live), csrfToken: this.csrfTokenOf(token) };
+    }
+    /**
+     * Re-checks a session by its id with the same strength as a cookie request:
+     * live, its principal active, and touched under the liveness it was read
+     * with. What a pinned socket connection runs per request.
+     */
+    async revalidateSession(sessionIdArg) {
+        if (typeof sessionIdArg !== 'string' || sessionIdArg.length === 0) {
+            return null;
+        }
+        const live = await this.liveSession(await this.#models.Session.getInstance({ id: sessionIdArg }));
+        return live ? this.snapshot(live) : null;
+    }
+    /** Whether a session is live right now, without touching it; what a sweep asks. */
+    async isSessionLive(sessionIdArg) {
+        if (typeof sessionIdArg !== 'string' || sessionIdArg.length === 0) {
+            return false;
+        }
+        const session = await this.#models.Session.getInstance({ id: sessionIdArg });
+        if (!session || session.revokedAt !== undefined || session.expiresAt <= this.#now()) {
+            return false;
+        }
+        return this.#principals.isActive(session.userId);
+    }
+    validateCsrf(resolvedArg, candidateArg) {
+        return typeof candidateArg === 'string' && timingSafeEqualString(resolvedArg.csrfToken, candidateArg);
+    }
+    /** Ends one session; see `endSession`. */
+    async logout(sessionIdArg) {
+        return this.endSession(sessionIdArg);
+    }
+    /**
+     * Revokes a session once, with one conditional update: a touch running
+     * beside it cannot write the revocation away, and a second call finds
+     * nothing. Its provider tokens go back within `TOKEN_REVOCATION_BUDGET_MS`,
+     * after the local revocation, which never depends on the provider. Answers
+     * whether this call ended it.
+     */
+    async endSession(sessionIdArg, reasonArg = 'logout') {
+        const ended = await this.revokeSession(sessionIdArg, reasonArg);
+        if (ended) {
+            await this.revokeSealedTokens(ended);
+        }
+        return ended !== null;
+    }
+    /**
+     * Ends every live session of a principal but `keepSessionId` (a password
+     * change keeps the session that asked for it) and answers how many ended.
+     */
+    async endSessionsOfPrincipal(principalIdArg, optionsArg = {}) {
+        let ended = 0;
+        const sessions = await this.#models.Session.getInstances({
+            userId: principalIdArg,
+            revokedAt: { $exists: false },
+        });
+        for (const session of sessions) {
+            if (session.id === optionsArg.keepSessionId) {
+                continue;
+            }
+            if (await this.endSession(session.id)) {
+                ended += 1;
+            }
+        }
+        return ended;
+    }
+    clearSessionCookie() {
+        return serializeClearedCookie(this.sessionCookieName, {
+            httpOnly: true,
+            secure: this.secureCookies,
+            sameSite: 'Lax',
+        });
+    }
+    clearIntentCookie() {
+        return serializeClearedCookie(this.intentCookieName, {
+            httpOnly: true,
+            secure: this.secureCookies,
+            sameSite: 'Lax',
+        });
+    }
+    // ==========================================================================
+    // provider login
+    // ==========================================================================
+    /**
+     * Starts a sign-in transaction: one attempt document with the PKCE verifier
+     * sealed next to it, and an intent cookie that binds the callback to this
+     * browser.
+     */
+    async startLogin(returnPathArg) {
+        const provider = this.requireProvider();
+        await this.sweepExpiredAttempts();
+        const state = randomToken(32);
+        const nonce = randomToken(32);
+        const pkceVerifier = randomToken(32);
+        const bindingToken = randomToken(32);
+        const now = this.#now();
+        const attempt = new this.#models.LoginAttempt();
+        attempt.id = 'lga_' + randomToken(18);
+        attempt.stateHash = sha256(state);
+        attempt.bindingTokenHash = sha256(bindingToken);
+        attempt.sealedPkceVerifier = this.#secretBox.seal(pkceVerifier);
+        attempt.nonce = nonce;
+        attempt.returnPath = sanitizeReturnPath(returnPathArg, this.publicOrigin, this.loginPathPrefix);
+        attempt.createdAt = now;
+        attempt.expiresAt = now + LOGIN_ATTEMPT_MAX_AGE_SECONDS * 1_000;
+        await attempt.save();
+        return {
+            authorizationUrl: await provider.buildAuthorizationUrl({ state, nonce, pkceVerifier }),
+            intentCookie: serializeCookie(this.intentCookieName, bindingToken, {
+                httpOnly: true,
+                secure: this.secureCookies,
+                sameSite: 'Lax',
+                maxAgeSeconds: LOGIN_ATTEMPT_MAX_AGE_SECONDS,
+            }),
+        };
+    }
+    /**
+     * Consumes the attempt exactly once, exchanges the code, admits the
+     * principal and opens a session. A replayed callback, a foreign intent
+     * cookie and an expired attempt all find nothing to consume. Nothing of a
+     * failed login survives: its tokens are handed back before the failure
+     * leaves.
+     */
+    async completeLogin(callbackUrlArg, cookieHeaderArg) {
+        const provider = this.requireProvider();
+        const states = callbackUrlArg.searchParams.getAll('state');
+        if (states.length !== 1 || !states[0]) {
+            throw new RelyingPartyError('invalid_login_callback');
+        }
+        const bindingToken = parseCookies(cookieHeaderArg).get(this.intentCookieName);
+        if (!bindingToken || bindingToken.length > MAX_COOKIE_TOKEN_LENGTH) {
+            throw new RelyingPartyError('missing_login_intent');
+        }
+        const now = this.#now();
+        const claimed = await this.#models.LoginAttempt.atomicFindOneAndUpdate({
+            stateHash: sha256(states[0]),
+            bindingTokenHash: sha256(bindingToken),
+            consumedAt: null,
+            expiresAt: { $gt: now },
+        }, { $set: { consumedAt: now } }, { returnDocument: 'after' });
+        if (claimed.status !== 'matched' || !claimed.document) {
+            throw new RelyingPartyError('invalid_or_replayed_login');
+        }
+        const attempt = claimed.document;
+        let completion;
+        let stage = 'token_exchange';
+        try {
+            completion = await provider.completeAuthorization({
+                callbackUrl: callbackUrlArg,
+                state: states[0],
+                nonce: attempt.nonce,
+                pkceVerifier: this.#secretBox.open(attempt.sealedPkceVerifier),
+            });
+            stage = 'principal_admission';
+            const { principalId } = await this.#principals.admit(completion);
+            stage = 'session_persistence';
+            return await this.createProviderSession(attempt, principalId, completion);
+        }
+        catch (error) {
+            if (completion) {
+                await this.revokeCompletionTokens(completion);
+            }
+            if (error instanceof RelyingPartyError || error instanceof RelyingPartyRefusal) {
+                throw error;
+            }
+            if (error instanceof OidcCompletionError) {
+                throw new LoginCallbackError(error.stage, error);
+            }
+            throw new LoginCallbackError(stage, error);
+        }
+    }
+    /**
+     * The provider sent the browser back without a code. The attempt is
+     * consumed so its state can never complete afterwards; a callback that
+     * matches no open attempt leaves nothing to do.
+     */
+    async abandonLogin(callbackUrlArg, cookieHeaderArg) {
+        const states = callbackUrlArg.searchParams.getAll('state');
+        const bindingToken = parseCookies(cookieHeaderArg).get(this.intentCookieName);
+        if (states.length !== 1
+            || !states[0]
+            || !bindingToken
+            || bindingToken.length > MAX_COOKIE_TOKEN_LENGTH) {
+            return;
+        }
+        await this.#models.LoginAttempt.atomicUpdate({ stateHash: sha256(states[0]), bindingTokenHash: sha256(bindingToken), consumedAt: null }, { $set: { consumedAt: this.#now() } });
+    }
+    /**
+     * The last step of a login: the browser arrives with both cookies, and the
+     * return path is released only when the session cookie belongs to the
+     * session this very attempt created.
+     */
+    async finalizeLogin(cookieHeaderArg) {
+        this.requireProvider();
+        const bindingToken = parseCookies(cookieHeaderArg).get(this.intentCookieName);
+        if (!bindingToken || bindingToken.length > MAX_COOKIE_TOKEN_LENGTH) {
+            throw new RelyingPartyError('invalid_login_finalize');
+        }
+        const attempt = await this.#models.LoginAttempt.getInstance({ bindingTokenHash: sha256(bindingToken) });
+        if (!attempt
+            || attempt.consumedAt === undefined
+            || attempt.consumedAt === null
+            || !attempt.createdSessionId
+            || attempt.expiresAt <= this.#now()) {
+            throw new RelyingPartyError('invalid_login_finalize');
+        }
+        const resolved = await this.resolveCookieSession(cookieHeaderArg);
+        if (!resolved
+            || resolved.session.id !== attempt.createdSessionId
+            || resolved.session.loginAttemptId !== attempt.id) {
+            throw new RelyingPartyError('invalid_login_finalize');
+        }
+        return sanitizeReturnPath(attempt.returnPath, this.publicOrigin, this.loginPathPrefix);
+    }
+    // ==========================================================================
+    // provider tokens
+    // ==========================================================================
+    /**
+     * An access token of this login session that is usable right now. A token
+     * within `ACCESS_TOKEN_REFRESH_SKEW_MS` of its expiry — or one whose expiry
+     * is unknown — is rotated first. The session has to belong to
+     * `expectedPrincipalIdArg`, so a credential is never evaluated with another
+     * person's tokens.
+     */
+    async liveProviderToken(sessionIdArg, expectedPrincipalIdArg) {
+        const session = await this.#models.Session.getInstance({ id: sessionIdArg });
+        const now = this.#now();
+        if (!session
+            || session.revokedAt !== undefined
+            || session.expiresAt <= now
+            || !session.idpSubject
+            || session.userId !== expectedPrincipalIdArg) {
+            throw new AuthorityTokenError('authority_login_required');
+        }
+        const subject = session.idpSubject;
+        const expiresAt = typeof session.accessTokenExpiresAt === 'number' ? session.accessTokenExpiresAt : 0;
+        const accessToken = this.openSealed(session.sealedAccessToken);
+        // an unknown expiry is rotated too: afterwards the lifetime is known
+        const due = accessToken === undefined || expiresAt === 0 || expiresAt <= now + ACCESS_TOKEN_REFRESH_SKEW_MS;
+        if (!due && accessToken !== undefined) {
+            return { accessToken, subject, expiresAt };
+        }
+        if (!session.sealedRefreshToken) {
+            if (accessToken !== undefined && (expiresAt === 0 || expiresAt > now)) {
+                // nothing to rotate with, and the token is not known to be dead
+                return { accessToken, subject, expiresAt };
+            }
+            await this.endProviderSession(sessionIdArg, 'access_token_unusable');
+            throw new AuthorityTokenError('authority_login_required');
+        }
+        return this.refreshProviderToken(sessionIdArg, subject);
+    }
+    async refreshProviderToken(sessionIdArg, subjectArg) {
+        const running = this.#refreshesInFlight.get(sessionIdArg);
+        if (running) {
+            return running;
+        }
+        const pending = this.runProviderRefresh(sessionIdArg, subjectArg).finally(() => {
+            this.#refreshesInFlight.delete(sessionIdArg);
+        });
+        this.#refreshesInFlight.set(sessionIdArg, pending);
+        return pending;
+    }
+    async runProviderRefresh(sessionIdArg, subjectArg) {
+        const provider = this.#provider;
+        if (!provider) {
+            throw new AuthorityTokenError('authority_unavailable');
+        }
+        const now = this.#now();
+        const lockUntil = now + this.refreshLockMs;
+        const claimed = await this.#models.Session.atomicFindOneAndUpdate({
+            id: sessionIdArg,
+            revokedAt: { $exists: false },
+            expiresAt: { $gt: now },
+            // a lock another replica holds is left alone until it expires
+            $or: [{ refreshLockUntil: { $lt: now } }, { refreshLockUntil: { $exists: false } }],
+        }, { $set: { refreshLockUntil: lockUntil } }, { returnDocument: 'after' });
+        if (claimed.status !== 'matched' || !claimed.document) {
+            return this.tokenAfterForeignRefresh(sessionIdArg, subjectArg);
+        }
+        const session = claimed.document;
+        // the lock holder decides on the state it just read: a rotation that
+        // landed in between is used as it stands, because spending a superseded
+        // refresh token would be reuse and would kill the family
+        const claimedExpiry = typeof session.accessTokenExpiresAt === 'number' ? session.accessTokenExpiresAt : 0;
+        const claimedToken = this.openSealed(session.sealedAccessToken);
+        if (claimedToken !== undefined && claimedExpiry > this.#now() + ACCESS_TOKEN_REFRESH_SKEW_MS) {
+            await this.#models.Session.atomicUpdate({ id: sessionIdArg, revokedAt: { $exists: false }, refreshLockUntil: lockUntil }, { $set: { refreshLockUntil: 0 } });
+            return { accessToken: claimedToken, subject: subjectArg, expiresAt: claimedExpiry };
+        }
+        const refreshToken = this.openSealed(session.sealedRefreshToken);
+        if (refreshToken === undefined) {
+            await this.endProviderSession(sessionIdArg, 'sealed_refresh_token_unreadable');
+            throw new AuthorityTokenError('authority_login_required');
+        }
+        let rotated;
+        try {
+            rotated = await provider.refreshTokens(refreshToken);
+        }
+        catch (error) {
+            if (error instanceof OidcRefreshRefusedError) {
+                await this.endProviderSession(sessionIdArg, 'refresh_token_refused');
+                throw new AuthorityTokenError('authority_login_required', error);
+            }
+            this.emit({ event: 'idp_token_refresh_failed', sessionId: sessionIdArg, message: errorMessage(error) });
+            throw new AuthorityTokenError('authority_unavailable', error);
+        }
+        // the rotated pair replaces the old one under this lock, and only while
+        // the session is live: a logout in between leaves the update unmatched
+        let matched;
+        try {
+            const written = await this.#models.Session.atomicUpdate({ id: sessionIdArg, revokedAt: { $exists: false }, refreshLockUntil: lockUntil }, {
+                $set: {
+                    sealedAccessToken: this.#secretBox.seal(rotated.accessToken),
+                    ...(rotated.refreshToken ? { sealedRefreshToken: this.#secretBox.seal(rotated.refreshToken) } : {}),
+                    accessTokenExpiresAt: rotated.accessTokenExpiresAt,
+                    refreshLockUntil: 0,
+                },
+            });
+            matched = written.matchedCount;
+        }
+        catch (error) {
+            // the provider has superseded the old pair and nothing here can name the
+            // new one: it goes back at once, the lock expires on its own, and the
+            // request fails closed
+            await this.revokeRotatedTokens(rotated);
+            this.emit({ event: 'idp_token_store_failed', sessionId: sessionIdArg, message: errorMessage(error) });
+            throw new AuthorityTokenError('authority_unavailable', error);
+        }
+        if (matched === 0) {
+            await this.revokeRotatedTokens(rotated);
+            this.notifySessionEnded({ sessionId: sessionIdArg, reason: 'revoked_elsewhere', revokedHere: false });
+            throw new AuthorityTokenError('authority_login_required');
+        }
+        return { accessToken: rotated.accessToken, subject: subjectArg, expiresAt: rotated.accessTokenExpiresAt };
+    }
+    /**
+     * Another replica is rotating this session right now. Whatever it has
+     * written by the time this request looks again is used; otherwise the
+     * request fails closed and the next one finds the rotated pair.
+     */
+    async tokenAfterForeignRefresh(sessionIdArg, subjectArg) {
+        const session = await this.#models.Session.getInstance({ id: sessionIdArg });
+        const now = this.#now();
+        const expiresAt = typeof session?.accessTokenExpiresAt === 'number' ? session.accessTokenExpiresAt : 0;
+        const accessToken = session ? this.openSealed(session.sealedAccessToken) : undefined;
+        if (session
+            && session.revokedAt === undefined
+            && session.expiresAt > now
+            && accessToken !== undefined
+            && expiresAt > now + ACCESS_TOKEN_REFRESH_SKEW_MS) {
+            return { accessToken, subject: subjectArg, expiresAt };
+        }
+        throw new AuthorityTokenError('authority_unavailable');
+    }
+    // ==========================================================================
+    // internals
+    // ==========================================================================
+    requireProvider() {
+        if (!this.#provider) {
+            throw new RelyingPartyError('login_method_unavailable');
+        }
+        return this.#provider;
+    }
+    newSessionDoc(tokenArg, principalIdArg) {
+        const now = this.#now();
+        const session = new this.#models.Session();
+        session.id = 'ses_' + randomToken(18);
+        session.tokenHash = sha256(tokenArg);
+        session.userId = principalIdArg;
+        session.createdAt = now;
+        session.lastSeenAt = now;
+        session.expiresAt = now + this.sessionMaxAgeSeconds * 1_000;
+        return session;
+    }
+    csrfTokenOf(tokenArg) {
+        return deriveCsrfToken(tokenArg, this.#csrfKey, this.#csrfLabel);
+    }
+    opening(sessionArg, tokenArg) {
+        return {
+            session: this.snapshot(sessionArg),
+            csrfToken: this.csrfTokenOf(tokenArg),
+            sessionCookie: serializeCookie(this.sessionCookieName, tokenArg, {
+                httpOnly: true,
+                secure: this.secureCookies,
+                sameSite: 'Lax',
+                maxAgeSeconds: this.sessionMaxAgeSeconds,
+            }),
+        };
+    }
+    snapshot(sessionArg) {
+        return {
+            id: sessionArg.id,
+            principalId: sessionArg.userId,
+            createdAt: sessionArg.createdAt,
+            lastSeenAt: sessionArg.lastSeenAt,
+            expiresAt: sessionArg.expiresAt,
+            ...(sessionArg.idpSubject ? { idpSubject: sessionArg.idpSubject } : {}),
+            ...(sessionArg.loginAttemptId ? { loginAttemptId: sessionArg.loginAttemptId } : {}),
+        };
+    }
+    /** A session document that is live right now with an active principal, touched at most once a minute. */
+    async liveSession(sessionArg) {
+        const now = this.#now();
+        if (!sessionArg || sessionArg.revokedAt !== undefined || sessionArg.expiresAt <= now) {
+            return null;
+        }
+        if (!(await this.#principals.isActive(sessionArg.userId))) {
+            return null;
+        }
+        if (now - sessionArg.lastSeenAt > SESSION_TOUCH_INTERVAL_MS) {
+            // the touch carries the liveness it was read under into the write: a
+            // revocation that landed in between leaves it unmatched
+            const touched = await this.#models.Session.atomicUpdate({ id: sessionArg.id, revokedAt: { $exists: false }, expiresAt: { $gt: now } }, { $set: { lastSeenAt: now } });
+            if (touched.matchedCount === 0) {
+                return null;
+            }
+            sessionArg.lastSeenAt = now;
+        }
+        return sessionArg;
+    }
+    async createProviderSession(attemptArg, principalIdArg, completionArg) {
+        const token = randomToken(32);
+        const session = this.newSessionDoc(token, principalIdArg);
+        session.idpSubject = completionArg.subject;
+        session.loginAttemptId = attemptArg.id;
+        session.sealedAccessToken = this.#secretBox.seal(completionArg.accessToken);
+        session.sealedRefreshToken = completionArg.refreshToken ? this.#secretBox.seal(completionArg.refreshToken) : '';
+        session.accessTokenExpiresAt = completionArg.accessTokenExpiresAt;
+        session.refreshLockUntil = 0;
+        await session.save();
+        const linked = await this.#models.LoginAttempt.atomicUpdate({ id: attemptArg.id, createdSessionId: null }, { $set: { createdSessionId: session.id } });
+        if (linked.matchedCount !== 1) {
+            // the attempt was consumed by another callback in the meantime
+            await this.discardUnopenedSession(session.id);
+            throw new RelyingPartyError('invalid_or_replayed_login');
+        }
+        const opening = this.opening(session, token);
+        try {
+            await this.#hooks.onProviderSessionOpened?.({ session: opening.session });
+        }
+        catch (error) {
+            // the cookie never leaves, so the session is unreachable: it is revoked
+            // and its sealed tokens erased before the application's error goes on;
+            // the caller hands the provider tokens back
+            try {
+                await this.discardUnopenedSession(session.id);
+            }
+            catch (discardError) {
+                this.emit({ event: 'session_discard_failed', sessionId: session.id, message: errorMessage(discardError) });
+            }
+            throw error;
+        }
+        return opening;
+    }
+    /** Revokes a session that was never handed out and erases its sealed tokens. */
+    async discardUnopenedSession(sessionIdArg) {
+        await this.#models.Session.atomicUpdate({ id: sessionIdArg, revokedAt: { $exists: false } }, { $set: { revokedAt: this.#now(), ...REVOKED_TOKEN_FIELDS } });
+    }
+    /**
+     * Tells the application a session ended. Its hook never stands between the
+     * local revocation and the provider revocation: a throw or a rejection is
+     * reported as `hook_failed` and the end runs on.
+     */
+    notifySessionEnded(eventArg) {
+        const hook = this.#hooks.onSessionEnded;
+        if (!hook) {
+            return;
+        }
+        const reportFailure = (errorArg) => {
+            this.emit({ event: 'hook_failed', hook: 'onSessionEnded', sessionId: eventArg.sessionId, message: errorMessage(errorArg) });
+        };
+        try {
+            const result = hook.call(this.#hooks, eventArg);
+            if (result instanceof Promise) {
+                result.catch(reportFailure);
+            }
+        }
+        catch (error) {
+            reportFailure(error);
+        }
+    }
+    /**
+     * The conditional revocation every end of a session runs. Answers the
+     * sealed tokens it took off the session when this call revoked it, `null`
+     * when the session was already over.
+     */
+    async revokeSession(sessionIdArg, reasonArg) {
+        if (typeof sessionIdArg !== 'string' || sessionIdArg.length === 0) {
+            return null;
+        }
+        const revoked = await this.#models.Session.atomicFindOneAndUpdate({ id: sessionIdArg, revokedAt: { $exists: false } }, { $set: { revokedAt: this.#now(), ...REVOKED_TOKEN_FIELDS } }, { returnDocument: 'before' });
+        const revokedHere = revoked.status === 'matched' && revoked.document !== null;
+        this.notifySessionEnded({ sessionId: sessionIdArg, reason: reasonArg, revokedHere });
+        if (!revokedHere) {
+            return null;
+        }
+        const before = revoked.document;
+        return { sealedAccessToken: before.sealedAccessToken, sealedRefreshToken: before.sealedRefreshToken };
+    }
+    /** The provider says the login is over: the session ends here without asking it anything more. */
+    async endProviderSession(sessionIdArg, reasonArg) {
+        if (await this.revokeSession(sessionIdArg, reasonArg)) {
+            this.emit({ event: 'idp_session_ended', sessionId: sessionIdArg, reason: reasonArg });
+        }
+    }
+    /**
+     * Hands the tokens of an ended session back, best-effort and within the
+     * budget. A sealed value this deployment can no longer open is skipped.
+     */
+    async revokeSealedTokens(sealedArg) {
+        if (!this.#provider || (!sealedArg.sealedAccessToken && !sealedArg.sealedRefreshToken)) {
+            return;
+        }
+        await this.withinRevocationBudget(async () => {
+            for (const [sealed, hint] of [
+                [sealedArg.sealedRefreshToken, 'refresh_token'],
+                [sealedArg.sealedAccessToken, 'access_token'],
+            ]) {
+                if (!sealed) {
+                    continue;
+                }
+                const token = this.openSealed(sealed);
+                if (token === undefined) {
+                    this.emit({ event: 'oidc_sealed_token_unreadable', hint, message: 'The sealed provider token could not be opened' });
+                    continue;
+                }
+                await this.revokeToken(token, hint);
+            }
+        });
+    }
+    async revokeRotatedTokens(rotatedArg) {
+        await this.withinRevocationBudget(async () => {
+            if (rotatedArg.refreshToken) {
+                await this.revokeToken(rotatedArg.refreshToken, 'refresh_token');
+            }
+            await this.revokeToken(rotatedArg.accessToken, 'access_token');
+        });
+    }
+    async revokeCompletionTokens(completionArg) {
+        await this.withinRevocationBudget(async () => {
+            if (completionArg.refreshToken) {
+                await this.revokeToken(completionArg.refreshToken, 'refresh_token');
+            }
+            await this.revokeToken(completionArg.accessToken, 'access_token');
+        });
+    }
+    async revokeToken(tokenArg, hintArg) {
+        try {
+            await this.#provider?.revokeToken(tokenArg, hintArg);
+        }
+        catch (error) {
+            // the local session is gone either way; the provider expires the token
+            this.emit({ event: 'oidc_token_revocation_failed', hint: hintArg, message: errorMessage(error) });
+        }
+    }
+    /**
+     * Runs a best-effort provider step under `TOKEN_REVOCATION_BUDGET_MS`. What
+     * is still in flight at the deadline keeps running and ends on the provider
+     * client's own request timeout; only the waiting stops. The timer is cleared
+     * on every path and unreferenced.
+     */
+    async withinRevocationBudget(workArg) {
+        let timer;
+        const work = workArg().then(() => 'done', (errorArg) => {
+            this.emit({ event: 'oidc_token_revocation_failed', message: errorMessage(errorArg) });
+            return 'done';
+        });
+        const deadline = new Promise((resolveArg) => {
+            timer = setTimeout(() => resolveArg('deadline'), TOKEN_REVOCATION_BUDGET_MS);
+            timer.unref();
+        });
+        try {
+            if ((await Promise.race([work, deadline])) === 'deadline') {
+                this.emit({
+                    event: 'oidc_token_revocation_timed_out',
+                    message: 'The provider did not answer within the revocation budget',
+                });
+            }
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    /** A sealed value this deployment can still open, or `undefined`. */
+    openSealed(sealedArg) {
+        if (!sealedArg) {
+            return undefined;
+        }
+        try {
+            return this.#secretBox.open(sealedArg);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * Removes attempts an hour past their expiry, one bounded page per login
+     * start. A sweep that cannot run never blocks a sign-in.
+     */
+    async sweepExpiredAttempts() {
+        try {
+            const page = await this.#models.LoginAttempt.getPagedInstances({
+                filter: { expiresAt: { $lt: this.#now() - LOGIN_ATTEMPT_SWEEP_GRACE_MS } },
+                sortField: 'expiresAt',
+                sortDirection: 'asc',
+                limit: LOGIN_ATTEMPT_SWEEP_BATCH,
+            });
+            for (const attempt of page.documents) {
+                await this.#models.LoginAttempt.atomicDelete({ id: attempt.id });
+            }
+        }
+        catch (error) {
+            this.emit({ event: 'login_attempt_sweep_failed', message: errorMessage(error) });
+        }
+    }
+    /**
+     * Reports one diagnostic. Every cleanup step reports through here, so a
+     * throwing sink must not end it: the event and the sink's failure go to
+     * `console.error` instead.
+     */
+    emit(eventArg) {
+        const sink = this.#hooks.onEvent;
+        if (!sink) {
+            console.error(JSON.stringify(eventArg));
+            return;
+        }
+        const reportFailure = (errorArg) => {
+            const failure = { event: 'hook_failed', hook: 'onEvent', message: errorMessage(errorArg) };
+            console.error(JSON.stringify(failure));
+            console.error(JSON.stringify(eventArg));
+        };
+        try {
+            const result = sink.call(this.#hooks, eventArg);
+            if (result instanceof Promise) {
+                result.catch(reportFailure);
+            }
+        }
+        catch (error) {
+            reportFailure(error);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.relyingpartysessions.js","sourceRoot":"","sources":["../../ts_relyingparty/classes.relyingpartysessions.ts"],"names":[],"mappings":"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"}