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

package/src/actions/openSso.test.ts

@@ -0,0 +1,407 @@
+/**
+ * Tests for openSso action
+ * Tests SSO flows in both redirect and popup modes
+ */
+
+import { vi } from "vitest";
+
+// Mock utilities before imports
+vi.mock("../utils/sso", () => ({
+    generateSsoUrl: vi.fn((walletUrl, _args, productId, name, _css) => {
+        return `${walletUrl}/sso?name=${name}&productId=${productId}`;
+    }),
+}));
+
+vi.mock("../utils/computeProductId", () => ({
+    computeProductId: vi.fn(
+        () =>
+            "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"
+    ),
+}));
+
+import {
+    afterEach,
+    beforeEach,
+    describe,
+    expect,
+    it,
+} from "../../tests/vitest-fixtures";
+import type {
+    FrakClient,
+    OpenSsoParamsType,
+    OpenSsoReturnType,
+} from "../types";
+import { openSso, ssoPopupFeatures, ssoPopupName } from "./openSso";
+
+describe("openSso", () => {
+    describe("constants", () => {
+        it("should have correct popup features", () => {
+            expect(ssoPopupFeatures).toBe(
+                "menubar=no,status=no,scrollbars=no,fullscreen=no,width=500, height=800"
+            );
+        });
+
+        it("should have correct popup name", () => {
+            expect(ssoPopupName).toBe("frak-sso");
+        });
+    });
+
+    describe("redirect mode", () => {
+        it("should use redirect mode when openInSameWindow is true", async () => {
+            const mockResponse: OpenSsoReturnType = {
+                wallet: "0x1234567890123456789012345678901234567890",
+            };
+
+            const mockClient = {
+                config: {
+                    metadata: { name: "Test App" },
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const params: OpenSsoParamsType = {
+                openInSameWindow: true,
+                metadata: {
+                    logoUrl: "https://example.com/logo.png",
+                },
+            };
+
+            const result = await openSso(mockClient, params);
+
+            expect(mockClient.request).toHaveBeenCalledWith({
+                method: "frak_openSso",
+                params: [params, "Test App", undefined],
+            });
+            expect(result).toEqual(mockResponse);
+        });
+
+        it("should use redirect mode when redirectUrl is provided", async () => {
+            const mockResponse: OpenSsoReturnType = {
+                wallet: "0xabcdefabcdefabcdefabcdefabcdefabcdefabcd",
+            };
+
+            const mockClient = {
+                config: {
+                    metadata: { name: "Test App" },
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const params: OpenSsoParamsType = {
+                redirectUrl: "https://example.com/callback",
+                metadata: {
+                    logoUrl: "https://example.com/logo.png",
+                },
+            };
+
+            const result = await openSso(mockClient, params);
+
+            expect(mockClient.request).toHaveBeenCalledWith({
+                method: "frak_openSso",
+                params: [params, "Test App", undefined],
+            });
+            expect(result).toEqual(mockResponse);
+        });
+
+        it("should pass custom CSS in redirect mode", async () => {
+            const mockResponse: OpenSsoReturnType = {};
+
+            const mockClient = {
+                config: {
+                    metadata: { name: "Test App" },
+                    customizations: {
+                        css: ":root { --primary: blue; }",
+                    },
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const params: OpenSsoParamsType = {
+                openInSameWindow: true,
+                metadata: {
+                    logoUrl: "https://example.com/logo.png",
+                },
+            };
+
+            await openSso(mockClient, params);
+
+            expect(mockClient.request).toHaveBeenCalledWith({
+                method: "frak_openSso",
+                params: [params, "Test App", ":root { --primary: blue; }"],
+            });
+        });
+    });
+
+    describe("popup mode", () => {
+        let windowOpenSpy: any;
+        let mockPopup: {
+            focus: ReturnType<typeof vi.fn>;
+        };
+
+        beforeEach(() => {
+            mockPopup = {
+                focus: vi.fn(),
+            };
+            windowOpenSpy = vi
+                .spyOn(window, "open")
+                .mockReturnValue(mockPopup as unknown as Window);
+        });
+
+        afterEach(() => {
+            windowOpenSpy.mockRestore();
+        });
+
+        it("should open popup with generated URL", async () => {
+            const mockResponse: OpenSsoReturnType = {
+                wallet: "0x1234567890123456789012345678901234567890",
+            };
+
+            const mockClient = {
+                config: {
+                    metadata: { name: "Test App" },
+                    walletUrl: "https://wallet.frak.id",
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const params: OpenSsoParamsType = {
+                metadata: {
+                    logoUrl: "https://example.com/logo.png",
+                },
+            };
+
+            await openSso(mockClient, params);
+
+            expect(window.open).toHaveBeenCalledWith(
+                expect.stringContaining("https://wallet.frak.id/sso"),
+                "frak-sso",
+                "menubar=no,status=no,scrollbars=no,fullscreen=no,width=500, height=800"
+            );
+        });
+
+        it("should use custom ssoPopupUrl when provided", async () => {
+            const mockResponse: OpenSsoReturnType = {};
+
+            const mockClient = {
+                config: {
+                    metadata: { name: "Test App" },
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const params: OpenSsoParamsType = {
+                ssoPopupUrl: "https://custom-wallet.com/sso?custom=param",
+                metadata: {
+                    logoUrl: "https://example.com/logo.png",
+                },
+            };
+
+            await openSso(mockClient, params);
+
+            expect(window.open).toHaveBeenCalledWith(
+                "https://custom-wallet.com/sso?custom=param",
+                "frak-sso",
+                "menubar=no,status=no,scrollbars=no,fullscreen=no,width=500, height=800"
+            );
+        });
+
+        it("should focus popup after opening", async () => {
+            const mockResponse: OpenSsoReturnType = {};
+
+            const mockClient = {
+                config: {
+                    metadata: { name: "Test App" },
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const params: OpenSsoParamsType = {
+                metadata: {
+                    logoUrl: "https://example.com/logo.png",
+                },
+            };
+
+            await openSso(mockClient, params);
+
+            expect(mockPopup.focus).toHaveBeenCalled();
+        });
+
+        it("should wait for SSO completion via client.request", async () => {
+            const mockResponse: OpenSsoReturnType = {
+                wallet: "0x1234567890123456789012345678901234567890",
+            };
+
+            const mockClient = {
+                config: {
+                    metadata: { name: "Test App" },
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const params: OpenSsoParamsType = {
+                metadata: {
+                    logoUrl: "https://example.com/logo.png",
+                },
+            };
+
+            const result = await openSso(mockClient, params);
+
+            expect(mockClient.request).toHaveBeenCalledWith({
+                method: "frak_openSso",
+                params: [params, "Test App", undefined],
+            });
+            expect(result).toEqual(mockResponse);
+        });
+
+        it("should return empty object when result is null", async () => {
+            const mockClient = {
+                config: {
+                    metadata: { name: "Test App" },
+                },
+                request: vi.fn().mockResolvedValue(null),
+            } as unknown as FrakClient;
+
+            const params: OpenSsoParamsType = {
+                metadata: {
+                    logoUrl: "https://example.com/logo.png",
+                },
+            };
+
+            const result = await openSso(mockClient, params);
+
+            expect(result).toEqual({});
+        });
+
+        it("should use default wallet URL when not configured", async () => {
+            const mockResponse: OpenSsoReturnType = {};
+
+            const mockClient = {
+                config: {
+                    metadata: { name: "Test App" },
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const params: OpenSsoParamsType = {
+                metadata: {
+                    logoUrl: "https://example.com/logo.png",
+                },
+            };
+
+            await openSso(mockClient, params);
+
+            expect(window.open).toHaveBeenCalledWith(
+                expect.stringContaining("https://wallet.frak.id/sso"),
+                expect.any(String),
+                expect.any(String)
+            );
+        });
+    });
+
+    describe("popup blocker", () => {
+        it("should throw error when popup is blocked", async () => {
+            vi.spyOn(window, "open").mockReturnValue(null);
+
+            const mockClient = {
+                config: {
+                    metadata: { name: "Test App" },
+                },
+                request: vi.fn(),
+            } as unknown as FrakClient;
+
+            const params: OpenSsoParamsType = {
+                metadata: {
+                    logoUrl: "https://example.com/logo.png",
+                },
+            };
+
+            await expect(openSso(mockClient, params)).rejects.toThrow(
+                "Popup was blocked. Please allow popups for this site."
+            );
+        });
+
+        it("should not call client.request when popup is blocked", async () => {
+            vi.spyOn(window, "open").mockReturnValue(null);
+
+            const mockClient = {
+                config: {
+                    metadata: { name: "Test App" },
+                },
+                request: vi.fn(),
+            } as unknown as FrakClient;
+
+            const params: OpenSsoParamsType = {
+                metadata: {
+                    logoUrl: "https://example.com/logo.png",
+                },
+            };
+
+            try {
+                await openSso(mockClient, params);
+            } catch {
+                // Expected error
+            }
+
+            expect(mockClient.request).not.toHaveBeenCalled();
+        });
+    });
+
+    describe("mode detection", () => {
+        it("should prefer openInSameWindow over redirectUrl", async () => {
+            const mockResponse: OpenSsoReturnType = {};
+
+            const mockClient = {
+                config: {
+                    metadata: { name: "Test App" },
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const params: OpenSsoParamsType = {
+                openInSameWindow: false,
+                redirectUrl: "https://example.com/callback",
+                metadata: {
+                    logoUrl: "https://example.com/logo.png",
+                },
+            };
+
+            const windowOpenSpy = vi.spyOn(window, "open").mockReturnValue({
+                focus: vi.fn(),
+            } as unknown as Window);
+
+            await openSso(mockClient, params);
+
+            // Should use popup mode because openInSameWindow=false
+            expect(window.open).toHaveBeenCalled();
+
+            windowOpenSpy.mockRestore();
+        });
+
+        it("should use popup mode when neither flag is set", async () => {
+            const mockResponse: OpenSsoReturnType = {};
+
+            const mockClient = {
+                config: {
+                    metadata: { name: "Test App" },
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const params: OpenSsoParamsType = {
+                metadata: {
+                    logoUrl: "https://example.com/logo.png",
+                },
+            };
+
+            const windowOpenSpy = vi.spyOn(window, "open").mockReturnValue({
+                focus: vi.fn(),
+            } as unknown as Window);
+
+            await openSso(mockClient, params);
+
+            expect(window.open).toHaveBeenCalled();
+
+            windowOpenSpy.mockRestore();
+        });
+    });
+});

package/src/actions/prepareSso.test.ts

@@ -0,0 +1,223 @@
+/**
+ * Tests for prepareSso action
+ * Tests SSO URL generation via RPC
+ */
+
+import { describe, expect, it, vi } from "../../tests/vitest-fixtures";
+import type {
+    FrakClient,
+    PrepareSsoParamsType,
+    PrepareSsoReturnType,
+} from "../types";
+import { prepareSso } from "./prepareSso";
+
+describe("prepareSso", () => {
+    describe("success cases", () => {
+        it("should call client.request with correct method and params", async () => {
+            const mockResponse: PrepareSsoReturnType = {
+                ssoUrl: "https://wallet.frak.id/sso?params=xyz",
+            };
+
+            const mockClient = {
+                config: {
+                    metadata: {
+                        name: "Test App",
+                    },
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const params: PrepareSsoParamsType = {
+                directExit: true,
+            };
+
+            await prepareSso(mockClient, params);
+
+            expect(mockClient.request).toHaveBeenCalledWith({
+                method: "frak_prepareSso",
+                params: [params, "Test App", undefined],
+            });
+        });
+
+        it("should return SSO URL", async () => {
+            const mockResponse: PrepareSsoReturnType = {
+                ssoUrl: "https://wallet.frak.id/sso?params=abc123",
+            };
+
+            const mockClient = {
+                config: {
+                    metadata: {
+                        name: "Test App",
+                    },
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const params: PrepareSsoParamsType = {
+                directExit: false,
+            };
+
+            const result = await prepareSso(mockClient, params);
+
+            expect(result).toEqual(mockResponse);
+            expect(result.ssoUrl).toBe(
+                "https://wallet.frak.id/sso?params=abc123"
+            );
+        });
+
+        it("should include custom CSS when provided", async () => {
+            const mockResponse: PrepareSsoReturnType = {
+                ssoUrl: "https://wallet.frak.id/sso?params=custom",
+            };
+
+            const mockClient = {
+                config: {
+                    metadata: {
+                        name: "Styled App",
+                    },
+                    customizations: {
+                        css: "body { background: red; }",
+                    },
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const params: PrepareSsoParamsType = {
+                directExit: true,
+            };
+
+            await prepareSso(mockClient, params);
+
+            expect(mockClient.request).toHaveBeenCalledWith({
+                method: "frak_prepareSso",
+                params: [params, "Styled App", "body { background: red; }"],
+            });
+        });
+
+        it("should handle params with redirectUrl", async () => {
+            const mockResponse: PrepareSsoReturnType = {
+                ssoUrl: "https://wallet.frak.id/sso?redirect=https://example.com",
+            };
+
+            const mockClient = {
+                config: {
+                    metadata: {
+                        name: "Test App",
+                    },
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const params: PrepareSsoParamsType = {
+                redirectUrl: "https://example.com/callback",
+                directExit: false,
+            };
+
+            await prepareSso(mockClient, params);
+
+            expect(mockClient.request).toHaveBeenCalledWith({
+                method: "frak_prepareSso",
+                params: [params, "Test App", undefined],
+            });
+        });
+
+        it("should handle params with metadata", async () => {
+            const mockResponse: PrepareSsoReturnType = {
+                ssoUrl: "https://wallet.frak.id/sso?metadata=xyz",
+            };
+
+            const mockClient = {
+                config: {
+                    metadata: {
+                        name: "App with Metadata",
+                        logoUrl: "https://example.com/logo.png",
+                    },
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const params: PrepareSsoParamsType = {
+                metadata: {
+                    logoUrl: "https://custom.com/logo.png",
+                    homepageLink: "https://custom.com",
+                },
+                directExit: true,
+            };
+
+            await prepareSso(mockClient, params);
+
+            expect(mockClient.request).toHaveBeenCalledWith({
+                method: "frak_prepareSso",
+                params: [params, "App with Metadata", undefined],
+            });
+        });
+
+        it("should pass client metadata name to request", async () => {
+            const mockResponse: PrepareSsoReturnType = {
+                ssoUrl: "https://wallet.frak.id/sso?name=MyApp",
+            };
+
+            const mockClient = {
+                config: {
+                    metadata: {
+                        name: "MyApp",
+                        logoUrl: "https://example.com/logo.png",
+                    },
+                    customizations: {
+                        css: "body { color: blue; }",
+                    },
+                },
+                request: vi.fn().mockResolvedValue(mockResponse),
+            } as unknown as FrakClient;
+
+            const params: PrepareSsoParamsType = {};
+
+            await prepareSso(mockClient, params);
+
+            expect(mockClient.request).toHaveBeenCalledWith({
+                method: "frak_prepareSso",
+                params: [params, "MyApp", "body { color: blue; }"],
+            });
+        });
+    });
+
+    describe("error handling", () => {
+        it("should propagate errors from client.request", async () => {
+            const error = new Error("SSO preparation failed");
+            const mockClient = {
+                config: {
+                    metadata: {
+                        name: "Test App",
+                    },
+                },
+                request: vi.fn().mockRejectedValue(error),
+            } as unknown as FrakClient;
+
+            const params: PrepareSsoParamsType = {
+                directExit: true,
+            };
+
+            await expect(prepareSso(mockClient, params)).rejects.toThrow(
+                "SSO preparation failed"
+            );
+        });
+
+        it("should handle network errors", async () => {
+            const error = new Error("Network timeout");
+            const mockClient = {
+                config: {
+                    metadata: {
+                        name: "Test App",
+                    },
+                },
+                request: vi.fn().mockRejectedValue(error),
+            } as unknown as FrakClient;
+
+            const params: PrepareSsoParamsType = {};
+
+            await expect(prepareSso(mockClient, params)).rejects.toThrow(
+                "Network timeout"
+            );
+        });
+    });
+});

package/src/actions/referral/processReferral.ts

@@ -61,7 +61,7 @@ export type ProcessReferralOptions = {
  * @see {@link displayModal} for more details about the displayed modal
  * @see {@link sendInteraction} for more details on the interaction submission part
  * @see {@link ReferralInteractionEncoder} for more details about the referred interaction
- * @see {@link ModalStepTypes} for more details on each modal steps types
+ * @see {@link @frak-labs/core-sdk!ModalStepTypes} for more details on each modal steps types
  */
 export async function processReferral(
     client: FrakClient,

package/src/actions/referral/referralInteraction.ts

@@ -20,7 +20,7 @@ import {
  * @description This function will automatically handle the referral interaction process
  *
  * @see {@link processReferral} for more details on the automatic referral handling process
- * @see {@link ModalStepTypes} for more details on each modal steps types
+ * @see {@link @frak-labs/core-sdk!ModalStepTypes} for more details on each modal steps types
  */
 export async function referralInteraction(
     client: FrakClient,