@oxyhq/services 5.17.17 → 5.18.0

package/src/core/index.ts

@@ -9,6 +9,10 @@
 export { OxyServices, OxyAuthenticationError, OxyAuthenticationTimeoutError } from './OxyServices';
 export { OXY_CLOUD_URL, oxyClient } from './OxyServices';
 
+// Cross-domain authentication
+export { CrossDomainAuth, createCrossDomainAuth } from './CrossDomainAuth';
+export type { CrossDomainAuthOptions } from './CrossDomainAuth';
+
 // Re-export all models and types for convenience
 export * from '../models/interfaces';
 export * from '../models/session';
@@ -27,4 +31,8 @@ export {
 } from '../utils/languageUtils';
 export type { LanguageMetadata } from '../utils/languageUtils';
 
-// Default export removed (no longer providing backward compatibility default export)
+// Import for default export
+import { OxyServices } from './OxyServices';
+
+// Default export for backward compatibility
+export default OxyServices;

package/src/core/mixins/OxyServices.assets.ts

@@ -168,9 +168,20 @@ export function OxyServicesAssetsMixin<T extends typeof OxyServicesBase>(Base: T
       
       try {
         const formData = new FormData();
-        // In React Native, pass filename as third parameter to avoid read-only name property error
-        // This prevents "Cannot assign to property 'name' which has only a getter" error
-        formData.append('file', file as any, fileName);
+        // Convert File to Blob to avoid read-only 'name' property error in Expo 54
+        // This is a known issue in Expo SDK 52+ where FormData tries to set the read-only 'name' property
+        let fileBlob: Blob;
+        if (file instanceof Blob) {
+          // Already a Blob, use directly
+          fileBlob = file;
+        } else if (typeof (file as any).blob === 'function') {
+          // Use async blob() method if available (Expo 54+ recommended approach)
+          fileBlob = await (file as any).blob();
+        } else {
+          // Fallback: create Blob from File (works in all environments)
+          fileBlob = new Blob([file], { type: (file as any).type || 'application/octet-stream' });
+        }
+        formData.append('file', fileBlob, fileName);
         if (visibility) {
           formData.append('visibility', visibility);
         }

package/src/core/mixins/OxyServices.auth.ts

@@ -1,8 +1,7 @@
 /**
  * Authentication Methods Mixin
  * 
- * Public key authentication using ECDSA signatures.
- * No passwords required - authentication is done via challenge-response.
+ * Supports password-based login (email/username) and public key challenge-response.
  */
 import type { User } from '../../models/interfaces';
 import type { SessionLoginResponse } from '../../models/session';
@@ -14,6 +13,23 @@ export interface ChallengeResponse {
   expiresAt: string;
 }
 
+export interface RegistrationRequest {
+  publicKey: string;
+  username: string;
+  email?: string;
+  signature: string;
+  timestamp: number;
+}
+
+export interface ChallengeVerifyRequest {
+  publicKey: string;
+  challenge: string;
+  signature: string;
+  timestamp: number;
+  deviceName?: string;
+  deviceFingerprint?: string;
+}
+
 export interface PublicKeyCheckResponse {
   registered: boolean;
   message: string;
@@ -26,21 +42,26 @@ export function OxyServicesAuthMixin<T extends typeof OxyServicesBase>(Base: T)
     }
 
     /**
-     * Register a new identity (bootstrap - no session required)
-     * 
-     * Register a new identity (public key only).
-     * Profile data should be synced separately via updateProfile after sign-in.
+     * Register a new identity with public key authentication
+     * Identity is purely cryptographic - username and profile data are optional
      * 
      * @param publicKey - The user's ECDSA public key (hex)
-     * @returns Object containing userId and user data
+     * @param signature - Signature of the registration request
+     * @param timestamp - Timestamp when the signature was created
      */
-    async registerIdentity(publicKey: string): Promise<{ userId: string; user: User }> {
+    async register(
+      publicKey: string,
+      signature: string,
+      timestamp: number
+    ): Promise<{ message: string; user: User }> {
       try {
-        const res = await this.makeRequest<{ userId: string; user: User }>('POST', '/api/identity/register', {
+        const res = await this.makeRequest<{ message: string; user: User }>('POST', '/api/auth/register', {
           publicKey,
+          signature,
+          timestamp,
         }, { cache: false });
 
-        if (!res || !res.userId) {
+        if (!res || (typeof res === 'object' && Object.keys(res).length === 0)) {
           throw new OxyAuthenticationError('Registration failed', 'REGISTER_FAILED', 400);
         }
 
@@ -54,12 +75,12 @@ export function OxyServicesAuthMixin<T extends typeof OxyServicesBase>(Base: T)
      * Request an authentication challenge
      * The client must sign this challenge with their private key
      * 
-     * @param userId - The user's ID (ObjectId)
+     * @param publicKey - The user's public key
      */
-    async requestChallenge(userId: string): Promise<ChallengeResponse> {
+    async requestChallenge(publicKey: string): Promise<ChallengeResponse> {
       try {
         return await this.makeRequest<ChallengeResponse>('POST', '/api/auth/challenge', {
-          userId,
+          publicKey,
         }, { cache: false });
       } catch (error) {
         throw this.handleError(error);
@@ -69,16 +90,16 @@ export function OxyServicesAuthMixin<T extends typeof OxyServicesBase>(Base: T)
     /**
      * Verify a signed challenge and create a session
      * 
-     * @param userId - The user's ID (ObjectId)
-     * @param nonce - The nonce (challenge) string from requestChallenge
+     * @param publicKey - The user's public key
+     * @param challenge - The challenge string from requestChallenge
      * @param signature - Signature of the auth message
      * @param timestamp - Timestamp when the signature was created
      * @param deviceName - Optional device name
      * @param deviceFingerprint - Optional device fingerprint
      */
     async verifyChallenge(
-      userId: string,
-      nonce: string,
+      publicKey: string,
+      challenge: string,
       signature: string,
       timestamp: number,
       deviceName?: string,
@@ -86,8 +107,8 @@ export function OxyServicesAuthMixin<T extends typeof OxyServicesBase>(Base: T)
     ): Promise<SessionLoginResponse> {
       try {
         return await this.makeRequest<SessionLoginResponse>('POST', '/api/auth/verify', {
-          userId,
-          nonce,
+          publicKey,
+          challenge,
           signature,
           timestamp,
           deviceName,
@@ -116,7 +137,6 @@ export function OxyServicesAuthMixin<T extends typeof OxyServicesBase>(Base: T)
 
     /**
      * Get user by public key
-     * Services never caches profile - always fetch fresh from backend
      */
     async getUserByPublicKey(publicKey: string): Promise<User> {
       try {
@@ -124,7 +144,7 @@ export function OxyServicesAuthMixin<T extends typeof OxyServicesBase>(Base: T)
           'GET',
           `/api/auth/user/${encodeURIComponent(publicKey)}`,
           undefined,
-          { cache: false } // Services never caches profile - only tokens
+          { cache: true, cacheTTL: 2 * 60 * 1000 }
         );
       } catch (error) {
         throw this.handleError(error);
@@ -133,12 +153,12 @@ export function OxyServicesAuthMixin<T extends typeof OxyServicesBase>(Base: T)
 
     /**
      * Get user by session ID
-     * Services never caches profile - always fetch fresh from backend
      */
     async getUserBySession(sessionId: string): Promise<User> {
       try {
         return await this.makeRequest<User>('GET', `/api/session/user/${sessionId}`, undefined, {
-          cache: false, // Services never caches profile - only tokens
+          cache: true,
+          cacheTTL: 2 * 60 * 1000,
         });
       } catch (error) {
         throw this.handleError(error);
@@ -161,7 +181,8 @@ export function OxyServicesAuthMixin<T extends typeof OxyServicesBase>(Base: T)
           '/api/session/users/batch',
           { sessionIds: uniqueSessionIds },
           {
-            cache: false,
+            cache: true,
+            cacheTTL: 2 * 60 * 1000,
             deduplicate: true,
           }
         );
@@ -173,23 +194,16 @@ export function OxyServicesAuthMixin<T extends typeof OxyServicesBase>(Base: T)
     /**
      * Get access token by session ID
      */
-    async getTokenBySession(
-      sessionId: string,
-      deviceId?: string
-    ): Promise<{ accessToken: string; refreshToken: string; expiresAt: string; sessionId: string; deviceId: string }> {
+    async getTokenBySession(sessionId: string): Promise<{ accessToken: string; expiresAt: string }> {
       try {
-        const res = await this.makeRequest<{ accessToken: string; refreshToken: string; expiresAt: string; sessionId: string; deviceId: string }>(
+        const res = await this.makeRequest<{ accessToken: string; expiresAt: string }>(
           'GET',
           `/api/session/token/${sessionId}`,
           undefined,
-          { 
-            cache: false, 
-            retry: false,
-            headers: deviceId ? { 'x-device-id': deviceId } : undefined,
-          }
+          { cache: false, retry: false }
         );
-
-        this.setTokens(res.accessToken, res.refreshToken);
+        
+        this.setTokens(res.accessToken);
         
         return res;
       } catch (error) {
@@ -285,5 +299,60 @@ export function OxyServicesAuthMixin<T extends typeof OxyServicesBase>(Base: T)
       }
     }
 
+    /**
+     * Register a new user with email/username and password
+     */
+    async signUp(
+      username: string,
+      email: string,
+      password: string,
+      deviceName?: string,
+      deviceFingerprint?: any
+    ): Promise<SessionLoginResponse> {
+      try {
+        return await this.makeRequest<SessionLoginResponse>('POST', '/api/auth/signup', {
+          username,
+          email,
+          password,
+          deviceName,
+          deviceFingerprint,
+        }, { cache: false });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Sign in with email or username and password
+     */
+    async signIn(
+      identifier: string,
+      password: string,
+      deviceName?: string,
+      deviceFingerprint?: any
+    ): Promise<SessionLoginResponse> {
+      try {
+        return await this.makeRequest<SessionLoginResponse>('POST', '/api/auth/login', {
+          identifier,
+          password,
+          deviceName,
+          deviceFingerprint,
+        }, { cache: false });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Convenience helper for email sign-in
+     */
+    async signInWithEmail(
+      email: string,
+      password: string,
+      deviceName?: string,
+      deviceFingerprint?: any
+    ): Promise<SessionLoginResponse> {
+      return this.signIn(email, password, deviceName, deviceFingerprint);
+    }
   };
 }