@rttnd/gau 1.4.1 → 1.4.2

package/dist/src/client/solid/index.jsx

@@ -492,6 +492,100 @@ function createAuthClient({ baseUrl, scheme = "gau" }) {
   };
 }
 
+// src/client/solid/solidStartFetchBridge.ts
+init_token();
+import { BROWSER as BROWSER3 } from "esm-env";
+function installSolidStartFetchBridge(options = {}) {
+  if (!BROWSER3 || typeof window === "undefined")
+    return;
+  if (window.__GAU_SOLIDSTART_FETCH_BRIDGE_INSTALLED__)
+    return;
+  window.__GAU_SOLIDSTART_FETCH_BRIDGE_INSTALLED__ = true;
+  const originalFetch = globalThis.fetch.bind(globalThis);
+  const serverFunctionTarget = resolveServerFunctionTarget(options.serverBaseUrl);
+  const wrappedFetch = async (input, init = {}) => {
+    const requestUrl = resolveRequestUrl(input);
+    if (!requestUrl || !isSolidStartServerFunctionRequest(requestUrl, serverFunctionTarget))
+      return originalFetch(input, init);
+    const headers = mergeHeaders(input, init);
+    if (!headers.has("Authorization")) {
+      const token = getSessionToken();
+      if (token)
+        headers.set("Authorization", `Bearer ${token}`);
+    }
+    const response = await originalFetch(input, {
+      ...init,
+      headers
+    });
+    handleRefreshedToken(response);
+    return response;
+  };
+  const wrappedFetchWithBunCompat = wrappedFetch;
+  wrappedFetchWithBunCompat.preconnect = originalFetch.preconnect?.bind(originalFetch);
+  globalThis.fetch = wrappedFetchWithBunCompat;
+  window.fetch = wrappedFetchWithBunCompat;
+}
+function resolveServerFunctionTarget(serverBaseUrl) {
+  const envBase = serverBaseUrl ?? (import.meta?.env?.SERVER_BASE_URL ?? "");
+  const trimmed = envBase.trim();
+  if (!trimmed || trimmed === "/") {
+    return {
+      origin: window.location.origin,
+      path: "/_server"
+    };
+  }
+  try {
+    const baseUrl = new URL(trimmed, window.location.origin);
+    const basePath = normalizePath(baseUrl.pathname);
+    const serverPath = basePath === "/" ? "/_server" : `${basePath}/_server`;
+    return {
+      origin: baseUrl.origin,
+      path: normalizePath(serverPath)
+    };
+  } catch {
+    return {
+      origin: window.location.origin,
+      path: "/_server"
+    };
+  }
+}
+function resolveRequestUrl(input) {
+  try {
+    if (input instanceof URL)
+      return input;
+    if (typeof input === "string")
+      return new URL(input, window.location.href);
+    return new URL(input.url, window.location.href);
+  } catch {
+    return null;
+  }
+}
+function mergeHeaders(input, init) {
+  const headers = new Headers();
+  if (input instanceof Request) {
+    input.headers.forEach((value, key) => {
+      headers.set(key, value);
+    });
+  }
+  if (init.headers) {
+    new Headers(init.headers).forEach((value, key) => {
+      headers.set(key, value);
+    });
+  }
+  return headers;
+}
+function isSolidStartServerFunctionRequest(requestUrl, target) {
+  if (requestUrl.origin !== target.origin)
+    return false;
+  return normalizePath(requestUrl.pathname) === target.path;
+}
+function normalizePath(pathname) {
+  if (!pathname)
+    return "/";
+  const normalized = pathname.replace(/\/{2,}/g, "/").replace(/\/+$/, "");
+  return normalized || "/";
+}
+
 // src/client/solid/Protected.tsx
 import { useNavigate } from "@solidjs/router";
 import { onMount, Show } from "solid-js";
@@ -526,6 +620,8 @@ var AuthContext = createContext();
 function AuthProvider(props) {
   const scheme = untrack(() => props.scheme ?? "gau");
   const baseUrl = untrack(() => props.baseUrl ?? "/api/auth");
+  if (!isServer2 && isTauri())
+    installSolidStartFetchBridge();
   const client = createAuthClient({
     baseUrl
   });
@@ -618,19 +714,22 @@ function AuthProvider(props) {
       return;
     }
     let disposed = false;
+    let unlisten;
     void (async () => {
       const { startAuthBridge: startAuthBridge2 } = await Promise.resolve().then(() => (init_tauri(), tauri_exports));
-      const unlisten = await startAuthBridge2(baseUrl, scheme, async (token) => {
+      const maybeUnlisten = await startAuthBridge2(baseUrl, scheme, async (token) => {
         await client.applySessionToken(token);
         await doRefetch();
       });
       if (disposed)
-        unlisten?.();
-      else if (unlisten)
-        onCleanup(() => unlisten());
+        maybeUnlisten?.();
+      else
+        unlisten = maybeUnlisten ?? void 0;
     })();
     onCleanup(() => {
       disposed = true;
+      unlisten?.();
+      unlisten = void 0;
     });
   });
   return <AuthContext.Provider value={{ session, isLoading, signIn, linkAccount, unlinkAccount, signOut, refresh: refetch, fetch: client.fetch }}>

package/dist/src/client/solid/solidStartFetchBridge.d.ts

@@ -0,0 +1,13 @@
+declare global {
+    interface Window {
+        __GAU_SOLIDSTART_FETCH_BRIDGE_INSTALLED__?: boolean;
+    }
+}
+/**
+ * In SolidStart, query/action server functions call `/_server` through global fetch.
+ * In Tauri token mode this bridge injects Authorization and captures refreshed tokens.
+ */
+export declare function installSolidStartFetchBridge(options?: {
+    serverBaseUrl?: string;
+}): void;
+//# sourceMappingURL=solidStartFetchBridge.d.ts.map

package/dist/src/client/solid/solidStartFetchBridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solidStartFetchBridge.d.ts","sourceRoot":"","sources":["../../../../src/client/solid/solidStartFetchBridge.ts"],"names":[],"mappings":"AAGA,OAAO,CAAC,MAAM,CAAC,CAAC;IACd,UAAU,MAAM;QACd,yCAAyC,CAAC,EAAE,OAAO,CAAA;KACpD;CACF;AAED;;;GAGG;AACH,wBAAgB,4BAA4B,CAAC,OAAO,GAAE;IAAE,aAAa,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,IAAI,CAqC3F"}