@passkeyme/auth 2.0.0 → 2.0.2

package/dist/index.js

@@ -323,7 +323,7 @@ class PasskeymeApiClient {
      * Get authentication configuration for the app
      */
     async getConfig() {
-        const backendConfig = await this.request(`${this.baseUrl}/api/auth/${this.appId}/config`);
+        const backendConfig = await this.request(`/api/auth/${this.appId}/config`);
         // Map backend response to SDK format
         return {
             appId: backendConfig.app_id,
@@ -399,7 +399,7 @@ class PasskeymeApiClient {
             token: token,
             app_id: this.appId,
         });
-        const response = (await this.request(`${this.baseUrl}/api/auth/verify-token?${params.toString()}`, {
+        const response = (await this.request(`/api/auth/verify-token?${params.toString()}`, {
             method: "GET",
         }));
         if (!response.valid) {
@@ -453,6 +453,179 @@ class PasskeymeApiClient {
     }
 }
 
+/**
+ * Platform SDK Interface for Passkeyme
+ *
+ * This interface abstracts platform-specific passkey operations,
+ * allowing the core SDK to work across web, React Native, and other platforms.
+ */
+/**
+ * No-op implementation for platforms without passkey support
+ */
+class NoOpPasskeySDK {
+    async register(_options) {
+        return {
+            success: false,
+            error: "Passkeys not supported on this platform",
+        };
+    }
+    async authenticate(_options) {
+        return {
+            success: false,
+            error: "Passkeys not supported on this platform",
+        };
+    }
+    isSupported() {
+        return false;
+    }
+    canUseDiscoverableCredentials() {
+        return false;
+    }
+    supportsBiometrics() {
+        return false;
+    }
+}
+
+/**
+ * Web Platform SDK Implementation
+ *
+ * Wraps the passkeyme-web-sdk to implement the PasskeySDK interface
+ */
+/**
+ * Web implementation of PasskeySDK using passkeyme-web-sdk
+ *
+ * This implementation should be used for web browsers that support WebAuthn.
+ * The actual passkeyme-web-sdk dependency should be provided by the consuming package.
+ */
+class WebPasskeySDK {
+    constructor(webSDK) {
+        this.webSDK = webSDK;
+    }
+    async register(options) {
+        try {
+            if (!this.webSDK) {
+                return {
+                    success: false,
+                    error: "Web SDK not available",
+                };
+            }
+            // Extract the challenge from the options
+            // The options object contains: { username, displayName, challenge, ...otherChallengeData }
+            const { username, displayName, challenge, ...otherData } = options;
+            // Pass the challenge data directly to the web SDK
+            const challengeData = challenge || otherData;
+            // Call the web SDK register method with the challenge
+            const result = await this.webSDK.passkeyRegister(challengeData);
+            return {
+                success: true,
+                credentialId: result.credentialId || result.id,
+                data: result,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message || "Registration failed",
+            };
+        }
+    }
+    async authenticate(options) {
+        try {
+            if (!this.webSDK) {
+                return {
+                    success: false,
+                    error: "Web SDK not available",
+                };
+            }
+            // Extract the challenge from the options
+            // The options object contains: { username, challenge, ...otherChallengeData }
+            const { username, challenge, ...otherData } = options;
+            // Pass the challenge data directly to the web SDK
+            const challengeData = challenge || otherData;
+            // Call the web SDK authenticate method with the challenge
+            const result = await this.webSDK.passkeyAuthenticate(challengeData);
+            return {
+                success: true,
+                assertion: result,
+                data: result,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message || "Authentication failed",
+            };
+        }
+    }
+    isSupported() {
+        // Check if we're in a browser environment with WebAuthn support
+        return (typeof window !== "undefined" &&
+            typeof navigator !== "undefined" &&
+            "credentials" in navigator &&
+            typeof navigator.credentials.create === "function");
+    }
+    async getAvailableAuthenticators() {
+        // This is a basic implementation - the web SDK might provide more detailed info
+        const authenticators = [];
+        if (this.isSupported()) {
+            // Basic platform authenticator info
+            authenticators.push({
+                type: "platform",
+                supportsBiometrics: true, // Assume platform authenticators support biometrics
+                supportsUserVerification: true,
+            });
+            // Basic cross-platform authenticator info
+            authenticators.push({
+                type: "cross-platform",
+                supportsBiometrics: false,
+                supportsUserVerification: true,
+            });
+        }
+        return authenticators;
+    }
+    canUseDiscoverableCredentials() {
+        // Check if the platform supports discoverable credentials (resident keys)
+        return this.isSupported();
+    }
+    supportsBiometrics() {
+        // On web, this depends on the platform authenticator availability
+        // This is a simplified check - a more sophisticated implementation
+        // would actually test for platform authenticator support
+        return (this.isSupported() &&
+            typeof window !== "undefined" &&
+            /Mac|Win|Linux/.test(navigator.platform));
+    }
+    async initialize(config) {
+        // Initialize the web SDK if it has an init method
+        if (this.webSDK && typeof this.webSDK.init === "function") {
+            await this.webSDK.init(config);
+        }
+    }
+    async cleanup() {
+        // Cleanup if the web SDK has a cleanup method
+        if (this.webSDK && typeof this.webSDK.cleanup === "function") {
+            await this.webSDK.cleanup();
+        }
+    }
+}
+
+/**
+ * Platform SDK exports
+ */
+// Conditionally export React Native SDK only in React Native environments
+exports.ReactNativePasskeySDK = null;
+try {
+    // Only try to load React Native SDK if we're actually in a React Native environment
+    if (typeof navigator !== "undefined" && navigator.product === "ReactNative") {
+        const { ReactNativePasskeySDK: RNPasskeySDK, } = require("./ReactNativePasskeySDK");
+        exports.ReactNativePasskeySDK = RNPasskeySDK;
+    }
+}
+catch (error) {
+    // React Native SDK not available or not in React Native environment
+    exports.ReactNativePasskeySDK = null;
+}
+
 /**
  * Browser storage implementation using localStorage or sessionStorage
  */
@@ -629,179 +802,6 @@ TokenStorage.REFRESH_TOKEN_KEY = "passkeyme_refresh_token";
 TokenStorage.EXPIRES_AT_KEY = "passkeyme_expires_at";
 TokenStorage.TOKEN_TYPE_KEY = "passkeyme_token_type";
 
-/**
- * Platform SDK Interface for Passkeyme
- *
- * This interface abstracts platform-specific passkey operations,
- * allowing the core SDK to work across web, React Native, and other platforms.
- */
-/**
- * No-op implementation for platforms without passkey support
- */
-class NoOpPasskeySDK {
-    async register(_options) {
-        return {
-            success: false,
-            error: "Passkeys not supported on this platform",
-        };
-    }
-    async authenticate(_options) {
-        return {
-            success: false,
-            error: "Passkeys not supported on this platform",
-        };
-    }
-    isSupported() {
-        return false;
-    }
-    canUseDiscoverableCredentials() {
-        return false;
-    }
-    supportsBiometrics() {
-        return false;
-    }
-}
-
-/**
- * Web Platform SDK Implementation
- *
- * Wraps the passkeyme-web-sdk to implement the PasskeySDK interface
- */
-/**
- * Web implementation of PasskeySDK using passkeyme-web-sdk
- *
- * This implementation should be used for web browsers that support WebAuthn.
- * The actual passkeyme-web-sdk dependency should be provided by the consuming package.
- */
-class WebPasskeySDK {
-    constructor(webSDK) {
-        this.webSDK = webSDK;
-    }
-    async register(options) {
-        try {
-            if (!this.webSDK) {
-                return {
-                    success: false,
-                    error: "Web SDK not available",
-                };
-            }
-            // Extract the challenge from the options
-            // The options object contains: { username, displayName, challenge, ...otherChallengeData }
-            const { username, displayName, challenge, ...otherData } = options;
-            // Pass the challenge data directly to the web SDK
-            const challengeData = challenge || otherData;
-            // Call the web SDK register method with the challenge
-            const result = await this.webSDK.passkeyRegister(challengeData);
-            return {
-                success: true,
-                credentialId: result.credentialId || result.id,
-                data: result,
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error.message || "Registration failed",
-            };
-        }
-    }
-    async authenticate(options) {
-        try {
-            if (!this.webSDK) {
-                return {
-                    success: false,
-                    error: "Web SDK not available",
-                };
-            }
-            // Extract the challenge from the options
-            // The options object contains: { username, challenge, ...otherChallengeData }
-            const { username, challenge, ...otherData } = options;
-            // Pass the challenge data directly to the web SDK
-            const challengeData = challenge || otherData;
-            // Call the web SDK authenticate method with the challenge
-            const result = await this.webSDK.passkeyAuthenticate(challengeData);
-            return {
-                success: true,
-                assertion: result,
-                data: result,
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error.message || "Authentication failed",
-            };
-        }
-    }
-    isSupported() {
-        // Check if we're in a browser environment with WebAuthn support
-        return (typeof window !== "undefined" &&
-            typeof navigator !== "undefined" &&
-            "credentials" in navigator &&
-            typeof navigator.credentials.create === "function");
-    }
-    async getAvailableAuthenticators() {
-        // This is a basic implementation - the web SDK might provide more detailed info
-        const authenticators = [];
-        if (this.isSupported()) {
-            // Basic platform authenticator info
-            authenticators.push({
-                type: "platform",
-                supportsBiometrics: true, // Assume platform authenticators support biometrics
-                supportsUserVerification: true,
-            });
-            // Basic cross-platform authenticator info
-            authenticators.push({
-                type: "cross-platform",
-                supportsBiometrics: false,
-                supportsUserVerification: true,
-            });
-        }
-        return authenticators;
-    }
-    canUseDiscoverableCredentials() {
-        // Check if the platform supports discoverable credentials (resident keys)
-        return this.isSupported();
-    }
-    supportsBiometrics() {
-        // On web, this depends on the platform authenticator availability
-        // This is a simplified check - a more sophisticated implementation
-        // would actually test for platform authenticator support
-        return (this.isSupported() &&
-            typeof window !== "undefined" &&
-            /Mac|Win|Linux/.test(navigator.platform));
-    }
-    async initialize(config) {
-        // Initialize the web SDK if it has an init method
-        if (this.webSDK && typeof this.webSDK.init === "function") {
-            await this.webSDK.init(config);
-        }
-    }
-    async cleanup() {
-        // Cleanup if the web SDK has a cleanup method
-        if (this.webSDK && typeof this.webSDK.cleanup === "function") {
-            await this.webSDK.cleanup();
-        }
-    }
-}
-
-/**
- * Platform SDK exports
- */
-// Conditionally export React Native SDK only in React Native environments
-exports.ReactNativePasskeySDK = null;
-try {
-    // Only try to load React Native SDK if we're actually in a React Native environment
-    if (typeof navigator !== "undefined" && navigator.product === "ReactNative") {
-        const { ReactNativePasskeySDK: RNPasskeySDK, } = require("./ReactNativePasskeySDK");
-        exports.ReactNativePasskeySDK = RNPasskeySDK;
-    }
-}
-catch (error) {
-    // React Native SDK not available or not in React Native environment
-    exports.ReactNativePasskeySDK = null;
-}
-
 /**
  * Main Passkeyme Authentication SDK class
  */
@@ -822,7 +822,7 @@ class PasskeymeAuth {
             ? `${window.location.origin}/auth/callback`
             : "http://localhost:3000/auth/callback";
         // Support both baseUrl and apiUrl for flexibility
-        const serverUrl = config.apiUrl || config.baseUrl || "https://auth.passkeyme.com";
+        const serverUrl = config.baseUrl || "https://auth.passkeyme.com";
         this.config = {
             appId: config.appId,
             baseUrl: serverUrl,