@commercengine/storefront-sdk 0.1.0

package/dist/lib/auth.js

@@ -0,0 +1,679 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NextCookieTokenStorage = exports.CookieTokenStorage = exports.BrowserTokenStorage = exports.MemoryTokenStorage = exports.AuthClient = void 0;
+exports.createTokenStorage = createTokenStorage;
+const client_1 = require("./client");
+/**
+ * Client for interacting with authentication endpoints
+ */
+class AuthClient extends client_1.StorefrontAPIClient {
+    constructor(config, tokenStorage) {
+        super(config);
+        this.autoRefreshTimer = null;
+        // Use provided storage or default to memory storage
+        this.tokenStorage = tokenStorage || new MemoryTokenStorage();
+        // Try to initialize from storage
+        const storedToken = this.tokenStorage.getAccessToken();
+        if (storedToken) {
+            this.setToken(storedToken);
+            this.setupAutoRefresh();
+        }
+    }
+    // Override the setToken method to use storage
+    setToken(token) {
+        super.setToken(token); // Assuming this sets the token in the client
+        this.tokenStorage.setAccessToken(token);
+        // If we also have a refresh token, store it
+        if (this.tokenStorage.getRefreshToken()) {
+            this.setupAutoRefresh();
+        }
+    }
+    // Store refresh token separately
+    setRefreshToken(token) {
+        this.tokenStorage.setRefreshToken(token);
+    }
+    // Clear tokens from storage
+    clearToken() {
+        super.clearToken(); // Assuming this clears the token in the client
+        this.tokenStorage.clearTokens();
+        this.clearAutoRefresh();
+    }
+    // Setup auto refresh based on token expiry
+    setupAutoRefresh() {
+        this.clearAutoRefresh();
+        const token = this.tokenStorage.getAccessToken();
+        if (!token)
+            return;
+        const expiryTime = this.getTokenExpiry(token);
+        if (!expiryTime)
+            return;
+        // Calculate refresh time (30 seconds before expiry)
+        const currentTime = Math.floor(Date.now() / 1000);
+        const timeUntilRefresh = Math.max(0, expiryTime - currentTime - 30) * 1000;
+        // Cap the timeout to avoid integer overflow (max 2147483647 ms, ~24.8 days)
+        const maxTimeout = 2147483647;
+        const safeTimeout = Math.min(timeUntilRefresh, maxTimeout);
+        // If the token expires far in the future, we'll need to reset the timer periodically
+        if (timeUntilRefresh > maxTimeout) {
+            this.autoRefreshTimer = setTimeout(() => {
+                this.setupAutoRefresh(); // Recalculate the timer
+            }, maxTimeout);
+        }
+        else {
+            this.autoRefreshTimer = setTimeout(() => {
+                this.handleTokenRefresh();
+            }, safeTimeout);
+        }
+    }
+    clearAutoRefresh() {
+        if (this.autoRefreshTimer) {
+            clearTimeout(this.autoRefreshTimer);
+            this.autoRefreshTimer = null;
+        }
+    }
+    async handleTokenRefresh() {
+        try {
+            const refreshToken = this.tokenStorage.getRefreshToken();
+            if (!refreshToken)
+                return;
+            const tokens = await this.refreshToken(refreshToken);
+            this.setToken(tokens.access_token);
+            this.setRefreshToken(tokens.refresh_token);
+        }
+        catch (error) {
+            // If refresh fails, clear tokens
+            this.clearToken();
+        }
+    }
+    getTokenExpiry(token) {
+        try {
+            // Simple JWT parsing (payload is the middle part between dots)
+            const parts = token.split(".");
+            if (parts.length !== 3)
+                return null;
+            // Base64 decode the payload
+            // We need to fix the base64 padding for the browser's atob function
+            const base64 = parts[1].replace(/-/g, "+").replace(/_/g, "/");
+            const padded = base64.padEnd(base64.length + ((4 - (base64.length % 4)) % 4), "=");
+            // In Node.js
+            let jsonStr;
+            if (typeof Buffer !== "undefined") {
+                jsonStr = Buffer.from(padded, "base64").toString();
+            }
+            // In browser
+            else if (typeof atob !== "undefined") {
+                jsonStr = atob(padded);
+            }
+            // Fallback
+            else {
+                return null;
+            }
+            const payload = JSON.parse(jsonStr);
+            return payload.exp;
+        }
+        catch (error) {
+            console.error("Error parsing JWT token:", error);
+            return null;
+        }
+    }
+    /**
+     * Get an anonymous user token
+     *
+     * @param options - Options for anonymous authentication
+     * @returns Promise with user info and tokens
+     */
+    async getAnonymousToken(options) {
+        return this.executeWithTokenRefresh(async () => {
+            // If apiKey is provided in options, temporarily set it for this request only
+            const tempApiKey = options?.apiKey;
+            const hadExistingApiKey = !!this.config.apiKey;
+            const originalApiKey = this.config.apiKey;
+            try {
+                // Set temporary API key if provided
+                if (tempApiKey) {
+                    this.setApiKey(tempApiKey);
+                }
+                // Check if we have an API key set (either from constructor or from options)
+                if (!this.config.apiKey) {
+                    throw new Error("X-Api-Key is required for anonymous authentication");
+                }
+                const { data, error } = await this.client.POST("/auth/anonymous");
+                if (error) {
+                    this.handleError(error);
+                }
+                if (data?.content?.access_token && data?.content?.refresh_token) {
+                    this.setToken(data.content.access_token);
+                    this.setRefreshToken(data.content.refresh_token);
+                }
+                return data?.content;
+            }
+            finally {
+                // Restore the original API key state if we used a temporary one
+                if (tempApiKey) {
+                    if (hadExistingApiKey && originalApiKey) {
+                        this.setApiKey(originalApiKey);
+                    }
+                    else {
+                        this.clearApiKey();
+                    }
+                }
+            }
+        });
+    }
+    /**
+     * Login with phone number
+     *
+     * @param phoneNumber - Phone number (without country code)
+     * @param countryCode - Country code (defaults to +91)
+     * @param registerIfNotExists - Whether to register if user doesn't exist
+     * @returns Promise with OTP token and action
+     */
+    async loginWithPhone(phoneNumber, countryCode = "+91", registerIfNotExists = false) {
+        return this.executeWithTokenRefresh(async () => {
+            const { data, error } = await this.client.POST("/auth/login/phone", {
+                body: {
+                    phone: phoneNumber,
+                    country_code: countryCode,
+                    register_if_not_exists: registerIfNotExists,
+                },
+            });
+            if (error) {
+                this.handleError(error);
+            }
+            return data?.content;
+        });
+    }
+    /**
+     * Login with email
+     *
+     * @param email - Email address
+     * @param registerIfNotExists - Whether to register if user doesn't exist
+     * @returns Promise with OTP token and action
+     */
+    async loginWithEmail(email, registerIfNotExists = false) {
+        return this.executeWithTokenRefresh(async () => {
+            const { data, error } = await this.client.POST("/auth/login/email", {
+                body: {
+                    email,
+                    register_if_not_exists: registerIfNotExists,
+                },
+            });
+            if (error) {
+                this.handleError(error);
+            }
+            return data?.content;
+        });
+    }
+    /**
+     * Login with password
+     *
+     * @param options - Login credentials
+     * @returns Promise with user info and tokens
+     */
+    async loginWithPassword(options) {
+        return this.executeWithTokenRefresh(async () => {
+            const { data, error } = await this.client.POST("/auth/login/password", {
+                body: options,
+            });
+            if (error) {
+                this.handleError(error);
+            }
+            if (data?.content?.access_token && data?.content?.refresh_token) {
+                this.setToken(data.content.access_token);
+                this.setRefreshToken(data.content.refresh_token);
+            }
+            return data?.content;
+        });
+    }
+    /**
+     * Verify OTP
+     *
+     * @param otp - One-time password
+     * @param otpToken - OTP token from login request
+     * @param otpAction - OTP action from login request
+     * @returns Promise with user info and tokens
+     */
+    async verifyOtp(otp, otpToken, otpAction) {
+        return this.executeWithTokenRefresh(async () => {
+            const { data, error } = await this.client.POST("/auth/verify-otp", {
+                body: {
+                    otp,
+                    otp_token: otpToken,
+                    otp_action: otpAction,
+                },
+            });
+            if (error) {
+                this.handleError(error);
+            }
+            if (data?.content?.access_token && data?.content?.refresh_token) {
+                this.setToken(data.content.access_token);
+                this.setRefreshToken(data.content.refresh_token);
+            }
+            return data?.content;
+        });
+    }
+    /**
+     * Register with phone
+     *
+     * @param options - Registration details
+     * @returns Promise with user info and tokens
+     */
+    async registerWithPhone(options) {
+        return this.executeWithTokenRefresh(async () => {
+            const { data, error } = await this.client.POST("/auth/register/phone", {
+                body: {
+                    ...options,
+                    country_code: options.country_code,
+                },
+            });
+            if (error) {
+                this.handleError(error);
+            }
+            if (data?.content?.access_token && data?.content?.refresh_token) {
+                this.setToken(data.content.access_token);
+                this.setRefreshToken(data.content.refresh_token);
+            }
+            return data?.content;
+        });
+    }
+    /**
+     * Register with email
+     *
+     * @param options - Registration details
+     * @returns Promise with user info and tokens
+     */
+    async registerWithEmail(options) {
+        return this.executeWithTokenRefresh(async () => {
+            const { data, error } = await this.client.POST("/auth/register/email", {
+                body: options,
+            });
+            if (error) {
+                this.handleError(error);
+            }
+            if (data?.content?.access_token && data?.content?.refresh_token) {
+                this.setToken(data.content.access_token);
+                this.setRefreshToken(data.content.refresh_token);
+            }
+            return data?.content;
+        });
+    }
+    /**
+     * Refresh token
+     *
+     * @param refreshToken - Refresh token
+     * @returns Promise with new tokens
+     */
+    async refreshToken(refreshToken) {
+        // Don't use executeWithTokenRefresh here to avoid infinite loop
+        const { data, error } = await this.client.POST("/auth/refresh-token", {
+            body: {
+                refresh_token: refreshToken,
+            },
+        });
+        if (error) {
+            this.handleError(error);
+        }
+        if (data?.content?.access_token && data?.content?.refresh_token) {
+            this.setToken(data.content.access_token);
+            this.setRefreshToken(data.content.refresh_token);
+        }
+        return data?.content;
+    }
+    /**
+     * Logout
+     *
+     * @returns Promise that resolves when logout is complete
+     */
+    async logout() {
+        return this.executeWithTokenRefresh(async () => {
+            const { error } = await this.client.POST("/auth/logout");
+            if (error) {
+                this.handleError(error);
+            }
+            this.clearToken();
+        });
+    }
+    /**
+     * Override the base client's attemptTokenRefresh method
+     * to implement token refresh for 401 errors
+     *
+     * @returns Promise that resolves to true if token was refreshed, false otherwise
+     */
+    async attemptTokenRefresh() {
+        const refreshToken = this.tokenStorage.getRefreshToken();
+        if (!refreshToken)
+            return false;
+        try {
+            const tokens = await this.refreshToken(refreshToken);
+            if (tokens.access_token) {
+                this.setToken(tokens.access_token);
+            }
+            if (tokens.refresh_token) {
+                this.setRefreshToken(tokens.refresh_token);
+            }
+            return true;
+        }
+        catch (error) {
+            // If refresh fails, clear tokens
+            this.clearToken();
+            return false;
+        }
+    }
+    /**
+     * Execute a request with automatic token refresh handling
+     * This wraps any API call in logic that will catch authentication errors,
+     * attempt to refresh the token, and retry the request once
+     *
+     * @param requestFn - Function that executes the API request
+     * @returns Promise with the API response
+     */
+    async executeWithTokenRefresh(requestFn) {
+        try {
+            // Attempt the request
+            return await requestFn();
+        }
+        catch (error) {
+            // If error message indicates token was refreshed, retry the request
+            if (error instanceof Error &&
+                error.message === "Token refreshed, please retry the request") {
+                return await requestFn();
+            }
+            // Otherwise, re-throw the error
+            throw error;
+        }
+    }
+}
+exports.AuthClient = AuthClient;
+/**
+ * Default in-memory implementation of token storage
+ */
+class MemoryTokenStorage {
+    constructor() {
+        this.accessToken = null;
+        this.refreshToken = null;
+    }
+    getAccessToken() {
+        return this.accessToken;
+    }
+    setAccessToken(token) {
+        this.accessToken = token;
+    }
+    getRefreshToken() {
+        return this.refreshToken;
+    }
+    setRefreshToken(token) {
+        this.refreshToken = token;
+    }
+    clearTokens() {
+        this.accessToken = null;
+        this.refreshToken = null;
+    }
+}
+exports.MemoryTokenStorage = MemoryTokenStorage;
+/**
+ * Browser storage implementation using localStorage
+ */
+class BrowserTokenStorage {
+    constructor(prefix = "storefront_") {
+        this.accessTokenKey = `${prefix}access_token`;
+        this.refreshTokenKey = `${prefix}refresh_token`;
+    }
+    getAccessToken() {
+        if (typeof localStorage === "undefined")
+            return null;
+        return localStorage.getItem(this.accessTokenKey);
+    }
+    setAccessToken(token) {
+        if (typeof localStorage === "undefined")
+            return;
+        localStorage.setItem(this.accessTokenKey, token);
+    }
+    getRefreshToken() {
+        if (typeof localStorage === "undefined")
+            return null;
+        return localStorage.getItem(this.refreshTokenKey);
+    }
+    setRefreshToken(token) {
+        if (typeof localStorage === "undefined")
+            return;
+        localStorage.setItem(this.refreshTokenKey, token);
+    }
+    clearTokens() {
+        if (typeof localStorage === "undefined")
+            return;
+        localStorage.removeItem(this.accessTokenKey);
+        localStorage.removeItem(this.refreshTokenKey);
+    }
+}
+exports.BrowserTokenStorage = BrowserTokenStorage;
+/**
+ * Cookie-based token storage for browser or server environments
+ */
+class CookieTokenStorage {
+    constructor(prefix = "storefront_", cookieOptions = {
+        path: "/",
+        secure: true,
+        sameSite: "strict",
+        maxAge: 60 * 60 * 24 * 30, // 30 days
+    }) {
+        this.accessTokenKey = `${prefix}access_token`;
+        this.refreshTokenKey = `${prefix}refresh_token`;
+        this.cookieOptions = cookieOptions;
+    }
+    /**
+     * Get access token from cookies
+     * Works in both browser and Next.js server components
+     */
+    getAccessToken() {
+        // Browser environment
+        if (typeof document !== "undefined") {
+            return getCookieValue(this.accessTokenKey);
+        }
+        // Next.js server component - would need to be implemented by user
+        // with their specific cookie library
+        return null;
+    }
+    /**
+     * Set access token in cookies
+     * Works in browser environment
+     */
+    setAccessToken(token) {
+        // Browser environment
+        if (typeof document !== "undefined") {
+            setCookie(this.accessTokenKey, token, this.cookieOptions);
+        }
+        // Next.js - would need to be implemented by user
+        // with their specific cookie API
+    }
+    /**
+     * Get refresh token from cookies
+     * Works in both browser and Next.js server components
+     */
+    getRefreshToken() {
+        // Browser environment
+        if (typeof document !== "undefined") {
+            return getCookieValue(this.refreshTokenKey);
+        }
+        // Next.js server component - would need to be implemented by user
+        return null;
+    }
+    /**
+     * Set refresh token in cookies
+     * Works in browser environment
+     */
+    setRefreshToken(token) {
+        // Browser environment
+        if (typeof document !== "undefined") {
+            setCookie(this.refreshTokenKey, token, this.cookieOptions);
+        }
+        // Next.js - would need to be implemented by user
+    }
+    /**
+     * Clear all tokens from cookies
+     */
+    clearTokens() {
+        // Browser environment
+        if (typeof document !== "undefined") {
+            deleteCookie(this.accessTokenKey);
+            deleteCookie(this.refreshTokenKey);
+        }
+        // Next.js - would need to be implemented by user
+    }
+}
+exports.CookieTokenStorage = CookieTokenStorage;
+/**
+ * Helper function to get cookie value
+ */
+function getCookieValue(name) {
+    if (typeof document === "undefined")
+        return null;
+    const match = document.cookie.match(new RegExp("(^| )" + name + "=([^;]+)"));
+    return match ? decodeURIComponent(match[2]) : null;
+}
+/**
+ * Helper function to set cookie
+ */
+function setCookie(name, value, options = {}) {
+    if (typeof document === "undefined")
+        return;
+    const cookieOptions = {
+        path: "/",
+        ...options,
+    };
+    let cookie = `${name}=${encodeURIComponent(value)}`;
+    if (cookieOptions.maxAge) {
+        cookie += `; max-age=${cookieOptions.maxAge}`;
+    }
+    if (cookieOptions.domain) {
+        cookie += `; domain=${cookieOptions.domain}`;
+    }
+    if (cookieOptions.path) {
+        cookie += `; path=${cookieOptions.path}`;
+    }
+    if (cookieOptions.secure) {
+        cookie += "; secure";
+    }
+    if (cookieOptions.sameSite) {
+        cookie += `; samesite=${cookieOptions.sameSite}`;
+    }
+    document.cookie = cookie;
+}
+/**
+ * Helper function to delete cookie
+ */
+function deleteCookie(name, path = "/") {
+    if (typeof document === "undefined")
+        return;
+    document.cookie = `${name}=; path=${path}; expires=Thu, 01 Jan 1970 00:00:01 GMT`;
+}
+/**
+ * Next.js specific cookie storage implementation
+ * Works with the Next.js cookies API
+ */
+class NextCookieTokenStorage {
+    constructor(cookieStore, prefix = "storefront_") {
+        this.accessTokenKey = `${prefix}access_token`;
+        this.refreshTokenKey = `${prefix}refresh_token`;
+        this.cookieStore = cookieStore;
+    }
+    /**
+     * Get access token from Next.js cookies
+     */
+    getAccessToken() {
+        try {
+            // Assuming cookieStore.get method exists (like in next/headers)
+            const cookie = this.cookieStore.get(this.accessTokenKey);
+            return cookie ? cookie.value : null;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    /**
+     * Set access token in Next.js cookies
+     */
+    setAccessToken(token) {
+        try {
+            // Assuming cookieStore.set method exists
+            this.cookieStore.set(this.accessTokenKey, token, {
+                path: "/",
+                secure: process.env.NODE_ENV === "production",
+                httpOnly: true,
+                sameSite: "strict",
+                maxAge: 60 * 60 * 24 * 30, // 30 days
+            });
+        }
+        catch (error) {
+            // Silently fail - might be in an environment where cookies can't be set
+        }
+    }
+    /**
+     * Get refresh token from Next.js cookies
+     */
+    getRefreshToken() {
+        try {
+            // Assuming cookieStore.get method exists
+            const cookie = this.cookieStore.get(this.refreshTokenKey);
+            return cookie ? cookie.value : null;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    /**
+     * Set refresh token in Next.js cookies
+     */
+    setRefreshToken(token) {
+        try {
+            // Assuming cookieStore.set method exists
+            this.cookieStore.set(this.refreshTokenKey, token, {
+                path: "/",
+                secure: process.env.NODE_ENV === "production",
+                httpOnly: true,
+                sameSite: "strict",
+                maxAge: 60 * 60 * 24 * 30, // 30 days
+            });
+        }
+        catch (error) {
+            // Silently fail
+        }
+    }
+    /**
+     * Clear all tokens from Next.js cookies
+     */
+    clearTokens() {
+        try {
+            // Assuming cookieStore.delete method exists
+            this.cookieStore.delete(this.accessTokenKey);
+            this.cookieStore.delete(this.refreshTokenKey);
+        }
+        catch (error) {
+            // Silently fail
+        }
+    }
+}
+exports.NextCookieTokenStorage = NextCookieTokenStorage;
+/**
+ * Helper to create a token storage instance based on environment
+ * Automatically selects the best storage method based on context
+ */
+function createTokenStorage(options) {
+    const prefix = options?.prefix || "storefront_";
+    // Node.js environment without a cookieStore - use memory
+    if (typeof window === "undefined" && !options?.cookieStore) {
+        return new MemoryTokenStorage();
+    }
+    // Next.js server component with cookieStore
+    if (typeof window === "undefined" && options?.cookieStore) {
+        return new NextCookieTokenStorage(options.cookieStore, prefix);
+    }
+    // Browser environment - use localStorage by default unless cookies are specified
+    if (typeof window !== "undefined") {
+        if (options?.useLocalStorage === false) {
+            return new CookieTokenStorage(prefix);
+        }
+        return new BrowserTokenStorage(prefix);
+    }
+    // Fallback to memory storage
+    return new MemoryTokenStorage();
+}