@frak-labs/core-sdk 0.2.1 → 1.0.0

package/src/utils/sdkConfigStore.test.ts

@@ -0,0 +1,405 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { sdkConfigStore } from "./sdkConfigStore";
+
+vi.mock("./backendUrl", () => ({
+    getBackendUrl: vi.fn((walletUrl?: string) => {
+        if (walletUrl?.includes("localhost")) {
+            return "http://localhost:3030";
+        }
+        return "https://backend.frak.id";
+    }),
+}));
+
+describe("sdkConfigStore", () => {
+    beforeEach(() => {
+        sdkConfigStore.clearCache();
+        window.sessionStorage.clear();
+        window.localStorage.clear();
+        window.__frakSdkConfig = undefined;
+        vi.clearAllMocks();
+        vi.spyOn(console, "warn").mockImplementation(() => {});
+    });
+
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+
+    describe("sdkConfigStore.resolve", () => {
+        it("should fetch from backend when not cached", async () => {
+            const mockResponse = {
+                merchantId: "merchant-123",
+                name: "Test",
+                domain: "shop.example.com",
+                allowedDomains: [],
+            };
+
+            global.fetch = vi.fn().mockResolvedValueOnce({
+                ok: true,
+                json: async () => mockResponse,
+            });
+
+            const result = await sdkConfigStore.resolve("shop.example.com");
+
+            expect(result).toEqual(mockResponse);
+            expect(global.fetch).toHaveBeenCalledWith(
+                "https://backend.frak.id/user/merchant/resolve?domain=shop.example.com"
+            );
+        });
+
+        it("should return cached response on subsequent calls", async () => {
+            const mockResponse = {
+                merchantId: "merchant-456",
+                name: "Test",
+                domain: "shop.example.com",
+                allowedDomains: [],
+            };
+
+            global.fetch = vi.fn().mockResolvedValueOnce({
+                ok: true,
+                json: async () => mockResponse,
+            });
+
+            const result1 = await sdkConfigStore.resolve("shop.example.com");
+            expect(result1).toEqual(mockResponse);
+
+            const result2 = await sdkConfigStore.resolve("shop.example.com");
+            expect(result2).toEqual(mockResponse);
+
+            expect(global.fetch).toHaveBeenCalledTimes(1);
+        });
+
+        it("should deduplicate concurrent requests", async () => {
+            const mockResponse = {
+                merchantId: "merchant-789",
+                name: "Test",
+                domain: "shop.example.com",
+                allowedDomains: [],
+            };
+
+            global.fetch = vi.fn().mockResolvedValueOnce({
+                ok: true,
+                json: async () => mockResponse,
+            });
+
+            const [result1, result2, result3] = await Promise.all([
+                sdkConfigStore.resolve("shop.example.com"),
+                sdkConfigStore.resolve("shop.example.com"),
+                sdkConfigStore.resolve("shop.example.com"),
+            ]);
+
+            expect(result1).toEqual(mockResponse);
+            expect(result2).toEqual(mockResponse);
+            expect(result3).toEqual(mockResponse);
+            expect(global.fetch).toHaveBeenCalledTimes(1);
+        });
+
+        it("should use window.location.hostname when domain not provided", async () => {
+            const mockResponse = {
+                merchantId: "merchant-default",
+                name: "Test",
+                domain: "example.com",
+                allowedDomains: [],
+            };
+
+            global.fetch = vi.fn().mockResolvedValueOnce({
+                ok: true,
+                json: async () => mockResponse,
+            });
+
+            Object.defineProperty(window, "location", {
+                value: { hostname: "example.com" },
+                writable: true,
+            });
+
+            const result = await sdkConfigStore.resolve();
+
+            expect(result).toEqual(mockResponse);
+            expect(global.fetch).toHaveBeenCalledWith(
+                "https://backend.frak.id/user/merchant/resolve?domain=example.com"
+            );
+        });
+
+        it("should return undefined when domain is empty", async () => {
+            global.fetch = vi.fn();
+
+            const result = await sdkConfigStore.resolve("");
+
+            expect(result).toBeUndefined();
+            expect(global.fetch).not.toHaveBeenCalled();
+        });
+
+        it("should handle fetch errors gracefully", async () => {
+            global.fetch = vi
+                .fn()
+                .mockRejectedValueOnce(new Error("Network error"));
+
+            const result = await sdkConfigStore.resolve("shop.example.com");
+
+            expect(result).toBeUndefined();
+            expect(console.warn).toHaveBeenCalledWith(
+                "[Frak SDK] Failed to fetch merchant config:",
+                expect.any(Error)
+            );
+        });
+
+        it("should handle non-ok response (404, 500)", async () => {
+            global.fetch = vi.fn().mockResolvedValueOnce({
+                ok: false,
+                status: 404,
+            });
+
+            const result = await sdkConfigStore.resolve("nonexistent.com");
+
+            expect(result).toBeUndefined();
+            expect(console.warn).toHaveBeenCalledWith(
+                "[Frak SDK] Merchant lookup failed for domain nonexistent.com: 404"
+            );
+        });
+
+        it("should use custom walletUrl to derive backend URL", async () => {
+            const mockResponse = {
+                merchantId: "merchant-local",
+                name: "Test",
+                domain: "shop.example.com",
+                allowedDomains: [],
+            };
+
+            global.fetch = vi.fn().mockResolvedValueOnce({
+                ok: true,
+                json: async () => mockResponse,
+            });
+
+            const result = await sdkConfigStore.resolve(
+                "shop.example.com",
+                "http://localhost:3000"
+            );
+
+            expect(result).toEqual(mockResponse);
+            expect(global.fetch).toHaveBeenCalledWith(
+                "http://localhost:3030/user/merchant/resolve?domain=shop.example.com"
+            );
+        });
+
+        it("should encode domain in URL query parameter", async () => {
+            const mockResponse = {
+                merchantId: "merchant-encoded",
+                name: "Test",
+                domain: "shop.example.com",
+                allowedDomains: [],
+            };
+
+            global.fetch = vi.fn().mockResolvedValueOnce({
+                ok: true,
+                json: async () => mockResponse,
+            });
+
+            const domainWithSpecialChars = "shop.example.com?test=1&foo=bar";
+            await sdkConfigStore.resolve(domainWithSpecialChars);
+
+            expect(global.fetch).toHaveBeenCalledWith(
+                "https://backend.frak.id/user/merchant/resolve?domain=shop.example.com%3Ftest%3D1%26foo%3Dbar"
+            );
+        });
+
+        it("should write merchantId to sessionStorage as 'frak-merchant-id'", async () => {
+            const mockResponse = {
+                merchantId: "merchant-persisted",
+                name: "Test",
+                domain: "shop.example.com",
+                allowedDomains: [],
+            };
+
+            global.fetch = vi.fn().mockResolvedValueOnce({
+                ok: true,
+                json: async () => mockResponse,
+            });
+
+            await sdkConfigStore.resolve("shop.example.com");
+
+            expect(window.sessionStorage.getItem("frak-merchant-id")).toBe(
+                "merchant-persisted"
+            );
+        });
+
+        it("should pass lang parameter to backend when provided", async () => {
+            const mockResponse = {
+                merchantId: "merchant-lang",
+                name: "Test",
+                domain: "shop.example.com",
+                allowedDomains: [],
+            };
+
+            global.fetch = vi.fn().mockResolvedValueOnce({
+                ok: true,
+                json: async () => mockResponse,
+            });
+
+            await sdkConfigStore.resolve("shop.example.com", undefined, "fr");
+
+            expect(global.fetch).toHaveBeenCalledWith(
+                "https://backend.frak.id/user/merchant/resolve?domain=shop.example.com&lang=fr"
+            );
+        });
+    });
+
+    describe("sdkConfigStore.getMerchantId", () => {
+        it("should return merchantId from resolved config", () => {
+            window.__frakSdkConfig = {
+                isResolved: true,
+                merchantId: "config-merchant-123",
+            };
+
+            const result = sdkConfigStore.getMerchantId();
+
+            expect(result).toBe("config-merchant-123");
+        });
+
+        it("should fall back to sessionStorage", () => {
+            window.__frakSdkConfig = {
+                isResolved: false,
+                merchantId: "",
+            };
+            window.sessionStorage.setItem(
+                "frak-merchant-id",
+                "session-merchant-456"
+            );
+
+            const result = sdkConfigStore.getMerchantId();
+
+            expect(result).toBe("session-merchant-456");
+        });
+
+        it("should return undefined when nothing cached", () => {
+            window.__frakSdkConfig = {
+                isResolved: false,
+                merchantId: "",
+            };
+
+            const result = sdkConfigStore.getMerchantId();
+
+            expect(result).toBeUndefined();
+        });
+    });
+
+    describe("sdkConfigStore.resolveMerchantId", () => {
+        it("should return merchantId from store without fetch", async () => {
+            window.__frakSdkConfig = {
+                isResolved: true,
+                merchantId: "store-merchant-123",
+            };
+            global.fetch = vi.fn();
+
+            const result = await sdkConfigStore.resolveMerchantId();
+
+            expect(result).toBe("store-merchant-123");
+            expect(global.fetch).not.toHaveBeenCalled();
+        });
+
+        it("should return merchantId from sessionStorage without fetch", async () => {
+            window.__frakSdkConfig = {
+                isResolved: false,
+                merchantId: "",
+            };
+            window.sessionStorage.setItem(
+                "frak-merchant-id",
+                "session-merchant-789"
+            );
+            global.fetch = vi.fn();
+
+            const result = await sdkConfigStore.resolveMerchantId();
+
+            expect(result).toBe("session-merchant-789");
+            expect(global.fetch).not.toHaveBeenCalled();
+        });
+
+        it("should fetch from backend as last resort", async () => {
+            const mockResponse = {
+                merchantId: "fetched-merchant-456",
+                name: "Test",
+                domain: "shop.example.com",
+                allowedDomains: [],
+            };
+
+            global.fetch = vi.fn().mockResolvedValueOnce({
+                ok: true,
+                json: async () => mockResponse,
+            });
+
+            Object.defineProperty(window, "location", {
+                value: { hostname: "shop.example.com" },
+                writable: true,
+            });
+
+            const result = await sdkConfigStore.resolveMerchantId();
+
+            expect(result).toBe("fetched-merchant-456");
+            expect(global.fetch).toHaveBeenCalled();
+        });
+
+        it("should return undefined when fetch fails", async () => {
+            global.fetch = vi
+                .fn()
+                .mockRejectedValueOnce(new Error("Network error"));
+
+            Object.defineProperty(window, "location", {
+                value: { hostname: "shop.example.com" },
+                writable: true,
+            });
+
+            const result = await sdkConfigStore.resolveMerchantId();
+
+            expect(result).toBeUndefined();
+        });
+    });
+
+    describe("sdkConfigStore.clearCache", () => {
+        it("should clear all caches and allow re-fetching", async () => {
+            const mockResponse = {
+                merchantId: "merchant-clear-test",
+                name: "Test",
+                domain: "shop.example.com",
+                allowedDomains: [],
+            };
+
+            global.fetch = vi.fn().mockResolvedValue({
+                ok: true,
+                json: async () => mockResponse,
+            });
+
+            const result1 = await sdkConfigStore.resolve("shop.example.com");
+            expect(result1).toEqual(mockResponse);
+            expect(global.fetch).toHaveBeenCalledTimes(1);
+
+            sdkConfigStore.clearCache();
+
+            const result2 = await sdkConfigStore.resolve("shop.example.com");
+            expect(result2).toEqual(mockResponse);
+            expect(global.fetch).toHaveBeenCalledTimes(2);
+        });
+
+        it("should clear sessionStorage frak-merchant-id", async () => {
+            const mockResponse = {
+                merchantId: "merchant-session-clear",
+                name: "Test",
+                domain: "shop.example.com",
+                allowedDomains: [],
+            };
+
+            global.fetch = vi.fn().mockResolvedValueOnce({
+                ok: true,
+                json: async () => mockResponse,
+            });
+
+            await sdkConfigStore.resolve("shop.example.com");
+            expect(window.sessionStorage.getItem("frak-merchant-id")).toBe(
+                "merchant-session-clear"
+            );
+
+            sdkConfigStore.clearCache();
+
+            expect(
+                window.sessionStorage.getItem("frak-merchant-id")
+            ).toBeNull();
+        });
+    });
+});

package/src/utils/sdkConfigStore.ts

@@ -0,0 +1,263 @@
+/**
+ * SDK config store — reactive singleton for the resolved merchant config.
+ *
+ * State lives directly on `window.__frakSdkConfig`.
+ * Reactivity is handled via the `frak:config` CustomEvent on `window`.
+ * Resolved configs are cached in localStorage (30 s TTL, stale-while-revalidate).
+ *
+ * Backend fetch responses are cached and deduplicated via `withCache`.
+ * Also owns the `frak-merchant-id` sessionStorage compatibility key.
+ */
+
+import type { Language } from "../types/config";
+import type {
+    MerchantConfigResponse,
+    SdkResolvedConfig,
+} from "../types/resolvedConfig";
+import { getBackendUrl } from "./backendUrl";
+import { clearAllCache, withCache } from "./cache";
+
+const GLOBAL_KEY = "__frakSdkConfig";
+const CACHE_TTL = 30_000; // 30 seconds
+const DEFAULT_CACHE_KEY = "frak-config-cache";
+const MERCHANT_ID_KEY = "frak-merchant-id";
+
+const cacheState = { key: DEFAULT_CACHE_KEY };
+
+const isBrowser = typeof window !== "undefined";
+
+type CacheEntry = { config: SdkResolvedConfig; timestamp: number };
+
+declare global {
+    interface Window {
+        [GLOBAL_KEY]?: SdkResolvedConfig;
+    }
+    interface WindowEventMap {
+        "frak:config": CustomEvent<SdkResolvedConfig>;
+    }
+}
+
+function freshEmptyConfig(): SdkResolvedConfig {
+    return { isResolved: false, merchantId: "" };
+}
+
+// ---------------------------------------------------------------------------
+// localStorage cache (with in-memory parsed copy)
+// ---------------------------------------------------------------------------
+
+let memoryEntry: CacheEntry | null = null;
+
+function loadCacheEntry(): CacheEntry | null {
+    if (!isBrowser) return null;
+    try {
+        const raw = localStorage.getItem(cacheState.key);
+        if (!raw) return null;
+        const entry: CacheEntry = JSON.parse(raw);
+        if (!entry.config?.isResolved) return null;
+        memoryEntry = entry;
+        return entry;
+    } catch {
+        return null;
+    }
+}
+
+function readCache(): SdkResolvedConfig | undefined {
+    return (memoryEntry ?? loadCacheEntry())?.config;
+}
+
+function isCacheFresh(): boolean {
+    const entry = memoryEntry ?? loadCacheEntry();
+    if (!entry) return false;
+    return Date.now() - entry.timestamp < CACHE_TTL;
+}
+
+function writeCache(config: SdkResolvedConfig): void {
+    if (!isBrowser || !config.isResolved) return;
+    try {
+        const entry: CacheEntry = { config, timestamp: Date.now() };
+        localStorage.setItem(cacheState.key, JSON.stringify(entry));
+        memoryEntry = entry;
+    } catch {}
+}
+
+function removeCache(): void {
+    if (!isBrowser) return;
+    memoryEntry = null;
+    try {
+        localStorage.removeItem(cacheState.key);
+    } catch {}
+}
+
+// ---------------------------------------------------------------------------
+// Initialise window-backed config (once per bundle boundary)
+// ---------------------------------------------------------------------------
+
+function initConfig(): void {
+    if (!isBrowser) return;
+    if (window[GLOBAL_KEY]) return;
+    window[GLOBAL_KEY] = readCache() ?? freshEmptyConfig();
+}
+
+initConfig();
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function getConfig(): SdkResolvedConfig {
+    if (!isBrowser) return freshEmptyConfig();
+    return window[GLOBAL_KEY] ?? freshEmptyConfig();
+}
+
+function dispatch(config: SdkResolvedConfig): void {
+    if (!isBrowser) return;
+    window.dispatchEvent(new CustomEvent("frak:config", { detail: config }));
+}
+
+function getTargetDomain(domain?: string): string {
+    return domain ?? (isBrowser ? window.location.hostname : "");
+}
+
+// ---------------------------------------------------------------------------
+// Merchant config fetching (resolve)
+// ---------------------------------------------------------------------------
+
+async function fetchFromBackend(
+    targetDomain: string,
+    walletUrl?: string,
+    lang?: Language
+): Promise<MerchantConfigResponse | undefined> {
+    try {
+        const backendUrl = getBackendUrl(walletUrl);
+        const langParam = lang ? `&lang=${encodeURIComponent(lang)}` : "";
+        const response = await fetch(
+            `${backendUrl}/user/merchant/resolve?domain=${encodeURIComponent(targetDomain)}${langParam}`
+        );
+
+        if (!response.ok) {
+            console.warn(
+                `[Frak SDK] Merchant lookup failed for domain ${targetDomain}: ${response.status}`
+            );
+            return undefined;
+        }
+
+        const data = (await response.json()) as MerchantConfigResponse;
+
+        // Write compatibility sessionStorage key
+        if (isBrowser) {
+            try {
+                sessionStorage.setItem(MERCHANT_ID_KEY, data.merchantId);
+            } catch {}
+        }
+
+        return data;
+    } catch (error) {
+        console.warn("[Frak SDK] Failed to fetch merchant config:", error);
+        return undefined;
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+export const sdkConfigStore = {
+    getConfig,
+
+    get isResolved(): boolean {
+        return getConfig().isResolved;
+    },
+
+    get isCacheFresh(): boolean {
+        return isCacheFresh();
+    },
+
+    setCacheScope(domain: string, lang?: string): void {
+        const suffix = `${domain}:${lang ?? ""}`;
+        cacheState.key = `${DEFAULT_CACHE_KEY}:${suffix}`;
+        memoryEntry = null;
+    },
+
+    setConfig(config: SdkResolvedConfig): void {
+        if (isBrowser) window[GLOBAL_KEY] = config;
+        writeCache(config);
+        dispatch(config);
+
+        // Keep sessionStorage merchantId in sync
+        if (isBrowser && config.merchantId) {
+            try {
+                sessionStorage.setItem(MERCHANT_ID_KEY, config.merchantId);
+            } catch {}
+        }
+    },
+
+    reset(): void {
+        const next = readCache() ?? freshEmptyConfig();
+        if (isBrowser) window[GLOBAL_KEY] = next;
+        dispatch(next);
+    },
+
+    clearCache(): void {
+        removeCache();
+        clearAllCache();
+        if (isBrowser) {
+            try {
+                sessionStorage.removeItem(MERCHANT_ID_KEY);
+            } catch {}
+        }
+    },
+
+    resolve(
+        domain?: string,
+        walletUrl?: string,
+        lang?: Language
+    ): Promise<MerchantConfigResponse | undefined> {
+        const targetDomain = getTargetDomain(domain);
+        if (!targetDomain) {
+            return Promise.resolve(undefined);
+        }
+
+        const cacheKey = `sdkConfig:${targetDomain}:${lang ?? ""}`;
+
+        return withCache(
+            async () => {
+                const result = await fetchFromBackend(
+                    targetDomain,
+                    walletUrl,
+                    lang
+                );
+                // Throw on failure so withCache doesn't cache undefined
+                if (!result) {
+                    throw new Error("Config resolution returned empty");
+                }
+                return result;
+            },
+            { cacheKey, cacheTime: Number.POSITIVE_INFINITY }
+        ).catch(() => undefined);
+    },
+
+    getMerchantId(): string | undefined {
+        const config = getConfig();
+        if (config.isResolved && config.merchantId) {
+            return config.merchantId;
+        }
+
+        if (isBrowser) {
+            try {
+                return sessionStorage.getItem(MERCHANT_ID_KEY) ?? undefined;
+            } catch {}
+        }
+        return undefined;
+    },
+
+    async resolveMerchantId(
+        domain?: string,
+        walletUrl?: string
+    ): Promise<string | undefined> {
+        const fast = sdkConfigStore.getMerchantId();
+        if (fast) return fast;
+
+        const config = await sdkConfigStore.resolve(domain, walletUrl);
+        return config?.merchantId;
+    },
+};

package/src/utils/sso.ts

@@ -3,7 +3,7 @@ import type { PrepareSsoParamsType, SsoMetadata } from "../types";
 import { compressJsonToB64 } from "./compression/compress";
 
 export type AppSpecificSsoMetadata = SsoMetadata & {
-    name: string;
+    name?: string;
     css?: string;
 };
 
@@ -43,7 +43,7 @@ export function generateSsoUrl(
     walletUrl: string,
     params: PrepareSsoParamsType,
     merchantId: string,
-    name: string,
+    name: string | undefined,
     clientId: string,
     css?: string
 ): string {
@@ -114,13 +114,9 @@ export type CompressedSsoData = {
     m: string;
     // metadata
     md: {
-        // merchant name
-        n: string;
-        // custom css
+        n?: string;
         css?: string;
-        // logo
         l?: string;
-        // home page link
         h?: string;
     };
 };