oidc-spa 10.2.12 → 10.2.14

package/src/tanstack-start/react/createOidcSpaUtils.ts

@@ -16,7 +16,6 @@ import { assert, type Equals, is } from "../../tools/tsafe/assert";
 import { createObjectThatThrowsIfAccessed } from "../../tools/createObjectThatThrowsIfAccessed";
 import { createStatefulEvt } from "../../tools/StatefulEvt";
 import { id } from "../../tools/tsafe/id";
-import { typeGuard } from "../../tools/tsafe/typeGuard";
 import type { GetterOrDirectValue } from "../../tools/GetterOrDirectValue";
 import { createServerFn, createMiddleware } from "@tanstack/react-start";
 // @ts-expect-error: Since our module is not labeled as ESM we don't have the types here.
@@ -27,6 +26,7 @@ import { BEFORE_LOAD_FN_BRAND_PROPERTY_NAME } from "./disableSsrIfLoginEnforced"
 import { setDesiredPostLoginRedirectUrl } from "../../core/desiredPostLoginRedirectUrl";
 import type { MaybeAsync } from "../../tools/MaybeAsync";
 import { enableStateDataCookie } from "../../core/StateDataCookie";
+import { publicEnvNames } from "virtual:oidc-spa/tanstack-start-public-env";
 
 export function createOidcSpaUtils<
     AutoLogin extends boolean,
@@ -541,95 +541,57 @@ export function createOidcSpaUtils<
             assert(prModuleCore !== undefined);
 
             const paramsOfBootstrap = await (async () => {
-                let envNamesToPullFromServer = new Set<string>();
-
-                const env: Record<string, string> = {};
+                class OidcSpaServerEnvRetrievalError extends Error {
+                    constructor(params: { envName: string }) {
+                        super(`oidc-spa: Env value ${params.envName} couldn't be pulled from server`);
+                        Object.setPrototypeOf(this, new.target.prototype);
+                    }
+                }
 
-                const env_proxy = new Proxy(env, {
-                    get: (...[, envName]) => {
-                        assert(typeof envName === "string");
+                const env_server_proxy = new Proxy(
+                    publicEnvNames.size === 0 ? {} : await fetchServerEnvVariableValues(),
+                    {
+                        get: (target, envName) => {
+                            assert(typeof envName === "string");
 
-                        if (envName in env) {
-                            return env[envName];
-                        }
+                            if (!Object.prototype.hasOwnProperty.call(target, envName)) {
+                                throw new OidcSpaServerEnvRetrievalError({ envName });
+                            }
 
-                        envNamesToPullFromServer.add(envName);
+                            return target[envName];
+                        },
+                        has: (target, envName) => {
+                            assert(typeof envName === "string");
 
-                        return "oidc_spa_probe";
-                    },
-                    has: (...[, envName]) => {
-                        assert(typeof envName === "string");
+                            if (!Object.prototype.hasOwnProperty.call(target, envName)) {
+                                throw new OidcSpaServerEnvRetrievalError({ envName });
+                            }
 
-                        if (envName in env) {
                             return true;
                         }
-
-                        envNamesToPullFromServer.add(envName);
-
-                        return true;
                     }
-                });
+                ) as Record<string, string>;
 
-                let result:
-                    | {
-                          hasThrown: false;
-                          paramsOfBootstrap: ParamsOfBootstrap<
-                              AutoLogin,
-                              DecodedIdToken,
-                              AccessTokenClaims
-                          >;
-                      }
-                    | {
-                          hasThrown: true;
-                          error: unknown;
-                      }
-                    | undefined = undefined;
-
-                while (true) {
-                    envNamesToPullFromServer = new Set();
-
-                    result = undefined;
-
-                    try {
-                        const paramsOfBootstrap = getParamsOfBootstrap({ process: { env: env_proxy } });
-                        result = {
-                            hasThrown: false,
-                            paramsOfBootstrap
-                        };
-                    } catch (error) {
-                        result = {
-                            hasThrown: true,
-                            error
-                        };
-                    }
+                let paramsOfBootstrap: ParamsOfBootstrap<AutoLogin, DecodedIdToken, AccessTokenClaims>;
 
-                    if (envNamesToPullFromServer.size === 0) {
-                        break;
+                try {
+                    paramsOfBootstrap = getParamsOfBootstrap({ process: { env: env_server_proxy } });
+                } catch (error) {
+                    if (error instanceof OidcSpaServerEnvRetrievalError) {
+                        throw error;
                     }
 
-                    Object.entries(
-                        await fetchServerEnvVariableValues({
-                            data: {
-                                envVarNames: Array.from(envNamesToPullFromServer)
-                            }
-                        })
-                    ).forEach(([envName, value]) => {
-                        env[envName] = value;
-                    });
-                }
-
-                if (result.hasThrown) {
                     throw new Error(
                         [
                             "oidc-spa: The function argument passed to bootstrapOidc",
                             "has thrown when invoked."
                         ].join(" "),
                         //@ts-expect-error
-                        { cause: result.error }
+                        { cause: error }
                     );
                 }
 
-                return result.paramsOfBootstrap;
+                return paramsOfBootstrap;
             })();
 
             dParamsOfBootstrap.resolve(paramsOfBootstrap);
@@ -793,7 +755,7 @@ export function createOidcSpaUtils<
     enforceLogin[BEFORE_LOAD_FN_BRAND_PROPERTY_NAME] = true;
 
     const prValidateAndGetAccessTokenClaims =
-        createValidateAndGetAccessTokenClaims === undefined
+        createValidateAndGetAccessTokenClaims === undefined || isBrowser
             ? undefined
             : dParamsOfBootstrap.pr.then(paramsOfBootstrap =>
                   createValidateAndGetAccessTokenClaims({
@@ -1021,26 +983,8 @@ export function createOidcSpaUtils<
     };
 }
 
-const fetchServerEnvVariableValues = createServerFn({ method: "GET" })
-    .validator((data: { envVarNames: string[] }) => {
-        if (typeof data !== "object" || data === null) {
-            throw new Error("Expected an object");
-        }
-
-        const { envVarNames } = data as Record<string, unknown>;
-
-        assert(
-            typeGuard<string[]>(
-                envVarNames,
-                Array.isArray(envVarNames) && envVarNames.every(name => typeof name === "string")
-            )
-        );
-
-        return { envVarNames };
-    })
-    .handler(async ({ data }) => {
-        const { envVarNames } = data;
-        return Object.fromEntries(
-            envVarNames.map(envVarName => [envVarName, process.env[envVarName] ?? ""])
-        );
-    });
+const fetchServerEnvVariableValues = createServerFn({ method: "GET" }).handler(async () =>
+    Object.fromEntries(
+        Array.from(publicEnvNames).map(envVarName => [envVarName, process.env[envVarName] ?? ""])
+    )
+);

package/src/tanstack-start/react/publicEnv.d.ts

@@ -0,0 +1,3 @@
+declare module "virtual:oidc-spa/tanstack-start-public-env" {
+    export const publicEnvNames: ReadonlySet<string>;
+}

package/src/vendor/build-runtime/babel.ts

@@ -1,6 +1,15 @@
 export * as babelParser from "@babel/parser";
-import babelGenerate from "@babel/generator";
-export { babelGenerate };
+import babelGenerate_import from "@babel/generator";
+// Babel's CommonJS entrypoints expose their callable export under `default`.
+// Native ESM and bundlers do not unwrap these imports in the same way.
+export const babelGenerate: typeof babelGenerate_import =
+    typeof babelGenerate_import === "function"
+        ? babelGenerate_import
+        : (babelGenerate_import as { default: typeof babelGenerate_import }).default;
 export * as babelTypes from "@babel/types";
-import babelTraverse from "@babel/traverse";
-export { babelTraverse };
+import babelTraverse_import from "@babel/traverse";
+export const babelTraverse: typeof babelTraverse_import =
+    typeof babelTraverse_import === "function"
+        ? babelTraverse_import
+        : (babelTraverse_import as { default: typeof babelTraverse_import }).default;
+export type { NodePath } from "@babel/traverse";