@idp.global/sdk 18.0.1 → 18.1.0

package/dist_ts_relyingparty/classes.idpoidcprovider.js

@@ -0,0 +1,255 @@
+import * as plugins from './plugins.js';
+import { OidcIntrospectionClient, OidcIntrospectionError, } from '../dist_ts_server/classes.oidc-introspection-client.js';
+/** The provider could not be asked, or did not answer in its own contract. The caller fails closed on it. */
+export class OidcAuthorityUnavailableError extends Error {
+    reason;
+    constructor(reason, causeArg) {
+        super('The identity provider could not be observed', { cause: causeArg });
+        this.reason = reason;
+        this.name = 'OidcAuthorityUnavailableError';
+    }
+}
+/** The provider refused the refresh with `invalid_grant`: the refresh family is revoked, expired or was reused. */
+export class OidcRefreshRefusedError extends Error {
+    constructor(causeArg) {
+        super('The identity provider refused the refresh', { cause: causeArg });
+        this.name = 'OidcRefreshRefusedError';
+    }
+}
+export class OidcCompletionError extends Error {
+    stage;
+    constructor(stage, causeArg) {
+        super('OIDC completion failed', { cause: causeArg });
+        this.stage = stage;
+        this.name = 'OidcCompletionError';
+    }
+}
+/**
+ * The scopes a relying party asks for. `organizations` and `roles` are what
+ * idp.global reports memberships under.
+ */
+export const IDP_OIDC_DEFAULT_SCOPES = 'openid profile email organizations roles';
+export const IDP_OIDC_DEFAULT_REQUEST_TIMEOUT_SECONDS = 10;
+const optionalString = (valueArg) => typeof valueArg === 'string' && valueArg.trim().length > 0 ? valueArg.trim() : undefined;
+/** When an access token dies, from the `expires_in` of a token response; `0` when it names none. */
+const expiryOf = (expiresInArg) => typeof expiresInArg === 'number' && Number.isFinite(expiresInArg) && expiresInArg > 0
+    ? Date.now() + Math.floor(expiresInArg) * 1_000
+    : 0;
+/**
+ * Organization claims as idp.global documents them: `id`, `name`, `slug` and
+ * the member's roles. Anything that is not that exact shape is dropped rather
+ * than guessed at.
+ */
+export const readOrganizationClaims = (valueArg) => {
+    if (!Array.isArray(valueArg)) {
+        return [];
+    }
+    const organizations = [];
+    for (const entry of valueArg) {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+            continue;
+        }
+        const candidate = entry;
+        const id = optionalString(candidate.id);
+        const name = optionalString(candidate.name);
+        const slug = optionalString(candidate.slug);
+        if (!id || !name || !slug) {
+            continue;
+        }
+        const roles = Array.isArray(candidate.roles)
+            ? candidate.roles.filter((roleArg) => typeof roleArg === 'string')
+            : [];
+        organizations.push({ id, name, slug, roles });
+    }
+    return organizations;
+};
+/**
+ * The relying-party side of the authorization code flow with S256 PKCE on
+ * `openid-client`, in the profile idp.global supports: code responses, S256
+ * challenges, RS256 ID tokens and `client_secret_basic` for a confidential
+ * client. Live organization authority is observed with the sdk's
+ * `OidcIntrospectionClient`.
+ */
+export class IdpOidcProvider {
+    requestTimeoutSeconds;
+    #options;
+    #configuration;
+    #introspection;
+    constructor(optionsArg) {
+        if (!(optionsArg?.issuer instanceof URL) || !(optionsArg.redirectUri instanceof URL)) {
+            throw new Error('IdpOidcProvider needs the issuer and the redirect URI as URLs');
+        }
+        if (!optionalString(optionsArg.clientId) || !optionalString(optionsArg.clientSecret)) {
+            throw new Error('IdpOidcProvider needs a client id and a client secret');
+        }
+        const timeout = optionsArg.requestTimeoutSeconds ?? IDP_OIDC_DEFAULT_REQUEST_TIMEOUT_SECONDS;
+        if (!Number.isSafeInteger(timeout) || timeout < 1 || timeout > 60) {
+            throw new Error('IdpOidcProvider requestTimeoutSeconds must be an integer from 1 to 60');
+        }
+        this.requestTimeoutSeconds = timeout;
+        this.#options = optionsArg;
+    }
+    get configuration() {
+        if (!this.#configuration) {
+            throw new Error('The identity provider is not initialized');
+        }
+        return this.#configuration;
+    }
+    async init() {
+        if (this.#configuration) {
+            return;
+        }
+        const options = this.#options;
+        // the timeout given to discovery bounds discovery itself and stays on the
+        // resolved configuration for every later request
+        const configuration = await plugins.openidClient.discovery(options.issuer, options.clientId, {
+            client_secret: options.clientSecret,
+            token_endpoint_auth_method: 'client_secret_basic',
+            id_token_signed_response_alg: 'RS256',
+        }, plugins.openidClient.ClientSecretBasic(options.clientSecret), { timeout: this.requestTimeoutSeconds });
+        const metadata = configuration.serverMetadata();
+        if (!metadata.authorization_endpoint || !metadata.token_endpoint || !metadata.jwks_uri) {
+            throw new Error('The identity provider is missing required OIDC endpoints');
+        }
+        if (!metadata.code_challenge_methods_supported?.includes('S256')) {
+            throw new Error('The identity provider must support PKCE S256');
+        }
+        if (metadata.id_token_signing_alg_values_supported
+            && !metadata.id_token_signing_alg_values_supported.includes('RS256')) {
+            throw new Error('The identity provider must sign ID tokens with RS256');
+        }
+        if (metadata.grant_types_supported && !metadata.grant_types_supported.includes('authorization_code')) {
+            throw new Error('The identity provider must support the authorization_code grant');
+        }
+        if (metadata.grant_types_supported && !metadata.grant_types_supported.includes('refresh_token')) {
+            // without rotation the access token dies long before the session does
+            throw new Error('The identity provider must support the refresh_token grant');
+        }
+        this.#introspection = new OidcIntrospectionClient({
+            issuer: options.issuer.origin,
+            clientId: options.clientId,
+            clientSecret: options.clientSecret,
+            ...(options.introspectionTimeoutMs !== undefined ? { timeoutMs: options.introspectionTimeoutMs } : {}),
+        });
+        this.#configuration = configuration;
+    }
+    async buildAuthorizationUrl(optionsArg) {
+        const codeChallenge = await plugins.openidClient.calculatePKCECodeChallenge(optionsArg.pkceVerifier);
+        return plugins.openidClient.buildAuthorizationUrl(this.configuration, {
+            redirect_uri: this.#options.redirectUri.href,
+            response_type: 'code',
+            scope: this.#options.scopes ?? IDP_OIDC_DEFAULT_SCOPES,
+            code_challenge: codeChallenge,
+            code_challenge_method: 'S256',
+            state: optionsArg.state,
+            nonce: optionsArg.nonce,
+        });
+    }
+    async completeAuthorization(optionsArg) {
+        let tokens;
+        try {
+            tokens = await plugins.openidClient.authorizationCodeGrant(this.configuration, optionsArg.callbackUrl, {
+                pkceCodeVerifier: optionsArg.pkceVerifier,
+                expectedState: optionsArg.state,
+                expectedNonce: optionsArg.nonce,
+                idTokenExpected: true,
+            });
+        }
+        catch (error) {
+            throw new OidcCompletionError('token_exchange', error);
+        }
+        let subject;
+        try {
+            const claims = tokens.claims();
+            if (!claims?.sub) {
+                throw new Error('The token response carries no subject');
+            }
+            subject = claims.sub;
+        }
+        catch (error) {
+            throw new OidcCompletionError('token_validation', error);
+        }
+        // UserInfo is the current view of profile and organization claims; the ID
+        // token proves the login. Both are read, and the subjects must agree.
+        let userInfo;
+        try {
+            userInfo = await plugins.openidClient.fetchUserInfo(this.configuration, tokens.access_token, subject);
+        }
+        catch (error) {
+            throw new OidcCompletionError('userinfo', error);
+        }
+        if (userInfo.sub !== subject) {
+            throw new OidcCompletionError('token_validation', new Error('The UserInfo subject does not match the ID token'));
+        }
+        return {
+            subject,
+            accessToken: tokens.access_token,
+            ...(tokens.refresh_token ? { refreshToken: tokens.refresh_token } : {}),
+            accessTokenExpiresAt: expiryOf(tokens.expires_in),
+            email: optionalString(userInfo.email),
+            emailVerified: userInfo.email_verified === true,
+            displayName: optionalString(userInfo.name) || optionalString(userInfo.preferred_username),
+            organizations: readOrganizationClaims(Reflect.get(userInfo, 'organizations')),
+        };
+    }
+    async revokeToken(tokenArg, hintArg) {
+        await plugins.openidClient.tokenRevocation(this.configuration, tokenArg, { token_type_hint: hintArg });
+    }
+    /**
+     * One `POST /oauth/introspect` through the confidential introspection
+     * client, which validates the whole answer before this code sees it. A
+     * refusal (`active: false`) is an answer; anything else is a failure to
+     * observe.
+     */
+    async introspectOrganization(optionsArg) {
+        if (!this.#introspection) {
+            throw new Error('The identity provider is not initialized');
+        }
+        let response;
+        try {
+            response = await this.#introspection.introspect({
+                token: optionsArg.accessToken,
+                subject: optionsArg.subject,
+                organizationId: optionsArg.organizationId,
+            });
+        }
+        catch (error) {
+            if (error instanceof OidcIntrospectionError) {
+                if (error.code === 'invalid_request') {
+                    // a request the endpoint's own client refuses is a defect of the
+                    // caller, never an answer about access
+                    throw error;
+                }
+                throw new OidcAuthorityUnavailableError(error.code, error);
+            }
+            throw new OidcAuthorityUnavailableError('unavailable', error);
+        }
+        if (!response.active) {
+            return { active: false, roles: [], expiresAt: 0 };
+        }
+        return {
+            active: true,
+            roles: response.idp_global_authority.roles,
+            expiresAt: response.exp * 1_000,
+        };
+    }
+    /** The refresh grant with rotation; a superseded refresh token is never kept by the caller. */
+    async refreshTokens(refreshTokenArg) {
+        let tokens;
+        try {
+            tokens = await plugins.openidClient.refreshTokenGrant(this.configuration, refreshTokenArg);
+        }
+        catch (error) {
+            if (error instanceof plugins.openidClient.ResponseBodyError && error.error === 'invalid_grant') {
+                throw new OidcRefreshRefusedError(error);
+            }
+            throw new OidcAuthorityUnavailableError('unavailable', error);
+        }
+        return {
+            accessToken: tokens.access_token,
+            ...(tokens.refresh_token ? { refreshToken: tokens.refresh_token } : {}),
+            accessTokenExpiresAt: expiryOf(tokens.expires_in),
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.idpoidcprovider.js","sourceRoot":"","sources":["../../ts_relyingparty/classes.idpoidcprovider.ts"],"names":[],"mappings":"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"}

package/dist_ts_relyingparty/classes.relyingpartyroutes.d.ts

@@ -0,0 +1,84 @@
+import type { RelyingPartySessions } from './classes.relyingpartysessions.js';
+import type { IResolvedRelyingPartySession } from './interfaces.js';
+/**
+ * The part of an HTTP request context the routes read. `IRequestContext` of
+ * `@push.rocks/smartserve` — what a typedserver `IRouteHandler` receives —
+ * satisfies it, so the routes plug into `addRoute()` / `addCustomRoutes()`
+ * without the sdk depending on either package.
+ */
+export interface IRelyingPartyHttpContext {
+    readonly method: string;
+    readonly url: URL;
+    readonly headers: Headers;
+    readonly request: Request;
+}
+export interface IRelyingPartyRoutesOptions {
+    sessions: RelyingPartySessions;
+    /** where a sign-in that did not finish sends the browser; no provider text is ever echoed into it */
+    failureLocation: string;
+    /**
+     * Where a refusal of the application (`RelyingPartyRefusal.code`) sends the
+     * browser, so the application can explain it; a refusal not named here is
+     * answered as a failed authentication with its status.
+     */
+    refusalLocations?: Readonly<Record<string, string>>;
+    /**
+     * The body `GET <prefix>session` answers with. Default:
+     * `{ session: { sessionId, principalId, expiresAt, csrfToken } | null }`.
+     */
+    sessionAnswer?(resolvedArg: IResolvedRelyingPartySession | null): Promise<object>;
+    /** the largest logout 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
+     * line to `console.error`. A throwing sink never changes the answer: the
+     * event and its failure go to `console.error` instead.
+     */
+    onRouteEvent?(eventArg: {
+        event: 'auth_login_start_failed' | 'auth_callback_failed' | 'auth_callback_declined' | 'auth_callback_refused';
+        stage?: string;
+        code?: string;
+        correlationId?: string;
+        message?: string;
+    }): void;
+}
+/**
+ * The HTTP steps of a relying-party login, all under the sessions' login path
+ * prefix (default `/auth/`):
+ *
+ * - `GET login?return=…` redirects to the provider and sets the intent cookie
+ * - `GET callback` consumes the attempt once and sets the session cookie; a
+ *   provider `error` abandons the attempt
+ * - `GET finalize` releases the return path only to the browser holding the
+ *   session this attempt created
+ * - `GET session` answers the current session
+ * - `POST logout` ends the session; it needs this origin and the CSRF token
+ *
+ * `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`.
+ */
+export declare class RelyingPartyRoutes {
+    #private;
+    constructor(optionsArg: IRelyingPartyRoutesOptions);
+    /** The paths the routes answer, for registering them one by one. */
+    get paths(): {
+        login: string;
+        callback: string;
+        finalize: string;
+        session: string;
+        logout: string;
+    };
+    readonly handle: (contextArg: IRelyingPartyHttpContext) => Promise<Response | null>;
+    private login;
+    private callback;
+    private logout;
+    private sessionAnswer;
+    /**
+     * A JSON body within `maxBodyBytes`, or `null`. The limit holds while the
+     * body streams, whatever `Content-Length` claims or omits: the read is
+     * cancelled at the first chunk that passes it.
+     */
+    private readJsonBody;
+    private emit;
+}

package/dist_ts_relyingparty/classes.relyingpartyroutes.js

@@ -0,0 +1,232 @@
+import * as plugins from './plugins.js';
+import { LoginCallbackError, RelyingPartyError, RelyingPartyRefusal } from './classes.errors.js';
+const DEFAULT_MAX_BODY_BYTES = 16 * 1024;
+/** What the provider names in a callback it did not issue a code for. */
+const MAX_PROVIDER_ERROR_CODE_LENGTH = 64;
+const noStoreHeaders = (headersArg) => {
+    const headers = new Headers(headersArg);
+    headers.set('Cache-Control', 'no-store');
+    headers.set('Pragma', 'no-cache');
+    headers.set('Cross-Origin-Resource-Policy', 'same-origin');
+    return headers;
+};
+const jsonResponse = (bodyArg, statusArg, headersArg) => {
+    const headers = noStoreHeaders(headersArg);
+    headers.set('Content-Type', 'application/json; charset=utf-8');
+    return new Response(JSON.stringify(bodyArg), { status: statusArg, headers });
+};
+const redirect = (locationArg, headersArg) => new Response(null, { status: 302, headers: noStoreHeaders({ Location: locationArg, ...headersArg }) });
+/**
+ * The HTTP steps of a relying-party login, all under the sessions' login path
+ * prefix (default `/auth/`):
+ *
+ * - `GET login?return=…` redirects to the provider and sets the intent cookie
+ * - `GET callback` consumes the attempt once and sets the session cookie; a
+ *   provider `error` abandons the attempt
+ * - `GET finalize` releases the return path only to the browser holding the
+ *   session this attempt created
+ * - `GET session` answers the current session
+ * - `POST logout` ends the session; it needs this origin and the CSRF token
+ *
+ * `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`.
+ */
+export class RelyingPartyRoutes {
+    #sessions;
+    #options;
+    #maxBodyBytes;
+    constructor(optionsArg) {
+        this.#sessions = optionsArg.sessions;
+        this.#options = optionsArg;
+        this.#maxBodyBytes = optionsArg.maxBodyBytes ?? DEFAULT_MAX_BODY_BYTES;
+    }
+    /** The paths the routes answer, for registering them one by one. */
+    get paths() {
+        const prefix = this.#sessions.loginPathPrefix;
+        return {
+            login: prefix + 'login',
+            callback: prefix + 'callback',
+            finalize: prefix + 'finalize',
+            session: prefix + 'session',
+            logout: prefix + 'logout',
+        };
+    }
+    handle = async (contextArg) => {
+        const paths = this.paths;
+        const path = contextArg.url.pathname;
+        const method = contextArg.method.toUpperCase();
+        const providerLogin = this.#sessions.providerLoginEnabled;
+        if (path === paths.login && method === 'GET' && providerLogin) {
+            return this.login(contextArg);
+        }
+        if (path === paths.callback && method === 'GET' && providerLogin) {
+            return this.callback(contextArg);
+        }
+        if (path === paths.finalize && method === 'GET' && providerLogin) {
+            let location = this.#options.failureLocation;
+            try {
+                location = await this.#sessions.finalizeLogin(contextArg.headers.get('cookie'));
+            }
+            catch {
+                location = this.#options.failureLocation;
+            }
+            return redirect(location, { 'Set-Cookie': this.#sessions.clearIntentCookie() });
+        }
+        if (path === paths.session && method === 'GET') {
+            const resolved = await this.#sessions.resolveCookieSession(contextArg.headers.get('cookie'));
+            return jsonResponse(await this.sessionAnswer(resolved), 200);
+        }
+        if (path === paths.logout && method === 'POST') {
+            return this.logout(contextArg);
+        }
+        return null;
+    };
+    async login(contextArg) {
+        try {
+            const start = await this.#sessions.startLogin(contextArg.url.searchParams.get('return'));
+            return redirect(start.authorizationUrl.href, { 'Set-Cookie': start.intentCookie });
+        }
+        catch (error) {
+            this.emit({ event: 'auth_login_start_failed', message: error instanceof Error ? error.message : String(error) });
+            return jsonResponse({ error: 'authentication_unavailable' }, 503);
+        }
+    }
+    async callback(contextArg) {
+        // the callback is read from the public origin, never from a forwarded host
+        const callbackUrl = new URL(contextArg.url.pathname + contextArg.url.search, this.#sessions.publicOrigin);
+        const cookieHeader = contextArg.headers.get('cookie');
+        const providerError = callbackUrl.searchParams.get('error');
+        if (providerError) {
+            // the user cancelled, or the provider refused: nothing to exchange, and
+            // the attempt is consumed so its state never completes later
+            await this.#sessions.abandonLogin(callbackUrl, cookieHeader);
+            this.emit({ event: 'auth_callback_declined', code: providerError.slice(0, MAX_PROVIDER_ERROR_CODE_LENGTH) });
+            return redirect(this.#options.failureLocation, { 'Set-Cookie': this.#sessions.clearIntentCookie() });
+        }
+        try {
+            const opening = await this.#sessions.completeLogin(callbackUrl, cookieHeader);
+            return redirect(this.paths.finalize, { 'Set-Cookie': opening.sessionCookie });
+        }
+        catch (error) {
+            const clearIntent = { 'Set-Cookie': this.#sessions.clearIntentCookie() };
+            if (error instanceof RelyingPartyRefusal) {
+                this.emit({ event: 'auth_callback_refused', code: error.code });
+                const locations = this.#options.refusalLocations ?? {};
+                if (Object.hasOwn(locations, error.code)) {
+                    return redirect(locations[error.code], clearIntent);
+                }
+                return jsonResponse({ error: 'authentication_failed' }, error.status, clearIntent);
+            }
+            const status = error instanceof RelyingPartyError ? error.status : 502;
+            if (status >= 500) {
+                this.emit({
+                    event: 'auth_callback_failed',
+                    correlationId: plugins.crypto.randomUUID(),
+                    stage: error instanceof LoginCallbackError ? error.stage : 'unclassified',
+                    message: error instanceof Error ? error.message : String(error),
+                });
+            }
+            return jsonResponse({ error: 'authentication_failed' }, status, clearIntent);
+        }
+    }
+    async logout(contextArg) {
+        if (contextArg.headers.get('origin') !== this.#sessions.publicOrigin) {
+            return jsonResponse({ error: 'forbidden' }, 403);
+        }
+        const clearSession = { 'Set-Cookie': this.#sessions.clearSessionCookie() };
+        const resolved = await this.#sessions.resolveCookieSession(contextArg.headers.get('cookie'));
+        if (!resolved) {
+            return jsonResponse({ endedLiveSession: false }, 200, clearSession);
+        }
+        const body = await this.readJsonBody(contextArg);
+        const csrfToken = body && typeof body === 'object' ? Reflect.get(body, 'csrfToken') : undefined;
+        if (!this.#sessions.validateCsrf(resolved, csrfToken)) {
+            return jsonResponse({ error: 'forbidden' }, 403);
+        }
+        return jsonResponse({ endedLiveSession: await this.#sessions.logout(resolved.session.id) }, 200, clearSession);
+    }
+    async sessionAnswer(resolvedArg) {
+        if (this.#options.sessionAnswer) {
+            return this.#options.sessionAnswer(resolvedArg);
+        }
+        return {
+            session: resolvedArg
+                ? {
+                    sessionId: resolvedArg.session.id,
+                    principalId: resolvedArg.session.principalId,
+                    expiresAt: resolvedArg.session.expiresAt,
+                    csrfToken: resolvedArg.csrfToken,
+                }
+                : null,
+        };
+    }
+    /**
+     * A JSON body within `maxBodyBytes`, or `null`. The limit holds while the
+     * body streams, whatever `Content-Length` claims or omits: the read is
+     * cancelled at the first chunk that passes it.
+     */
+    async readJsonBody(contextArg) {
+        const declaredLength = Number(contextArg.headers.get('content-length') || 0);
+        if (!Number.isFinite(declaredLength) || declaredLength < 0 || declaredLength > this.#maxBodyBytes) {
+            return null;
+        }
+        const body = contextArg.request.body;
+        if (!body) {
+            return null;
+        }
+        const reader = body.getReader();
+        const chunks = [];
+        let received = 0;
+        try {
+            for (;;) {
+                const { done, value } = await reader.read();
+                if (done) {
+                    break;
+                }
+                received += value.byteLength;
+                if (received > this.#maxBodyBytes) {
+                    await reader.cancel();
+                    return null;
+                }
+                chunks.push(value);
+            }
+        }
+        catch {
+            return null;
+        }
+        finally {
+            reader.releaseLock();
+        }
+        try {
+            return JSON.parse(Buffer.concat(chunks, received).toString('utf8'));
+        }
+        catch {
+            return null;
+        }
+    }
+    emit(eventArg) {
+        if (!this.#options.onRouteEvent) {
+            console.error(JSON.stringify(eventArg));
+            return;
+        }
+        const reportFailure = (errorArg) => {
+            console.error(JSON.stringify({
+                event: 'hook_failed',
+                hook: 'onRouteEvent',
+                message: errorArg instanceof Error ? errorArg.message : String(errorArg),
+            }));
+            console.error(JSON.stringify(eventArg));
+        };
+        try {
+            const result = this.#options.onRouteEvent(eventArg);
+            if (result instanceof Promise) {
+                result.catch(reportFailure);
+            }
+        }
+        catch (error) {
+            reportFailure(error);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.relyingpartyroutes.js","sourceRoot":"","sources":["../../ts_relyingparty/classes.relyingpartyroutes.ts"],"names":[],"mappings":"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"}