@frak-labs/core-sdk 0.1.0-beta.afa252b0 → 0.1.0-beta.b0bd1f8a

package/src/actions/sendInteraction.test.ts

@@ -0,0 +1,219 @@
+/**
+ * Tests for sendInteraction action
+ * Tests sending user interactions via RPC
+ */
+
+import type { Hex } from "viem";
+import { vi } from "vitest";
+
+// Mock computeProductId - must be before imports
+vi.mock("../utils/computeProductId", () => ({
+    computeProductId: vi.fn(
+        () =>
+            "0xcomputed1234567890123456789012345678901234567890123456789012" as Hex
+    ),
+}));
+
+import { describe, expect, it } from "../../tests/vitest-fixtures";
+import type {
+    FrakClient,
+    PreparedInteraction,
+    SendInteractionParamsType,
+    SendInteractionReturnType,
+} from "../types";
+import { sendInteraction } from "./sendInteraction";
+
+describe("sendInteraction", () => {
+    const mockInteraction: PreparedInteraction = {
+        interactionData: "0xdata" as Hex,
+        handlerTypeDenominator: "0x01" as Hex,
+    };
+
+    describe("with productId provided", () => {
+        it("should use provided productId", async () => {
+            const mockResponse: SendInteractionReturnType = {
+                delegationId: "delegation-123",
+            };
+
+            const mockClient = {
+                config: {
+                    domain: "example.com",
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const params: SendInteractionParamsType = {
+                productId:
+                    "0xprovidedid567890123456789012345678901234567890123456789012" as Hex,
+                interaction: mockInteraction,
+            };
+
+            await sendInteraction(mockClient, params);
+
+            expect(mockClient.request).toHaveBeenCalledWith({
+                method: "frak_sendInteraction",
+                params: [
+                    "0xprovidedid567890123456789012345678901234567890123456789012",
+                    mockInteraction,
+                    undefined,
+                ],
+            });
+        });
+
+        it("should return delegationId", async () => {
+            const mockResponse: SendInteractionReturnType = {
+                delegationId: "delegation-456",
+            };
+
+            const mockClient = {
+                config: {
+                    domain: "example.com",
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const params: SendInteractionParamsType = {
+                productId:
+                    "0xprovidedid567890123456789012345678901234567890123456789012" as Hex,
+                interaction: mockInteraction,
+            };
+
+            const result = await sendInteraction(mockClient, params);
+
+            expect(result).toEqual(mockResponse);
+            expect(result.delegationId).toBe("delegation-456");
+        });
+
+        it("should include validation signature when provided", async () => {
+            const mockResponse: SendInteractionReturnType = {
+                delegationId: "delegation-789",
+            };
+
+            const mockClient = {
+                config: {
+                    domain: "example.com",
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const params: SendInteractionParamsType = {
+                productId:
+                    "0xprovidedid567890123456789012345678901234567890123456789012" as Hex,
+                interaction: mockInteraction,
+                validation: "0xsignature1234567890" as Hex,
+            };
+
+            await sendInteraction(mockClient, params);
+
+            expect(mockClient.request).toHaveBeenCalledWith({
+                method: "frak_sendInteraction",
+                params: [
+                    "0xprovidedid567890123456789012345678901234567890123456789012",
+                    mockInteraction,
+                    "0xsignature1234567890",
+                ],
+            });
+        });
+    });
+
+    describe("without productId provided", () => {
+        it("should compute productId from client.config", async () => {
+            const { computeProductId } = await import(
+                "../utils/computeProductId"
+            );
+
+            const mockResponse: SendInteractionReturnType = {
+                delegationId: "delegation-computed",
+            };
+
+            const mockClient = {
+                config: {
+                    domain: "example.com",
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const params: SendInteractionParamsType = {
+                interaction: mockInteraction,
+            };
+
+            await sendInteraction(mockClient, params);
+
+            expect(computeProductId).toHaveBeenCalledWith(mockClient.config);
+            expect(mockClient.request).toHaveBeenCalledWith({
+                method: "frak_sendInteraction",
+                params: [
+                    "0xcomputed1234567890123456789012345678901234567890123456789012",
+                    mockInteraction,
+                    undefined,
+                ],
+            });
+        });
+
+        it("should work with different interaction types", async () => {
+            const mockResponse: SendInteractionReturnType = {
+                delegationId: "delegation-different",
+            };
+
+            const mockClient = {
+                config: {
+                    domain: "example.com",
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const differentInteraction: PreparedInteraction = {
+                interactionData: "0xdifferentdata" as Hex,
+                handlerTypeDenominator: "0x02" as Hex,
+            };
+
+            const params: SendInteractionParamsType = {
+                interaction: differentInteraction,
+            };
+
+            const result = await sendInteraction(mockClient, params);
+
+            expect(result).toEqual(mockResponse);
+        });
+    });
+
+    describe("error handling", () => {
+        it("should propagate errors from client.request", async () => {
+            const error = new Error("Send interaction failed");
+            const mockClient = {
+                config: {
+                    domain: "example.com",
+                },
+                request: vi.fn().mockRejectedValue(error),
+            } as unknown as FrakClient;
+
+            const params: SendInteractionParamsType = {
+                productId:
+                    "0xprovidedid567890123456789012345678901234567890123456789012" as Hex,
+                interaction: mockInteraction,
+            };
+
+            await expect(sendInteraction(mockClient, params)).rejects.toThrow(
+                "Send interaction failed"
+            );
+        });
+
+        it("should handle network errors", async () => {
+            const error = new Error("Network timeout");
+            const mockClient = {
+                config: {
+                    domain: "example.com",
+                },
+                request: vi.fn().mockRejectedValue(error),
+            } as unknown as FrakClient;
+
+            const params: SendInteractionParamsType = {
+                interaction: mockInteraction,
+            };
+
+            await expect(sendInteraction(mockClient, params)).rejects.toThrow(
+                "Network timeout"
+            );
+        });
+    });
+});

package/src/actions/sendInteraction.ts

@@ -0,0 +1,32 @@
+import type {
+    FrakClient,
+    SendInteractionParamsType,
+    SendInteractionReturnType,
+} from "../types";
+import { computeProductId } from "../utils/computeProductId";
+
+/**
+ * Function used to send an interaction
+ * @param client - The current Frak Client
+ * @param args
+ *
+ * @example
+ * const interaction = PressInteractionEncoder.openArticle({
+ *     articleId: keccak256(toHex("article-slug")),
+ * });
+ * const { delegationId } = await sendInteraction(frakConfig, {
+ *     interaction,
+ * });
+ * console.log("Delegated interaction id", delegationId);
+ */
+export async function sendInteraction(
+    client: FrakClient,
+    { productId, interaction, validation }: SendInteractionParamsType
+): Promise<SendInteractionReturnType> {
+    const pId = productId ?? computeProductId(client.config);
+
+    return await client.request({
+        method: "frak_sendInteraction",
+        params: [pId, interaction, validation],
+    });
+}

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/trackPurchaseStatus.ts

@@ -0,0 +1,53 @@
+/**
+ * Function used to track the status of a purchase
+ * when a purchase is tracked, the `purchaseCompleted` interactions will be automatically send for the user when we receive the purchase confirmation via webhook.
+ *
+ * @param args.customerId - The customer id that made the purchase (on your side)
+ * @param args.orderId - The order id of the purchase (on your side)
+ * @param args.token - The token of the purchase
+ *
+ * @description This function will send a request to the backend to listen for the purchase status.
+ *
+ * @example
+ * async function trackPurchase(checkout) {
+ *   const payload = {
+ *     customerId: checkout.order.customer.id,
+ *     orderId: checkout.order.id,
+ *     token: checkout.token,
+ *   };
+ *
+ *   await trackPurchaseStatus(payload);
+ * }
+ *
+ * @remarks
+ * - The `trackPurchaseStatus` function requires the `frak-wallet-interaction-token` stored in the session storage to authenticate the request.
+ * - This function will print a warning if used in a non-browser environment or if the wallet interaction token is not available.
+ */
+export async function trackPurchaseStatus(args: {
+    customerId: string | number;
+    orderId: string | number;
+    token: string;
+}) {
+    if (typeof window === "undefined") {
+        console.warn("[Frak] No window found, can't track purchase");
+        return;
+    }
+    const interactionToken = window.sessionStorage.getItem(
+        "frak-wallet-interaction-token"
+    );
+    if (!interactionToken) {
+        console.warn("[Frak] No frak session found, skipping purchase check");
+        return;
+    }
+
+    // Submit the listening request
+    await fetch("https://backend.frak.id/interactions/listenForPurchase", {
+        method: "POST",
+        headers: {
+            Accept: "application/json",
+            "Content-Type": "application/json",
+            "x-wallet-sdk-auth": interactionToken,
+        },
+        body: JSON.stringify(args),
+    });
+}