@frak-labs/core-sdk 0.2.1-beta.b38eef2e → 0.2.1-beta.c7fe645d

package/src/utils/cache/withCache.ts

@@ -0,0 +1,105 @@
+import { LruMap } from "./lruMap";
+
+type CacheEntry<TData> = {
+    data: TData;
+    created: number;
+};
+
+/** Global cache for in-flight promises (dedup concurrent calls) */
+const promiseCache = new LruMap<Promise<unknown>>(1024);
+
+/** Global cache for resolved responses (TTL-based) */
+const responseCache = new LruMap<CacheEntry<unknown>>(1024);
+
+/** Default cache time: 30 seconds */
+export const DEFAULT_CACHE_TIME = 30_000;
+
+type WithCacheOptions = {
+    /** The key to cache the data against */
+    cacheKey: string;
+    /** Time in ms that cached data will remain valid. Default: 30_000 (30s). Set to 0 to disable caching. */
+    cacheTime?: number;
+};
+
+/**
+ * Returns the result of a given promise, and caches the result for
+ * subsequent invocations against a provided cache key.
+ *
+ * Also deduplicates concurrent calls — if multiple callers request the same
+ * cache key while the promise is pending, they share the same promise.
+ *
+ * @example
+ * ```ts
+ * // First call fetches, subsequent calls return cached data for 30s
+ * const data = await withCache(
+ *     () => client.request({ method: "frak_getMerchantInformation" }),
+ *     { cacheKey: "merchantInfo", cacheTime: 30_000 }
+ * );
+ * ```
+ */
+export async function withCache<TData>(
+    fn: () => Promise<TData>,
+    { cacheKey, cacheTime = DEFAULT_CACHE_TIME }: WithCacheOptions
+): Promise<TData> {
+    // Check response cache — return immediately if fresh
+    if (cacheTime > 0) {
+        const cached = responseCache.get(cacheKey) as
+            | CacheEntry<TData>
+            | undefined;
+        if (cached) {
+            const age = Date.now() - cached.created;
+            if (age < cacheTime) return cached.data;
+        }
+    }
+
+    // Check if there's already a pending promise (dedup concurrent calls)
+    let promise = promiseCache.get(cacheKey) as Promise<TData> | undefined;
+    if (!promise) {
+        promise = fn();
+        promiseCache.set(cacheKey, promise);
+    }
+
+    try {
+        const data = await promise;
+        // Store the response with a timestamp
+        responseCache.set(cacheKey, { data, created: Date.now() });
+        return data;
+    } finally {
+        // Clear the promise cache so subsequent calls can re-fetch after TTL
+        promiseCache.delete(cacheKey);
+    }
+}
+
+/**
+ * Get a cache handle for a specific key, useful for manual invalidation.
+ *
+ * @example
+ * ```ts
+ * // Invalidate merchant info cache after a mutation
+ * getCache("frak_getMerchantInformation").clear();
+ * ```
+ */
+export function getCache(cacheKey: string) {
+    return {
+        /** Clear both the pending promise and the cached response */
+        clear: () => {
+            promiseCache.delete(cacheKey);
+            responseCache.delete(cacheKey);
+        },
+        /** Check if a non-expired response exists */
+        has: (cacheTime: number = DEFAULT_CACHE_TIME) => {
+            const cached = responseCache.get(cacheKey);
+            if (!cached) return false;
+            return Date.now() - cached.created < cacheTime;
+        },
+    };
+}
+
+/**
+ * Clear all cached data (both pending promises and resolved responses).
+ * Called automatically when the client is destroyed.
+ */
+export function clearAllCache() {
+    promiseCache.clear();
+    responseCache.clear();
+}

package/src/utils/inAppBrowser.ts

@@ -0,0 +1,60 @@
+/**
+ * Check if the current device runs iOS (including iPadOS 13+).
+ */
+function checkIsIOS(): boolean {
+    if (typeof navigator === "undefined") return false;
+    const ua = navigator.userAgent;
+    // Standard iOS devices
+    if (/iPhone|iPad|iPod/i.test(ua)) return true;
+    // iPadOS 13+ reports as Macintosh — detect via touch support
+    if (/Macintosh/i.test(ua) && navigator.maxTouchPoints > 1) return true;
+    return false;
+}
+
+/**
+ * Whether the current device runs iOS (including iPadOS 13+).
+ */
+export const isIOS: boolean = checkIsIOS();
+
+/**
+ * Check if the current browser is a social media in-app browser
+ * (Instagram, Facebook WebView).
+ */
+function checkInAppBrowser(): boolean {
+    if (typeof navigator === "undefined") return false;
+    const ua = navigator.userAgent.toLowerCase();
+    return (
+        ua.includes("instagram") ||
+        ua.includes("fban") ||
+        ua.includes("fbav") ||
+        ua.includes("facebook")
+    );
+}
+
+/**
+ * Whether the current browser is a social media in-app browser
+ * (Instagram, Facebook).
+ */
+export const isInAppBrowser: boolean = checkInAppBrowser();
+
+/**
+ * Redirect to external browser from in-app WebView.
+ *
+ * - **iOS**: Uses `x-safari-https://` scheme — server-side 302 redirects
+ *   to custom URL schemes are silently swallowed by WKWebView.
+ *   Direct `window.location.href` assignment works (confirmed iOS 17+).
+ *
+ * - **Android**: Uses backend `/common/social` endpoint which returns a PDF
+ *   Content-Type response, forcing the WebView to hand off to the default browser.
+ *
+ * @param targetUrl - The URL to open in the external browser
+ */
+export function redirectToExternalBrowser(targetUrl: string): void {
+    if (isIOS && targetUrl.startsWith("https://")) {
+        window.location.href = `x-safari-https://${targetUrl.slice(8)}`;
+    } else if (isIOS && targetUrl.startsWith("http://")) {
+        window.location.href = `x-safari-http://${targetUrl.slice(7)}`;
+    } else {
+        window.location.href = `${process.env.BACKEND_URL}/common/social?u=${encodeURIComponent(targetUrl)}`;
+    }
+}

package/src/utils/index.ts

@@ -1,5 +1,6 @@
 export { Deferred } from "@frak-labs/frame-connector";
 export { getBackendUrl } from "./backendUrl";
+export { clearAllCache, getCache, withCache } from "./cache";
 export { getClientId } from "./clientId";
 export { base64urlDecode, base64urlEncode } from "./compression/b64";
 export { compressJsonToB64 } from "./compression/compress";
@@ -23,10 +24,11 @@ export {
     findIframeInOpener,
 } from "./iframeHelper";
 export {
-    clearMerchantIdCache,
-    fetchMerchantId,
-    resolveMerchantId,
-} from "./merchantId";
+    isInAppBrowser,
+    isIOS,
+    redirectToExternalBrowser,
+} from "./inAppBrowser";
+export { sdkConfigStore } from "./sdkConfigStore";
 export {
     type AppSpecificSsoMetadata,
     type CompressedSsoData,

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();
+        });
+    });
+});