@crossmint/client-sdk-auth 1.1.3 → 1.1.5

package/src/CrossmintAuthClient.ts

@@ -1,294 +0,0 @@
-import type { UseSignInData } from "@farcaster/auth-kit";
-import {
-    AUTH_SDK_ROOT_ENDPOINT,
-    type AuthMaterialWithUser,
-    CROSSMINT_API_VERSION,
-    CrossmintAuth,
-    CrossmintAuthenticationError,
-    type CrossmintAuthOptions,
-    type OAuthProvider,
-    REFRESH_TOKEN_PREFIX,
-    SESSION_PREFIX,
-} from "@crossmint/common-sdk-auth";
-import type { Crossmint, CrossmintApiClient } from "@crossmint/common-sdk-base";
-import { type CancellableTask, queueTask } from "@crossmint/client-sdk-base";
-import { deleteCookie, getCookie, getJWTExpiration, setCookie, TIME_BEFORE_EXPIRING_JWT_IN_SECONDS } from "./utils";
-
-type CrossmintAuthClientConfig = CrossmintAuthOptions & {
-    callbacks?: CrossmintAuthClientCallbacks;
-    logoutRoute?: string;
-};
-
-export class CrossmintAuthClient extends CrossmintAuth {
-    private callbacks: CrossmintAuthClientCallbacks;
-    private refreshTask: CancellableTask | null = null;
-    private refreshPromise: Promise<AuthMaterialWithUser> | null = null;
-    private logoutRoute: string | null;
-
-    private constructor(crossmint: Crossmint, apiClient: CrossmintApiClient, config: CrossmintAuthClientConfig = {}) {
-        super(crossmint, apiClient, config);
-        this.callbacks = config.callbacks ?? {};
-        this.logoutRoute = config.logoutRoute ?? null;
-    }
-
-    public static from(crossmint: Crossmint, config: CrossmintAuthClientConfig = {}): CrossmintAuthClient {
-        const authClient = new CrossmintAuthClient(crossmint, CrossmintAuth.defaultApiClient(crossmint), config);
-        // In case an instance is created on the server, we can't refresh as this stores cookies
-        if (typeof window !== "undefined") {
-            authClient.handleRefreshAuthMaterial();
-        }
-        return authClient;
-    }
-
-    public async getUser() {
-        try {
-            const response = await this.apiClient.get(`api/${CROSSMINT_API_VERSION}/sdk/auth/user`, {
-                headers: { "Content-Type": "application/json" },
-            });
-
-            if (!response.ok) {
-                throw await response.text();
-            }
-
-            return await response.json();
-        } catch (error) {
-            throw new CrossmintAuthenticationError(
-                `Failed to fetch user: ${error instanceof Error ? error.message : "Unknown error"}`
-            );
-        }
-    }
-
-    public storeAuthMaterial(authMaterial: AuthMaterialWithUser) {
-        setCookie(SESSION_PREFIX, authMaterial.jwt);
-        setCookie(REFRESH_TOKEN_PREFIX, authMaterial.refreshToken.secret, authMaterial.refreshToken.expiresAt);
-    }
-
-    public async logout() {
-        // Store the old refresh token to pass it to the logout route before deleting the cookies
-        const oldRefreshToken = getCookie(REFRESH_TOKEN_PREFIX);
-
-        // Even if there's a server error, we want to clear the cookies and we do it first to load faster
-        deleteCookie(REFRESH_TOKEN_PREFIX);
-        deleteCookie(SESSION_PREFIX);
-        this.callbacks.onLogout?.();
-        try {
-            if (this.logoutRoute != null) {
-                await this.logoutFromCustomRoute();
-            } else if (oldRefreshToken != null) {
-                await this.logoutFromDefaultRoute(oldRefreshToken);
-            }
-        } catch (error) {
-            console.error(error);
-        }
-    }
-
-    public async handleRefreshAuthMaterial(refreshTokenSecret?: string): Promise<void> {
-        const refreshToken = refreshTokenSecret ?? getCookie(REFRESH_TOKEN_PREFIX);
-        // If there is a custom refresh route, that endpoint will fetch the cookies itself
-        if (refreshToken == null && this.refreshRoute == null) {
-            return;
-        }
-
-        try {
-            // Create new refresh promise if none exists
-            if (this.refreshPromise == null) {
-                this.refreshPromise = this.refreshAuthMaterial(refreshToken);
-            }
-            const authMaterial = await this.refreshPromise;
-
-            // If a custom refresh route is set, storing in cookies is handled in the server
-            if (this.refreshRoute == null) {
-                this.storeAuthMaterial(authMaterial);
-            }
-
-            this.callbacks.onTokenRefresh?.(authMaterial);
-
-            this.scheduleNextRefresh(authMaterial.jwt);
-        } catch (error) {
-            console.error(error);
-            this.logout();
-        } finally {
-            this.refreshPromise = null;
-        }
-    }
-
-    public async getOAuthUrl(provider: OAuthProvider) {
-        try {
-            const response = await this.apiClient.get(`${AUTH_SDK_ROOT_ENDPOINT}/social/${provider}/start`, {
-                headers: { "Content-Type": "application/json" },
-            });
-
-            if (!response.ok) {
-                throw await response.text();
-            }
-
-            const data = await response.json();
-            return data.oauthUrl;
-        } catch (error) {
-            throw new CrossmintAuthenticationError(
-                `Failed to get OAuth URL for provider ${provider}: ${error instanceof Error ? error.message : "Unknown error"}`
-            );
-        }
-    }
-
-    public async sendEmailOtp(email: string) {
-        try {
-            const response = await this.apiClient.post(`${AUTH_SDK_ROOT_ENDPOINT}/otps/send`, {
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({ email }),
-            });
-
-            if (!response.ok) {
-                throw await response.text();
-            }
-
-            return await response.json();
-        } catch (error) {
-            throw new CrossmintAuthenticationError(
-                `Failed to send email OTP: ${error instanceof Error ? error.message : "Unknown error"}`
-            );
-        }
-    }
-
-    public async confirmEmailOtp(email: string, emailId: string, token: string) {
-        try {
-            const queryParams = new URLSearchParams({
-                email,
-                signinAuthenticationMethod: "email",
-                token,
-                locale: "en",
-                state: emailId,
-            });
-
-            const response = await this.apiClient.post(`${AUTH_SDK_ROOT_ENDPOINT}/authenticate?${queryParams}`, {
-                headers: { "Content-Type": "application/json" },
-            });
-
-            if (!response.ok) {
-                throw await response.text();
-            }
-
-            const resData = await response.json();
-            return resData.oneTimeSecret;
-        } catch (error) {
-            throw new CrossmintAuthenticationError(
-                `Failed to confirm email OTP: ${error instanceof Error ? error.message : "Unknown error"}`
-            );
-        }
-    }
-
-    public async signInWithFarcaster(data: UseSignInData) {
-        try {
-            const queryParams = new URLSearchParams({
-                signinAuthenticationMethod: "farcaster",
-                callbackUrl: `${this.apiClient.baseUrl}/${AUTH_SDK_ROOT_ENDPOINT}/callback`,
-            });
-
-            const response = await this.apiClient.post(`${AUTH_SDK_ROOT_ENDPOINT}/authenticate?${queryParams}`, {
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({
-                    ...data,
-                    domain: data.signatureParams.domain,
-                    redirect: true,
-                    callbackUrl: `${this.apiClient.baseUrl}/${AUTH_SDK_ROOT_ENDPOINT}/callback`,
-                }),
-            });
-
-            if (!response.ok) {
-                throw await response.text();
-            }
-
-            const resData = await response.json();
-            return resData.oneTimeSecret;
-        } catch (error) {
-            throw new CrossmintAuthenticationError(
-                `Failed to sign in with Farcaster: ${error instanceof Error ? error.message : "Unknown error"}`
-            );
-        }
-    }
-
-    public async signInWithSmartWallet(address: string) {
-        try {
-            const queryParams = new URLSearchParams({ signinAuthenticationMethod: "evm" });
-            const response = await this.apiClient.post(
-                `${AUTH_SDK_ROOT_ENDPOINT}/crypto_wallets/authenticate/start?${queryParams}`,
-                {
-                    headers: { "Content-Type": "application/json" },
-                    body: JSON.stringify({ walletAddress: address }),
-                }
-            );
-
-            if (!response.ok) {
-                throw await response.text();
-            }
-
-            return await response.json();
-        } catch (error) {
-            throw new CrossmintAuthenticationError(
-                `Failed to initiate smart wallet sign in: ${error instanceof Error ? error.message : "Unknown error"}`
-            );
-        }
-    }
-
-    public async authenticateSmartWallet(address: string, signature: string) {
-        try {
-            const queryParams = new URLSearchParams({
-                signinAuthenticationMethod: "evm",
-                callbackUrl: `${this.apiClient.baseUrl}/${AUTH_SDK_ROOT_ENDPOINT}/callback`,
-            });
-            const response = await this.apiClient.post(
-                `${AUTH_SDK_ROOT_ENDPOINT}/crypto_wallets/authenticate?${queryParams}`,
-                {
-                    headers: { "Content-Type": "application/json" },
-                    body: JSON.stringify({ walletAddress: address, signature }),
-                }
-            );
-
-            if (!response.ok) {
-                throw await response.text();
-            }
-
-            return await response.json();
-        } catch (error) {
-            throw new CrossmintAuthenticationError(
-                `Failed to authenticate smart wallet: ${error instanceof Error ? error.message : "Unknown error"}`
-            );
-        }
-    }
-
-    private async logoutFromCustomRoute(): Promise<Response> {
-        if (!this.logoutRoute) {
-            throw new Error("Custom logout route is not set");
-        }
-
-        return await fetch(this.logoutRoute, { method: "POST" });
-    }
-
-    private scheduleNextRefresh(jwt: string): void {
-        const jwtExpiration = getJWTExpiration(jwt);
-        if (!jwtExpiration) {
-            throw new Error("Invalid JWT");
-        }
-
-        const currentTime = Date.now() / 1000;
-        const timeToExpire = jwtExpiration - currentTime - TIME_BEFORE_EXPIRING_JWT_IN_SECONDS;
-
-        if (timeToExpire > 0) {
-            const endTime = Date.now() + timeToExpire * 1000;
-            this.cancelScheduledRefresh();
-            this.refreshTask = queueTask(() => this.handleRefreshAuthMaterial(), endTime);
-        }
-    }
-
-    private cancelScheduledRefresh(): void {
-        if (this.refreshTask) {
-            this.refreshTask.cancel();
-            this.refreshTask = null;
-        }
-    }
-}
-
-type CrossmintAuthClientCallbacks = {
-    onTokenRefresh?: (authMaterial: AuthMaterialWithUser) => void;
-    onLogout?: () => void;
-};

package/src/index.ts

@@ -1,3 +0,0 @@
-export { createCrossmint } from "@crossmint/common-sdk-base";
-export { CrossmintAuthClient as CrossmintAuth } from "./CrossmintAuthClient";
-export * from "./utils";

package/src/utils/constants.ts

@@ -1 +0,0 @@
-export const TIME_BEFORE_EXPIRING_JWT_IN_SECONDS = 120;

package/src/utils/cookies.test.ts

@@ -1,44 +0,0 @@
-import { beforeEach, describe, expect, it } from "vitest";
-import { deleteCookie, getCookie, setCookie } from "./cookies";
-
-describe("cookies", () => {
-    beforeEach(() => {
-        // Clear all cookies before each test
-        document.cookie.split(";").forEach((cookie) => {
-            document.cookie = cookie
-                .replace(/^ +/, "")
-                .replace(/=.*/, "=;expires=" + new Date().toUTCString() + ";path=/");
-        });
-    });
-
-    it("should return undefined for non-existent cookie", () => {
-        expect(getCookie("non-existent")).toBeUndefined();
-    });
-
-    it("should return the correct value for an existing cookie", async () => {
-        document.cookie = "test-cookie=test-value";
-        await waitForSettledState(() => {
-            expect(getCookie("test-cookie")).toBe("test-value");
-        });
-    });
-
-    it("should set a cookie without expiration", async () => {
-        setCookie("test-cookie", "test-value");
-        await waitForSettledState(() => {
-            expect(document.cookie).toContain("test-cookie=test-value");
-        });
-    });
-
-    it("should delete an existing cookie", async () => {
-        document.cookie = "test-cookie=test-value";
-        deleteCookie("test-cookie");
-        await waitForSettledState(() => {
-            expect(document.cookie).not.toContain("test-cookie");
-        });
-    });
-});
-
-const waitForSettledState = async (callback: () => void) => {
-    await new Promise((resolve) => setTimeout(resolve, 20));
-    callback();
-};

package/src/utils/cookies.ts

@@ -1,13 +0,0 @@
-export function getCookie(name: string): string | undefined {
-    const crossmintRefreshToken = document.cookie.split("; ").find((row) => row.startsWith(name));
-    return crossmintRefreshToken ? crossmintRefreshToken.split("=")[1] : undefined;
-}
-
-export function setCookie(name: string, value: string, expiresAt?: string) {
-    const expiresInUtc = expiresAt ? new Date(expiresAt).toUTCString() : "";
-    document.cookie = `${name}=${value}; ${expiresAt ? `expires=${expiresInUtc};` : ""} path=/; SameSite=Lax;`;
-}
-
-export function deleteCookie(name: string) {
-    document.cookie = `${name}=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/;`;
-}

package/src/utils/index.ts

@@ -1,3 +0,0 @@
-export * from "./jwt";
-export * from "./cookies";
-export * from "./constants";

package/src/utils/jwt.ts

@@ -1,6 +0,0 @@
-import { jwtDecode } from "jwt-decode";
-
-export function getJWTExpiration(token: string) {
-    const decoded = jwtDecode(token);
-    return decoded.exp;
-}