@rixl/sdk 0.8.2 → 0.8.3

package/dist/index.js

@@ -625,6 +625,117 @@ const createClient = (config = {}) => {
 //#region src/generated/client.gen.ts
 const client = createClient(createConfig({ baseUrl: "https://raw.githubusercontent.com" }));
 
+//#endregion
+//#region src/shared-runtime.ts
+/**
+* Cross-instance runtime state for the SDK.
+*
+* Every store and client in this package is module-level singleton state that
+* `connect()` mutates. That only works while exactly one copy of `@rixl/sdk`
+* is evaluated. Bundlers routinely break that assumption: Vite's dependency
+* pre-bundling, for example, inlines a private copy of the SDK into any
+* optimized dependency that imports it, so a consumer's `connect()` configures
+* one copy while a library's requests read another — with a wrong baseUrl and,
+* worse, no auth tokens.
+*
+* Anchoring the state to a `Symbol.for` key on `globalThis` makes every copy
+* resolve the same objects, so duplication becomes harmless instead of a
+* silent, hard-to-trace failure.
+*/
+const REGISTRY_KEY = Symbol.for("@rixl/sdk.runtime");
+/** Bumped only if the shape below changes incompatibly. */
+const STATE_VERSION = 1;
+function registry() {
+	const host = globalThis;
+	const existing = host[REGISTRY_KEY];
+	if (existing && existing.version === STATE_VERSION) return existing;
+	const created = {
+		version: STATE_VERSION,
+		copies: 0,
+		values: /* @__PURE__ */ new Map()
+	};
+	host[REGISTRY_KEY] = created;
+	return created;
+}
+/**
+* Returns the one shared value for `name`, creating it on first use.
+*
+* `create` runs at most once per realm no matter how many copies of the SDK are
+* loaded, so callers get object identity (a nanostore atom, a Set) rather than
+* a per-copy clone.
+*/
+function shared(name, create) {
+	const { values } = registry();
+	if (!values.has(name)) values.set(name, create());
+	return values.get(name);
+}
+const copies = registry().copies += 1;
+if (copies > 1) console.warn(`[@rixl/sdk] ${copies} copies of this package were loaded in one page. Shared state is deduplicated, so this is not fatal, but it doubles bundle size and usually means a bundler inlined a private copy — with Vite, add "@rixl/sdk" to optimizeDeps.include and resolve.dedupe. Ensure libraries depending on @rixl/sdk declare it as a peerDependency.`);
+
+//#endregion
+//#region src/client-registry.ts
+/**
+* The baseUrl the code generator bakes in. It is derived from the origin of the
+* OpenAPI input URL, not from a real server, so a client still holding it has
+* simply never been configured. Captured from the client itself rather than
+* hardcoded so it stays correct if the generator input ever moves.
+*/
+const placeholderBaseUrl = shared("placeholderBaseUrl", () => client.getConfig().baseUrl);
+const clients = shared("clients", () => /* @__PURE__ */ new Set());
+/** Setup applied to every client copy, including ones registered later. */
+const initializers = shared("clientInitializers", () => []);
+/** Last baseUrl passed to {@link configureAllClients}, replayed onto late joiners. */
+const appliedConfig = shared("appliedConfig", () => ({ baseUrl: void 0 }));
+function isUnconfigured(target) {
+	const { baseUrl } = target.getConfig();
+	return !baseUrl || baseUrl === placeholderBaseUrl;
+}
+/**
+* Fails a request that would otherwise be sent to the generator's placeholder
+* host. Without this the request goes out looking legitimate and comes back a
+* 404 from an unrelated origin, which reads like a backend fault instead of
+* "the SDK was never initialised".
+*/
+function installUnconfiguredGuard(target) {
+	target.interceptors.request.use((request) => {
+		if (isUnconfigured(target)) throw new Error(`[@rixl/sdk] Cannot send ${request.method} ${new URL(request.url).pathname}: no baseUrl is configured. Call connect({baseUrl}) before issuing requests.`);
+		return request;
+	});
+}
+/**
+* Registers setup to run against every client copy — those already known and
+* any that register afterwards. Interceptors added through here therefore reach
+* a copy that loads from a lazy chunk after `connect()` has already run.
+*/
+function addClientInitializer(initialize) {
+	initializers.push(initialize);
+	for (const target of clients) initialize(target);
+}
+/**
+* Adds a client to the shared registry so configuration reaches it. Registering
+* is idempotent, and a client that joins late is brought fully up to date.
+*/
+function registerClient(target) {
+	if (clients.has(target)) return;
+	clients.add(target);
+	installUnconfiguredGuard(target);
+	for (const initialize of initializers) initialize(target);
+	if (appliedConfig.baseUrl !== void 0) target.setConfig({ baseUrl: appliedConfig.baseUrl });
+}
+/**
+* Points every known client copy at `baseUrl`.
+*
+* Duplicate copies of this package each construct their own client object, and
+* the generated request functions close over whichever one their copy owns.
+* Configuring only the caller's copy is what leaves a bundled library issuing
+* requests to the placeholder host.
+*/
+function configureAllClients(baseUrl) {
+	appliedConfig.baseUrl = baseUrl;
+	for (const target of clients) target.setConfig({ baseUrl });
+}
+registerClient(client);
+
 //#endregion
 //#region src/generated/sdk.gen.ts
 /**
@@ -2472,11 +2583,14 @@ const parseUser = () => {
 		return;
 	}
 };
-const user = atom(parseUser());
-user.subscribe((value) => {
-	if (typeof localStorage === "undefined" || !localStorage || typeof localStorage.setItem !== "function") return;
-	if (value) localStorage.setItem(userPath, JSON.stringify(value));
-	else localStorage.removeItem(userPath);
+const user = shared("user", () => {
+	const store = atom(parseUser());
+	store.subscribe((value) => {
+		if (typeof localStorage === "undefined" || !localStorage || typeof localStorage.setItem !== "function") return;
+		if (value) localStorage.setItem(userPath, JSON.stringify(value));
+		else localStorage.removeItem(userPath);
+	});
+	return store;
 });
 
 //#endregion
@@ -2530,13 +2644,13 @@ const isTokenExpired = (expireAt) => {
 
 //#endregion
 //#region src/auth/authStore.ts
-const isLogged = atom(initVals["isLogged"] === "true" || detectProvider() !== void 0);
-const accessToken = atom(initVals["accessToken"]);
-const refreshToken = atom(initVals["refreshToken"]);
-const expireAt = atom(Number(initVals["expireAt"]));
-const authError = atom(null);
-const requiresAction = atom(initVals["requiresAction"] || null);
-const limitedAccessToken = atom(initVals["limitedAccessToken"] || null);
+const isLogged = shared("isLogged", () => atom(initVals["isLogged"] === "true" || detectProvider() !== void 0));
+const accessToken = shared("accessToken", () => atom(initVals["accessToken"]));
+const refreshToken = shared("refreshToken", () => atom(initVals["refreshToken"]));
+const expireAt = shared("expireAt", () => atom(Number(initVals["expireAt"])));
+const authError = shared("authError", () => atom(null));
+const requiresAction = shared("requiresAction", () => atom(initVals["requiresAction"] || null));
+const limitedAccessToken = shared("limitedAccessToken", () => atom(initVals["limitedAccessToken"] || null));
 let currentTokenPromise = null;
 const PROVIDER_URL_MAP = {
 	google: googleAuthUrl,
@@ -2678,17 +2792,19 @@ var ApiError = class extends Error {
 /**
 * Global API base URL store
 */
-const apiURL = atom("");
+const apiURL = shared("apiURL", () => atom(""));
 
 //#endregion
 //#region src/auth/api/sdk-client.ts
 function isWireErrorBody(error) {
 	return typeof error === "object" && error !== null;
 }
-let configured = false;
-let tokenResolver = getToken;
+const state = shared("sdkClientState", () => ({
+	configured: false,
+	tokenResolver: getToken
+}));
 function setTokenResolver(resolver) {
-	tokenResolver = resolver;
+	state.tokenResolver = resolver;
 }
 /**
 * Routes that do not require a Bearer token at the gateway edge. These
@@ -2800,26 +2916,28 @@ function isPublicRoute(method, pathname) {
 	return publicRoutes.some(({ method: m, path, prefix }) => match === m && (prefix ? pathname.startsWith(path) : pathname === path));
 }
 function configureSdkClient() {
-	if (configured) return;
-	configured = true;
-	client.setConfig({ baseUrl: apiURL.get() });
+	if (state.configured) return;
+	state.configured = true;
+	configureAllClients(apiURL.get());
 	apiURL.subscribe((url) => {
-		client.setConfig({ baseUrl: url });
+		configureAllClients(url);
 	});
-	client.interceptors.request.use(async (request) => {
-		if (request.headers.has("Authorization")) return request;
-		const { pathname } = new URL(request.url);
-		if (isPublicRoute(request.method, pathname)) return request;
-		const token = await tokenResolver();
-		if (!token) throw new ApiError("No access token available for an authenticated request", HTTP_STATUS.UNAUTHORIZED, pathname);
-		request.headers.set("Authorization", `Bearer ${token}`);
-		return request;
-	});
-	client.interceptors.error.use((error, response, request) => {
-		if (error instanceof Error) return error;
-		const body = isWireErrorBody(error) ? error : void 0;
-		const status = response?.status ?? body?.code ?? 0;
-		return new ApiError(body?.error || body?.details || (typeof error === "string" ? error : "Request failed"), status, request ? new URL(request.url).pathname : "", error);
+	addClientInitializer((client) => {
+		client.interceptors.request.use(async (request) => {
+			if (request.headers.has("Authorization")) return request;
+			const { pathname } = new URL(request.url);
+			if (isPublicRoute(request.method, pathname)) return request;
+			const token = await state.tokenResolver();
+			if (!token) throw new ApiError("No access token available for an authenticated request", HTTP_STATUS.UNAUTHORIZED, pathname);
+			request.headers.set("Authorization", `Bearer ${token}`);
+			return request;
+		});
+		client.interceptors.error.use((error, response, request) => {
+			if (error instanceof Error) return error;
+			const body = isWireErrorBody(error) ? error : void 0;
+			const status = response?.status ?? body?.code ?? 0;
+			return new ApiError(body?.error || body?.details || (typeof error === "string" ? error : "Request failed"), status, request ? new URL(request.url).pathname : "", error);
+		});
 	});
 }
 
@@ -3180,9 +3298,9 @@ const initSocials = async () => {
 
 //#endregion
 //#region src/platform/platformAuthStore.ts
-const platformAccessToken = atom(void 0);
-const platformRefreshToken = atom(void 0);
-const platformExpireAt = atom(0);
+const platformAccessToken = shared("platformAccessToken", () => atom(void 0));
+const platformRefreshToken = shared("platformRefreshToken", () => atom(void 0));
+const platformExpireAt = shared("platformExpireAt", () => atom(0));
 let currentPlatformTokenPromise = null;
 const setPlatformTokens = (access, refresh, expiresIn) => {
 	platformAccessToken.set(access);
@@ -3239,7 +3357,7 @@ const getPlatformToken = async () => {
 //#region src/connect.ts
 const connect = async (config) => {
 	apiURL.set(config.baseUrl);
-	client.setConfig({ baseUrl: config.baseUrl });
+	configureAllClients(config.baseUrl);
 	if (config.apiKey) {
 		await exchangeApiKey(config.apiKey);
 		setTokenResolver(getPlatformToken);