oidc-spa 7.1.10 → 7.2.0-rc.2

package/src/core/persistedAuthState.ts

@@ -1,122 +0,0 @@
-import { typeGuard, id } from "../vendor/frontend/tsafe";
-
-function getKey(params: { configId: string }) {
-    const { configId } = params;
-
-    return `oidc-spa:auth-state:${configId}`;
-}
-
-type PersistedAuthState = PersistedAuthState.LoggedIn | PersistedAuthState.ExplicitlyLoggedOut;
-namespace PersistedAuthState {
-    type Common = {
-        __brand: "PersistedAuthState-v1";
-    };
-
-    export type LoggedIn = Common & {
-        stateDescription: "logged in";
-        untilTime: number | undefined;
-    };
-
-    export type ExplicitlyLoggedOut = Common & {
-        stateDescription: "explicitly logged out";
-    };
-}
-
-export function persistAuthState(params: {
-    configId: string;
-    state:
-        | {
-              stateDescription: "logged in";
-              idleSessionLifetimeInSeconds: number | undefined;
-              refreshTokenExpirationTime: number | undefined;
-          }
-        | {
-              stateDescription: "explicitly logged out";
-          }
-        | undefined;
-}) {
-    const { configId, state } = params;
-
-    const key = getKey({ configId });
-
-    if (state === undefined) {
-        localStorage.removeItem(key);
-        return;
-    }
-
-    localStorage.setItem(
-        key,
-        JSON.stringify(
-            id<PersistedAuthState>(
-                (() => {
-                    switch (state.stateDescription) {
-                        case "logged in":
-                            return id<PersistedAuthState.LoggedIn>({
-                                __brand: "PersistedAuthState-v1",
-                                stateDescription: "logged in",
-                                untilTime: (() => {
-                                    const { idleSessionLifetimeInSeconds, refreshTokenExpirationTime } =
-                                        state;
-
-                                    if (idleSessionLifetimeInSeconds !== undefined) {
-                                        return Date.now() + idleSessionLifetimeInSeconds * 1000;
-                                    }
-
-                                    return refreshTokenExpirationTime;
-                                })()
-                            });
-                        case "explicitly logged out":
-                            return id<PersistedAuthState.ExplicitlyLoggedOut>({
-                                __brand: "PersistedAuthState-v1",
-                                stateDescription: "explicitly logged out"
-                            });
-                    }
-                })()
-            )
-        )
-    );
-}
-
-export function getPersistedAuthState(params: {
-    configId: string;
-}): PersistedAuthState["stateDescription"] | undefined {
-    const { configId } = params;
-
-    const key = getKey({ configId });
-
-    const value = localStorage.getItem(key);
-
-    if (value === null) {
-        return undefined;
-    }
-
-    let state: unknown;
-
-    try {
-        state = JSON.parse(value);
-    } catch {
-        localStorage.removeItem(key);
-        return undefined;
-    }
-
-    if (
-        !typeGuard<PersistedAuthState>(
-            state,
-            state instanceof Object &&
-                "__brand" in state &&
-                state.__brand === id<PersistedAuthState["__brand"]>("PersistedAuthState-v1")
-        )
-    ) {
-        localStorage.removeItem(key);
-        return undefined;
-    }
-
-    if (state.stateDescription === "logged in") {
-        if (state.untilTime !== undefined && state.untilTime <= Date.now()) {
-            localStorage.removeItem(key);
-            return undefined;
-        }
-    }
-
-    return state.stateDescription;
-}

package/src/core/trustedFetch.ts

@@ -1,9 +0,0 @@
-const globalContext = {
-    trustedFetch: window.fetch
-};
-
-export const { trustedFetch } = globalContext;
-
-export function captureFetch() {
-    /** noop */
-}

package/src/index.ts

@@ -1,7 +0,0 @@
-export {
-    type Oidc,
-    OidcInitializationError,
-    type ParamsOfCreateOidc,
-    createOidc,
-    trustedFetch
-} from "./core";

package/src/mock/react.tsx

@@ -1,11 +0,0 @@
-import { createOidcReactApi_dependencyInjection } from "../react/react";
-import { createMockOidc, type ParamsOfCreateMockOidc } from "./oidc";
-import type { ValueOrAsyncGetter } from "../tools/ValueOrAsyncGetter";
-
-/** @see: https://docs.oidc-spa.dev/v/v7/mock */
-export function createMockReactOidc<
-    DecodedIdToken extends Record<string, unknown> = Record<string, unknown>,
-    AutoLogin extends boolean = false
->(params: ValueOrAsyncGetter<ParamsOfCreateMockOidc<DecodedIdToken, AutoLogin>>) {
-    return createOidcReactApi_dependencyInjection(params, createMockOidc);
-}

package/src/react/react.tsx

@@ -1,460 +0,0 @@
-import {
-    useEffect,
-    useState,
-    createContext,
-    useContext,
-    type ReactNode,
-    type ComponentType,
-    type FC,
-    type JSX
-} from "react";
-import { type Oidc, createOidc, type ParamsOfCreateOidc, OidcInitializationError } from "../core";
-import { assert, type Equals, type Param0 } from "../vendor/frontend/tsafe";
-import { id } from "../vendor/frontend/tsafe";
-import type { ValueOrAsyncGetter } from "../tools/ValueOrAsyncGetter";
-import { Deferred } from "../tools/Deferred";
-import { toFullyQualifiedUrl } from "../tools/toFullyQualifiedUrl";
-
-export type OidcReact<DecodedIdToken extends Record<string, unknown>> =
-    | OidcReact.NotLoggedIn
-    | OidcReact.LoggedIn<DecodedIdToken>;
-
-export namespace OidcReact {
-    export type Common = Oidc.Common & {
-        useAutoLogoutWarningCountdown: (params: { warningDurationSeconds: number }) => {
-            secondsLeft: number | undefined;
-        };
-    };
-
-    export type NotLoggedIn = Common & {
-        isUserLoggedIn: false;
-        login: (params?: {
-            extraQueryParams?: Record<string, string | undefined>;
-            redirectUrl?: string;
-            transformUrlBeforeRedirect?: (url: string) => string;
-            doesCurrentHrefRequiresAuth?: boolean;
-        }) => Promise<never>;
-        initializationError: OidcInitializationError | undefined;
-
-        decodedIdToken?: never;
-        logout?: never;
-        renewTokens?: never;
-        goToAuthServer?: never;
-        backFromAuthServer?: never;
-        isNewBrowserSession?: never;
-    };
-
-    export type LoggedIn<DecodedIdToken extends Record<string, unknown>> = Common & {
-        isUserLoggedIn: true;
-        decodedIdToken: DecodedIdToken;
-        logout: Oidc.LoggedIn["logout"];
-        renewTokens: Oidc.LoggedIn["renewTokens"];
-        login?: never;
-        initializationError?: never;
-        goToAuthServer: (params: {
-            extraQueryParams?: Record<string, string>;
-            redirectUrl?: string;
-            transformUrlBeforeRedirect?: (url: string) => string;
-        }) => Promise<never>;
-
-        backFromAuthServer:
-            | {
-                  extraQueryParams: Record<string, string>;
-                  result: Record<string, string>;
-              }
-            | undefined;
-
-        isNewBrowserSession: boolean;
-    };
-}
-{
-    type Actual = Param0<OidcReact.NotLoggedIn["login"]>;
-    type Expected = Omit<Param0<Oidc.NotLoggedIn["login"]>, "doesCurrentHrefRequiresAuth"> & {
-        doesCurrentHrefRequiresAuth?: boolean;
-    };
-
-    assert<Equals<Actual, Expected>>();
-}
-
-type OidcReactApi<DecodedIdToken extends Record<string, unknown>, AutoLogin extends boolean> = {
-    OidcProvider: AutoLogin extends true
-        ? (props: {
-              fallback?: ReactNode;
-              ErrorFallback?: (props: { initializationError: OidcInitializationError }) => ReactNode;
-              children: ReactNode;
-          }) => JSX.Element
-        : (props: { fallback?: ReactNode; children: ReactNode }) => JSX.Element;
-    useOidc: AutoLogin extends true
-        ? {
-              (params?: { assert: "user logged in" }): OidcReact.LoggedIn<DecodedIdToken>;
-          }
-        : {
-              (params?: { assert?: undefined }): OidcReact<DecodedIdToken>;
-              (params: { assert: "user logged in" }): OidcReact.LoggedIn<DecodedIdToken>;
-              (params: { assert: "user not logged in" }): OidcReact.NotLoggedIn;
-          };
-    getOidc: () => Promise<
-        AutoLogin extends true ? Oidc.LoggedIn<DecodedIdToken> : Oidc<DecodedIdToken>
-    >;
-} & (AutoLogin extends true
-    ? {}
-    : {
-          withLoginEnforced: <Props extends Record<string, unknown>>(
-              Component: ComponentType<Props>,
-              params?: {
-                  onRedirecting: () => JSX.Element | null;
-              }
-          ) => FC<Props>;
-          enforceLogin: (loaderParams: {
-              request?: { url?: string };
-              cause?: "preload" | string;
-              location?: {
-                  href?: string;
-              };
-          }) => Promise<void | never>;
-      });
-
-export function createOidcReactApi_dependencyInjection<
-    DecodedIdToken extends Record<string, unknown>,
-    ParamsOfCreateOidc extends {
-        autoLogin?: boolean;
-    } & (
-        | {
-              decodedIdTokenSchema: { parse: (data: unknown) => DecodedIdToken } | undefined;
-          }
-        | {}
-    )
->(
-    paramsOrGetParams: ValueOrAsyncGetter<ParamsOfCreateOidc>,
-    createOidc: (params: ParamsOfCreateOidc) => Promise<Oidc<DecodedIdToken>>
-): OidcReactApi<
-    DecodedIdToken,
-    ParamsOfCreateOidc extends { autoLogin?: true | undefined } ? true : false
-> {
-    const dReadyToCreate = new Deferred<void>();
-
-    const oidcContext = createContext<{ oidc: Oidc<DecodedIdToken>; fallback: ReactNode } | undefined>(
-        undefined
-    );
-
-    // NOTE: It can be InitializationError only if autoLogin is true
-    const prOidcOrInitializationError = (async () => {
-        const params = await (async () => {
-            if (typeof paramsOrGetParams === "function") {
-                const getParams = paramsOrGetParams;
-
-                await dReadyToCreate.pr;
-
-                const params = await getParams();
-
-                return params;
-            }
-
-            const params = paramsOrGetParams;
-
-            return params;
-        })();
-
-        let oidc: Oidc<DecodedIdToken>;
-
-        try {
-            oidc = await createOidc(params);
-        } catch (error) {
-            if (!(error instanceof OidcInitializationError)) {
-                throw error;
-            }
-
-            return error;
-        }
-
-        return oidc;
-    })();
-
-    let prOidcOrInitializationError_resolvedValue:
-        | Oidc<DecodedIdToken>
-        | OidcInitializationError
-        | undefined = undefined;
-    prOidcOrInitializationError.then(value => (prOidcOrInitializationError_resolvedValue = value));
-
-    function OidcProvider(props: {
-        fallback?: ReactNode;
-        ErrorFallback?: (props: { initializationError: OidcInitializationError }) => ReactNode;
-        children: ReactNode;
-    }) {
-        const { fallback, ErrorFallback, children } = props;
-
-        const [oidcOrInitializationError, setOidcOrInitializationError] = useState<
-            Oidc<DecodedIdToken> | OidcInitializationError | undefined
-        >(prOidcOrInitializationError_resolvedValue);
-
-        useEffect(() => {
-            if (oidcOrInitializationError !== undefined) {
-                return;
-            }
-
-            dReadyToCreate.resolve();
-            prOidcOrInitializationError.then(setOidcOrInitializationError);
-        }, []);
-
-        if (oidcOrInitializationError === undefined) {
-            return <>{fallback === undefined ? null : fallback}</>;
-        }
-
-        if (oidcOrInitializationError instanceof OidcInitializationError) {
-            const initializationError = oidcOrInitializationError;
-
-            return (
-                <>
-                    {ErrorFallback === undefined ? (
-                        <h1 style={{ color: "red" }}>
-                            An error occurred while initializing the OIDC client:&nbsp;
-                            {initializationError.message}
-                        </h1>
-                    ) : (
-                        <ErrorFallback initializationError={initializationError} />
-                    )}
-                </>
-            );
-        }
-
-        const oidc = oidcOrInitializationError;
-
-        return (
-            <oidcContext.Provider value={{ oidc, fallback: fallback ?? null }}>
-                {children}
-            </oidcContext.Provider>
-        );
-    }
-
-    const useAutoLogoutWarningCountdown: OidcReact.LoggedIn<DecodedIdToken>["useAutoLogoutWarningCountdown"] =
-        ({ warningDurationSeconds }) => {
-            const contextValue = useContext(oidcContext);
-
-            assert(contextValue !== undefined);
-
-            const { oidc } = contextValue;
-
-            const [secondsLeft, setSecondsLeft] = useState<number | undefined>(undefined);
-
-            useEffect(() => {
-                if (!oidc.isUserLoggedIn) {
-                    return;
-                }
-
-                const { unsubscribeFromAutoLogoutCountdown } = oidc.subscribeToAutoLogoutCountdown(
-                    ({ secondsLeft }) =>
-                        setSecondsLeft(
-                            secondsLeft === undefined || secondsLeft > warningDurationSeconds
-                                ? undefined
-                                : secondsLeft
-                        )
-                );
-
-                return () => {
-                    unsubscribeFromAutoLogoutCountdown();
-                };
-            }, [warningDurationSeconds]);
-
-            return { secondsLeft };
-        };
-
-    function useOidc(params?: {
-        assert?: "user logged in" | "user not logged in";
-    }): OidcReact<DecodedIdToken> {
-        const { assert: assert_params } = params ?? {};
-
-        const contextValue = useContext(oidcContext);
-
-        assert(contextValue !== undefined, "You must use useOidc inside the corresponding OidcProvider");
-
-        const { oidc } = contextValue;
-
-        check_assertion: {
-            if (assert_params === undefined) {
-                break check_assertion;
-            }
-
-            const getMessage = (v: string) =>
-                [
-                    "There is a logic error in the application.",
-                    `If this component is mounted the user is supposed ${v}.`,
-                    "An explicit assertion was made in this sense."
-                ].join(" ");
-
-            switch (assert_params) {
-                case "user logged in":
-                    if (!oidc.isUserLoggedIn) {
-                        throw new Error(getMessage("to be logged in but currently they arn't"));
-                    }
-                    break;
-                case "user not logged in":
-                    if (oidc.isUserLoggedIn) {
-                        throw new Error(getMessage("not to be logged in but currently they are"));
-                    }
-                    break;
-                default:
-                    assert<Equals<typeof assert_params, never>>(false);
-            }
-        }
-
-        const [, reRenderIfDecodedIdTokenChanged] = useState(
-            !oidc.isUserLoggedIn ? undefined : oidc.getDecodedIdToken()
-        );
-
-        useEffect(() => {
-            if (!oidc.isUserLoggedIn) {
-                return;
-            }
-
-            const { unsubscribe } = oidc.subscribeToTokensChange(() =>
-                reRenderIfDecodedIdTokenChanged(oidc.getDecodedIdToken())
-            );
-
-            reRenderIfDecodedIdTokenChanged(oidc.getDecodedIdToken());
-
-            return unsubscribe;
-        }, []);
-
-        const common: OidcReact.Common = {
-            params: oidc.params,
-            useAutoLogoutWarningCountdown
-        };
-
-        if (!oidc.isUserLoggedIn) {
-            return id<OidcReact.NotLoggedIn>({
-                ...common,
-                isUserLoggedIn: false,
-                login: ({ doesCurrentHrefRequiresAuth = false, ...rest } = {}) =>
-                    oidc.login({ doesCurrentHrefRequiresAuth, ...rest }),
-                initializationError: oidc.initializationError
-            });
-        }
-
-        const oidcReact: OidcReact.LoggedIn<DecodedIdToken> = {
-            ...common,
-            isUserLoggedIn: true,
-            decodedIdToken: oidc.getDecodedIdToken(),
-            logout: oidc.logout,
-            renewTokens: oidc.renewTokens,
-            goToAuthServer: oidc.goToAuthServer,
-            isNewBrowserSession: oidc.isNewBrowserSession,
-            backFromAuthServer: oidc.backFromAuthServer
-        };
-
-        return oidcReact;
-    }
-
-    function withLoginEnforced<Props extends Record<string, unknown>>(
-        Component: ComponentType<Props>,
-        params?: {
-            onRedirecting?: () => JSX.Element | null;
-        }
-    ): FC<Props> {
-        const { onRedirecting } = params ?? {};
-
-        function ComponentWithLoginEnforced(props: Props) {
-            const contextValue = useContext(oidcContext);
-
-            assert(contextValue !== undefined, "094283");
-
-            const { oidc, fallback } = contextValue;
-
-            useEffect(() => {
-                if (oidc.isUserLoggedIn) {
-                    return;
-                }
-
-                oidc.login({ doesCurrentHrefRequiresAuth: true });
-            }, []);
-
-            if (!oidc.isUserLoggedIn) {
-                return onRedirecting === undefined ? fallback : onRedirecting();
-            }
-
-            return <Component {...props} />;
-        }
-
-        ComponentWithLoginEnforced.displayName = `${
-            Component.displayName ?? Component.name ?? "Component"
-        }WithLoginEnforced`;
-
-        return ComponentWithLoginEnforced;
-    }
-
-    async function enforceLogin(loaderParams: {
-        request?: { url?: string };
-        cause?: "preload" | string;
-        location?: { href?: string };
-    }): Promise<void | never> {
-        const { cause } = loaderParams;
-
-        const redirectUrl = (() => {
-            if (loaderParams.request?.url !== undefined) {
-                return toFullyQualifiedUrl({
-                    urlish: loaderParams.request.url,
-                    doAssertNoQueryParams: false
-                });
-            }
-
-            if (loaderParams.location?.href !== undefined) {
-                return toFullyQualifiedUrl({
-                    urlish: loaderParams.location.href,
-                    doAssertNoQueryParams: false
-                });
-            }
-
-            return location.href;
-        })();
-
-        const oidc = await getOidc();
-
-        if (!oidc.isUserLoggedIn) {
-            if (cause === "preload") {
-                throw new Error(
-                    "oidc-spa: User is not yet logged in. This is an expected error, nothing to be addressed."
-                );
-            }
-            const doesCurrentHrefRequiresAuth =
-                location.href.replace(/\/$/, "") === redirectUrl.replace(/\/$/, "");
-
-            await oidc.login({
-                redirectUrl,
-                doesCurrentHrefRequiresAuth
-            });
-        }
-    }
-
-    async function getOidc(): Promise<Oidc<DecodedIdToken>> {
-        dReadyToCreate.resolve();
-
-        const oidcOrInitializationError = await prOidcOrInitializationError;
-
-        if (oidcOrInitializationError instanceof OidcInitializationError) {
-            const error = oidcOrInitializationError;
-            throw error;
-        }
-
-        const oidc = oidcOrInitializationError;
-
-        return oidc;
-    }
-
-    const oidcReact: OidcReactApi<DecodedIdToken, false> = {
-        OidcProvider,
-        useOidc: useOidc as any,
-        getOidc,
-        withLoginEnforced,
-        enforceLogin
-    };
-
-    // @ts-expect-error: We know what we are doing
-    return oidcReact;
-}
-
-/** @see: https://docs.oidc-spa.dev/v/v7/usage#react-api */
-export function createReactOidc<
-    DecodedIdToken extends Record<string, unknown> = Oidc.Tokens.DecodedIdToken_base,
-    AutoLogin extends boolean = false
->(params: ValueOrAsyncGetter<ParamsOfCreateOidc<DecodedIdToken, AutoLogin>>) {
-    return createOidcReactApi_dependencyInjection(params, createOidc);
-}

package/src/tools/Deferred.ts

@@ -1,39 +0,0 @@
-import { overwriteReadonlyProp } from "../vendor/frontend/tsafe";
-
-export class Deferred<T> {
-    public readonly pr: Promise<T>;
-
-    /** NOTE: Does not need to be called bound to instance*/
-    public readonly resolve: (value: T) => void;
-    public readonly reject: (error: any) => void;
-
-    constructor() {
-        let resolve!: (value: T) => void;
-        let reject!: (error: any) => void;
-
-        this.pr = new Promise<T>((resolve_, reject_) => {
-            resolve = value => {
-                overwriteReadonlyProp(this, "isPending", false);
-                resolve_(value);
-            };
-
-            reject = error => {
-                overwriteReadonlyProp(this, "isPending", false);
-                reject_(error);
-            };
-        });
-
-        this.resolve = resolve;
-        this.reject = reject;
-    }
-
-    public readonly isPending: boolean = true;
-}
-
-export namespace Deferred {
-    export type Unpack<T extends Deferred<any>> = T extends Deferred<infer U> ? U : never;
-}
-
-export class VoidDeferred extends Deferred<undefined> {
-    public declare readonly resolve: () => void;
-}

package/src/tools/StatefulEvt.ts

@@ -1,38 +0,0 @@
-export type StatefulEvt<T> = {
-    current: T;
-    subscribe: (next: (data: T) => void) => Subscription;
-};
-
-export type StatefulReadonlyEvt<T> = {
-    readonly current: T;
-    subscribe: (next: (data: T) => void) => Subscription;
-};
-
-export type Subscription = {
-    unsubscribe: () => void;
-};
-
-export function createStatefulEvt<T>(getInitialValue: () => T): StatefulEvt<T> {
-    let nextFunctions: ((data: T) => void)[] = [];
-
-    let wrappedState: [T] | undefined = undefined;
-
-    return {
-        get current() {
-            if (wrappedState === undefined) {
-                wrappedState = [getInitialValue()];
-            }
-            return wrappedState[0];
-        },
-        set current(data: T) {
-            wrappedState = [data];
-
-            nextFunctions.forEach(next => next(data));
-        },
-        subscribe: (next: (data: T) => void) => {
-            nextFunctions.push(next);
-
-            return { unsubscribe: () => nextFunctions.splice(nextFunctions.indexOf(next), 1) };
-        }
-    };
-}