@frak-labs/core-sdk 0.1.0-beta.8d103039 → 0.1.0-beta.d9302e66

package/src/actions/trackPurchaseStatus.test.ts

@@ -0,0 +1,287 @@
+/**
+ * Tests for trackPurchaseStatus action
+ * Tests webhook registration for purchase tracking
+ */
+
+import {
+    afterEach,
+    beforeEach,
+    describe,
+    expect,
+    it,
+    vi,
+} from "../../tests/vitest-fixtures";
+import { trackPurchaseStatus } from "./trackPurchaseStatus";
+
+describe("trackPurchaseStatus", () => {
+    let mockSessionStorage: {
+        getItem: ReturnType<typeof vi.fn>;
+        setItem: ReturnType<typeof vi.fn>;
+        removeItem: ReturnType<typeof vi.fn>;
+    };
+    let fetchSpy: any;
+    let consoleWarnSpy: any;
+
+    beforeEach(() => {
+        // Mock sessionStorage
+        mockSessionStorage = {
+            getItem: vi.fn(),
+            setItem: vi.fn(),
+            removeItem: vi.fn(),
+        };
+        Object.defineProperty(window, "sessionStorage", {
+            value: mockSessionStorage,
+            writable: true,
+            configurable: true,
+        });
+
+        // Mock fetch
+        fetchSpy = vi.fn().mockResolvedValue({
+            ok: true,
+            status: 200,
+        });
+        global.fetch = fetchSpy;
+
+        // Mock console.warn
+        consoleWarnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+    });
+
+    afterEach(() => {
+        vi.clearAllMocks();
+        consoleWarnSpy.mockRestore();
+    });
+
+    describe("successful tracking", () => {
+        it("should send POST request with correct parameters", async () => {
+            mockSessionStorage.getItem.mockReturnValue("token-123");
+
+            await trackPurchaseStatus({
+                customerId: "cust-456",
+                orderId: "order-789",
+                token: "purchase-token",
+            });
+
+            expect(fetchSpy).toHaveBeenCalledWith(
+                "https://backend.frak.id/interactions/listenForPurchase",
+                {
+                    method: "POST",
+                    headers: {
+                        Accept: "application/json",
+                        "Content-Type": "application/json",
+                        "x-wallet-sdk-auth": "token-123",
+                    },
+                    body: JSON.stringify({
+                        customerId: "cust-456",
+                        orderId: "order-789",
+                        token: "purchase-token",
+                    }),
+                }
+            );
+        });
+
+        it("should read interaction token from sessionStorage", async () => {
+            mockSessionStorage.getItem.mockReturnValue("my-token");
+
+            await trackPurchaseStatus({
+                customerId: "cust-1",
+                orderId: "order-1",
+                token: "token-1",
+            });
+
+            expect(mockSessionStorage.getItem).toHaveBeenCalledWith(
+                "frak-wallet-interaction-token"
+            );
+            expect(fetchSpy).toHaveBeenCalled();
+        });
+
+        it("should handle numeric customerId", async () => {
+            mockSessionStorage.getItem.mockReturnValue("token-123");
+
+            await trackPurchaseStatus({
+                customerId: 12345,
+                orderId: "order-789",
+                token: "purchase-token",
+            });
+
+            expect(fetchSpy).toHaveBeenCalledWith(
+                expect.any(String),
+                expect.objectContaining({
+                    body: JSON.stringify({
+                        customerId: 12345,
+                        orderId: "order-789",
+                        token: "purchase-token",
+                    }),
+                })
+            );
+        });
+
+        it("should handle numeric orderId", async () => {
+            mockSessionStorage.getItem.mockReturnValue("token-123");
+
+            await trackPurchaseStatus({
+                customerId: "cust-456",
+                orderId: 67890,
+                token: "purchase-token",
+            });
+
+            expect(fetchSpy).toHaveBeenCalledWith(
+                expect.any(String),
+                expect.objectContaining({
+                    body: JSON.stringify({
+                        customerId: "cust-456",
+                        orderId: 67890,
+                        token: "purchase-token",
+                    }),
+                })
+            );
+        });
+
+        it("should handle both numeric customerId and orderId", async () => {
+            mockSessionStorage.getItem.mockReturnValue("token-123");
+
+            await trackPurchaseStatus({
+                customerId: 12345,
+                orderId: 67890,
+                token: "purchase-token",
+            });
+
+            expect(fetchSpy).toHaveBeenCalledWith(
+                expect.any(String),
+                expect.objectContaining({
+                    body: JSON.stringify({
+                        customerId: 12345,
+                        orderId: 67890,
+                        token: "purchase-token",
+                    }),
+                })
+            );
+        });
+    });
+
+    describe("missing interaction token", () => {
+        it("should warn when no interaction token found", async () => {
+            mockSessionStorage.getItem.mockReturnValue(null);
+
+            await trackPurchaseStatus({
+                customerId: "cust-456",
+                orderId: "order-789",
+                token: "purchase-token",
+            });
+
+            expect(consoleWarnSpy).toHaveBeenCalledWith(
+                "[Frak] No frak session found, skipping purchase check"
+            );
+        });
+
+        it("should not send request when no interaction token", async () => {
+            mockSessionStorage.getItem.mockReturnValue(null);
+
+            await trackPurchaseStatus({
+                customerId: "cust-456",
+                orderId: "order-789",
+                token: "purchase-token",
+            });
+
+            expect(fetchSpy).not.toHaveBeenCalled();
+        });
+
+        it("should not send request when interaction token is empty string", async () => {
+            mockSessionStorage.getItem.mockReturnValue("");
+
+            await trackPurchaseStatus({
+                customerId: "cust-456",
+                orderId: "order-789",
+                token: "purchase-token",
+            });
+
+            expect(fetchSpy).not.toHaveBeenCalled();
+        });
+    });
+
+    describe("network errors", () => {
+        it("should handle fetch rejection", async () => {
+            mockSessionStorage.getItem.mockReturnValue("token-123");
+            fetchSpy.mockRejectedValue(new Error("Network error"));
+
+            await expect(
+                trackPurchaseStatus({
+                    customerId: "cust-456",
+                    orderId: "order-789",
+                    token: "purchase-token",
+                })
+            ).rejects.toThrow("Network error");
+        });
+
+        it("should handle fetch with error response", async () => {
+            mockSessionStorage.getItem.mockReturnValue("token-123");
+            fetchSpy.mockResolvedValue({
+                ok: false,
+                status: 500,
+            });
+
+            // Function doesn't check response, so it should complete
+            await trackPurchaseStatus({
+                customerId: "cust-456",
+                orderId: "order-789",
+                token: "purchase-token",
+            });
+
+            expect(fetchSpy).toHaveBeenCalled();
+        });
+    });
+
+    describe("request format", () => {
+        it("should include correct headers", async () => {
+            mockSessionStorage.getItem.mockReturnValue("my-auth-token");
+
+            await trackPurchaseStatus({
+                customerId: "cust-1",
+                orderId: "order-1",
+                token: "token-1",
+            });
+
+            expect(fetchSpy).toHaveBeenCalledWith(
+                expect.any(String),
+                expect.objectContaining({
+                    headers: {
+                        Accept: "application/json",
+                        "Content-Type": "application/json",
+                        "x-wallet-sdk-auth": "my-auth-token",
+                    },
+                })
+            );
+        });
+
+        it("should use POST method", async () => {
+            mockSessionStorage.getItem.mockReturnValue("token-123");
+
+            await trackPurchaseStatus({
+                customerId: "cust-1",
+                orderId: "order-1",
+                token: "token-1",
+            });
+
+            expect(fetchSpy).toHaveBeenCalledWith(
+                expect.any(String),
+                expect.objectContaining({
+                    method: "POST",
+                })
+            );
+        });
+
+        it("should target correct backend URL", async () => {
+            mockSessionStorage.getItem.mockReturnValue("token-123");
+
+            await trackPurchaseStatus({
+                customerId: "cust-1",
+                orderId: "order-1",
+                token: "token-1",
+            });
+
+            expect(fetchSpy).toHaveBeenCalledWith(
+                "https://backend.frak.id/interactions/listenForPurchase",
+                expect.any(Object)
+            );
+        });
+    });
+});

package/src/actions/watchWalletStatus.test.ts

@@ -0,0 +1,372 @@
+/**
+ * Tests for watchWalletStatus action
+ * Tests wallet status watching and side effects
+ */
+
+import { vi } from "vitest";
+
+// Mock Deferred before imports
+vi.mock("@frak-labs/frame-connector", () => ({
+    Deferred: class {
+        promise: Promise<any>;
+        resolve: (value: any) => void;
+
+        constructor() {
+            let resolveFunc: (value: any) => void;
+            this.promise = new Promise((resolve) => {
+                resolveFunc = resolve;
+            });
+            this.resolve = resolveFunc!;
+        }
+    },
+}));
+
+import type { Address } from "viem";
+import {
+    afterEach,
+    beforeEach,
+    describe,
+    expect,
+    it,
+} from "../../tests/vitest-fixtures";
+import type { FrakClient, WalletStatusReturnType } from "../types";
+import { watchWalletStatus } from "./watchWalletStatus";
+
+describe("watchWalletStatus", () => {
+    let mockSessionStorage: {
+        getItem: ReturnType<typeof vi.fn>;
+        setItem: ReturnType<typeof vi.fn>;
+        removeItem: ReturnType<typeof vi.fn>;
+    };
+
+    beforeEach(() => {
+        // Mock sessionStorage
+        mockSessionStorage = {
+            getItem: vi.fn(),
+            setItem: vi.fn(),
+            removeItem: vi.fn(),
+        };
+        Object.defineProperty(window, "sessionStorage", {
+            value: mockSessionStorage,
+            writable: true,
+            configurable: true,
+        });
+    });
+
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+
+    describe("without callback", () => {
+        it("should make one-shot request", async () => {
+            const mockStatus: WalletStatusReturnType = {
+                key: "connected",
+                wallet: "0x1234567890123456789012345678901234567890" as Address,
+                interactionToken: "token-123",
+            };
+
+            const mockClient = {
+                request: vi.fn().mockResolvedValue(mockStatus),
+                openPanel: {
+                    setGlobalProperties: vi.fn(),
+                },
+            } as unknown as FrakClient;
+
+            const result = await watchWalletStatus(mockClient);
+
+            expect(mockClient.request).toHaveBeenCalledWith({
+                method: "frak_listenToWalletStatus",
+            });
+            expect(result).toEqual(mockStatus);
+        });
+
+        it("should save interaction token to sessionStorage", async () => {
+            const mockStatus: WalletStatusReturnType = {
+                key: "connected",
+                wallet: "0x1234567890123456789012345678901234567890" as Address,
+                interactionToken: "token-abc",
+            };
+
+            const mockClient = {
+                request: vi.fn().mockResolvedValue(mockStatus),
+                openPanel: {
+                    setGlobalProperties: vi.fn(),
+                },
+            } as unknown as FrakClient;
+
+            await watchWalletStatus(mockClient);
+
+            expect(mockSessionStorage.setItem).toHaveBeenCalledWith(
+                "frak-wallet-interaction-token",
+                "token-abc"
+            );
+        });
+
+        it("should remove interaction token when not present", async () => {
+            const mockStatus: WalletStatusReturnType = {
+                key: "not-connected",
+            };
+
+            const mockClient = {
+                request: vi.fn().mockResolvedValue(mockStatus),
+                openPanel: {
+                    setGlobalProperties: vi.fn(),
+                },
+            } as unknown as FrakClient;
+
+            await watchWalletStatus(mockClient);
+
+            expect(mockSessionStorage.removeItem).toHaveBeenCalledWith(
+                "frak-wallet-interaction-token"
+            );
+        });
+
+        it("should update OpenPanel global properties", async () => {
+            const mockStatus: WalletStatusReturnType = {
+                key: "connected",
+                wallet: "0xabcdefabcdefabcdefabcdefabcdefabcdefabcd" as Address,
+            };
+
+            const mockClient = {
+                request: vi.fn().mockResolvedValue(mockStatus),
+                openPanel: {
+                    setGlobalProperties: vi.fn(),
+                },
+            } as unknown as FrakClient;
+
+            await watchWalletStatus(mockClient);
+
+            expect(
+                mockClient.openPanel?.setGlobalProperties
+            ).toHaveBeenCalledWith({
+                wallet: "0xabcdefabcdefabcdefabcdefabcdefabcdefabcd",
+            });
+        });
+
+        it("should set wallet to null when not connected", async () => {
+            const mockStatus: WalletStatusReturnType = {
+                key: "not-connected",
+            };
+
+            const mockClient = {
+                request: vi.fn().mockResolvedValue(mockStatus),
+                openPanel: {
+                    setGlobalProperties: vi.fn(),
+                },
+            } as unknown as FrakClient;
+
+            await watchWalletStatus(mockClient);
+
+            expect(
+                mockClient.openPanel?.setGlobalProperties
+            ).toHaveBeenCalledWith({
+                wallet: null,
+            });
+        });
+
+        it("should work without openPanel", async () => {
+            const mockStatus: WalletStatusReturnType = {
+                key: "connected",
+                wallet: "0x1234567890123456789012345678901234567890" as Address,
+            };
+
+            const mockClient = {
+                request: vi.fn().mockResolvedValue(mockStatus),
+            } as unknown as FrakClient;
+
+            const result = await watchWalletStatus(mockClient);
+
+            expect(result).toEqual(mockStatus);
+        });
+    });
+
+    describe("with callback", () => {
+        it("should setup listener request", async () => {
+            const mockStatus: WalletStatusReturnType = {
+                key: "connected",
+                wallet: "0x1234567890123456789012345678901234567890" as Address,
+            };
+
+            const mockCallback = vi.fn();
+            const mockClient = {
+                listenerRequest: vi.fn((_params, callback) => {
+                    // Simulate status update
+                    setTimeout(() => callback(mockStatus), 0);
+                }),
+                openPanel: {
+                    setGlobalProperties: vi.fn(),
+                },
+            } as unknown as FrakClient;
+
+            const resultPromise = watchWalletStatus(mockClient, mockCallback);
+
+            expect(mockClient.listenerRequest).toHaveBeenCalled();
+
+            await resultPromise;
+        });
+
+        it("should call callback with status updates", async () => {
+            const mockStatus: WalletStatusReturnType = {
+                key: "connected",
+                wallet: "0x1234567890123456789012345678901234567890" as Address,
+                interactionToken: "token-123",
+            };
+
+            const mockCallback = vi.fn();
+            const mockClient = {
+                listenerRequest: vi.fn((_params, callback) => {
+                    setTimeout(() => callback(mockStatus), 0);
+                }),
+                openPanel: {
+                    setGlobalProperties: vi.fn(),
+                },
+            } as unknown as FrakClient;
+
+            await watchWalletStatus(mockClient, mockCallback);
+
+            expect(mockCallback).toHaveBeenCalledWith(mockStatus);
+        });
+
+        it("should resolve promise with first status", async () => {
+            const firstStatus: WalletStatusReturnType = {
+                key: "connected",
+                wallet: "0x1234567890123456789012345678901234567890" as Address,
+            };
+
+            const secondStatus: WalletStatusReturnType = {
+                key: "connected",
+                wallet: "0xabcdefabcdefabcdefabcdefabcdefabcdefabcd" as Address,
+            };
+
+            const mockCallback = vi.fn();
+            const mockClient = {
+                listenerRequest: vi.fn((_params, callback) => {
+                    setTimeout(() => {
+                        callback(firstStatus);
+                        callback(secondStatus);
+                    }, 0);
+                }),
+                openPanel: {
+                    setGlobalProperties: vi.fn(),
+                },
+            } as unknown as FrakClient;
+
+            const result = await watchWalletStatus(mockClient, mockCallback);
+
+            expect(result).toEqual(firstStatus);
+            expect(mockCallback).toHaveBeenCalledTimes(2);
+        });
+
+        it("should handle side effects for each status update", async () => {
+            const firstStatus: WalletStatusReturnType = {
+                key: "connected",
+                wallet: "0x1234567890123456789012345678901234567890" as Address,
+                interactionToken: "token-1",
+            };
+
+            const secondStatus: WalletStatusReturnType = {
+                key: "connected",
+                wallet: "0x1234567890123456789012345678901234567890" as Address,
+                interactionToken: "token-2",
+            };
+
+            const mockCallback = vi.fn();
+            const mockClient = {
+                listenerRequest: vi.fn((_params, callback) => {
+                    setTimeout(() => {
+                        callback(firstStatus);
+                        callback(secondStatus);
+                    }, 0);
+                }),
+                openPanel: {
+                    setGlobalProperties: vi.fn(),
+                },
+            } as unknown as FrakClient;
+
+            await watchWalletStatus(mockClient, mockCallback);
+
+            // Both tokens should be saved
+            expect(mockSessionStorage.setItem).toHaveBeenCalledWith(
+                "frak-wallet-interaction-token",
+                "token-1"
+            );
+            expect(mockSessionStorage.setItem).toHaveBeenCalledWith(
+                "frak-wallet-interaction-token",
+                "token-2"
+            );
+        });
+
+        it("should save and remove interaction token based on status", async () => {
+            const connectedStatus: WalletStatusReturnType = {
+                key: "connected",
+                wallet: "0x1234567890123456789012345678901234567890" as Address,
+                interactionToken: "token-123",
+            };
+
+            const disconnectedStatus: WalletStatusReturnType = {
+                key: "not-connected",
+            };
+
+            const mockCallback = vi.fn();
+            const mockClient = {
+                listenerRequest: vi.fn((_params, callback) => {
+                    setTimeout(() => {
+                        callback(connectedStatus);
+                        callback(disconnectedStatus);
+                    }, 0);
+                }),
+                openPanel: {
+                    setGlobalProperties: vi.fn(),
+                },
+            } as unknown as FrakClient;
+
+            await watchWalletStatus(mockClient, mockCallback);
+
+            expect(mockSessionStorage.setItem).toHaveBeenCalledWith(
+                "frak-wallet-interaction-token",
+                "token-123"
+            );
+            expect(mockSessionStorage.removeItem).toHaveBeenCalledWith(
+                "frak-wallet-interaction-token"
+            );
+        });
+
+        it("should update OpenPanel properties with each status", async () => {
+            const firstStatus: WalletStatusReturnType = {
+                key: "connected",
+                wallet: "0x1111111111111111111111111111111111111111" as Address,
+            };
+
+            const secondStatus: WalletStatusReturnType = {
+                key: "connected",
+                wallet: "0x2222222222222222222222222222222222222222" as Address,
+            };
+
+            const mockCallback = vi.fn();
+            const mockClient = {
+                listenerRequest: vi.fn((_params, callback) => {
+                    setTimeout(() => {
+                        callback(firstStatus);
+                        callback(secondStatus);
+                    }, 0);
+                }),
+                openPanel: {
+                    setGlobalProperties: vi.fn(),
+                },
+            } as unknown as FrakClient;
+
+            await watchWalletStatus(mockClient, mockCallback);
+
+            expect(
+                mockClient.openPanel?.setGlobalProperties
+            ).toHaveBeenCalledWith({
+                wallet: "0x1111111111111111111111111111111111111111",
+            });
+            expect(
+                mockClient.openPanel?.setGlobalProperties
+            ).toHaveBeenCalledWith({
+                wallet: "0x2222222222222222222222222222222222222222",
+            });
+        });
+    });
+});

package/src/bundle.ts

@@ -1,3 +1,3 @@
-export * from "./index";
 export * from "./actions";
+export * from "./index";
 export * from "./interactions";

package/src/clients/createIFrameFrakClient.ts

@@ -1,8 +1,8 @@
 import {
+    createRpcClient,
     FrakRpcError,
     type RpcClient,
     RpcErrorCodes,
-    createRpcClient,
 } from "@frak-labs/frame-connector";
 import { createClientCompressionMiddleware } from "@frak-labs/frame-connector/middleware";
 import { OpenPanel } from "@openpanel/web";
@@ -14,8 +14,8 @@ import { BACKUP_KEY } from "../utils/constants";
 import { setupSsoUrlListener } from "../utils/ssoUrlListener";
 import { DebugInfoGatherer } from "./DebugInfo";
 import {
-    type IframeLifecycleManager,
     createIFrameLifecycleManager,
+    type IframeLifecycleManager,
 } from "./transports/iframeLifecycleManager";
 
 type SdkRpcClient = RpcClient<IFrameRpcSchema, FrakLifecycleEvent>;

package/src/clients/index.ts

@@ -1,3 +1,3 @@
 export { createIFrameFrakClient } from "./createIFrameFrakClient";
-export { setupClient } from "./setupClient";
 export { DebugInfoGatherer } from "./DebugInfo";
+export { setupClient } from "./setupClient";

package/src/clients/setupClient.ts

@@ -19,7 +19,9 @@ import { createIframe, getSupportedCurrency } from "../utils";
  */
 export async function setupClient({
     config,
-}: { config: FrakWalletSdkConfig }): Promise<FrakClient | undefined> {
+}: {
+    config: FrakWalletSdkConfig;
+}): Promise<FrakClient | undefined> {
     // Prepare the config
     const preparedConfig = prepareConfig(config);