@oxyhq/services 5.13.15 → 5.13.17

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

@@ -0,0 +1,127 @@
+/**
+ * Language Methods Mixin
+ */
+import { normalizeLanguageCode, getLanguageMetadata, getLanguageName, getNativeLanguageName } from '../../utils/languageUtils';
+import type { LanguageMetadata } from '../../utils/languageUtils';
+import type { OxyServicesBase } from '../OxyServices.base';
+
+export function OxyServicesLanguageMixin<T extends typeof OxyServicesBase>(Base: T) {
+  return class extends Base {
+    constructor(...args: any[]) {
+      super(...(args as [any]));
+    }
+    /**
+     * Get appropriate storage for the platform (similar to DeviceManager)
+     */
+    public async getStorage(): Promise<{
+      getItem: (key: string) => Promise<string | null>;
+      setItem: (key: string, value: string) => Promise<void>;
+      removeItem: (key: string) => Promise<void>;
+    }> {
+      const isReactNative = typeof navigator !== 'undefined' && navigator.product === 'ReactNative';
+      
+      if (isReactNative) {
+        try {
+          const asyncStorageModule = await import('@react-native-async-storage/async-storage');
+          const storage = (asyncStorageModule.default as unknown) as import('@react-native-async-storage/async-storage').AsyncStorageStatic;
+          return {
+            getItem: storage.getItem.bind(storage),
+            setItem: storage.setItem.bind(storage),
+            removeItem: storage.removeItem.bind(storage),
+          };
+        } catch (error) {
+          console.error('AsyncStorage not available in React Native:', error);
+          throw new Error('AsyncStorage is required in React Native environment');
+        }
+      } else {
+        // Use localStorage for web
+        return {
+          getItem: async (key: string) => {
+            if (typeof window !== 'undefined' && window.localStorage) {
+              return localStorage.getItem(key);
+            }
+            return null;
+          },
+          setItem: async (key: string, value: string) => {
+            if (typeof window !== 'undefined' && window.localStorage) {
+              localStorage.setItem(key, value);
+            }
+          },
+          removeItem: async (key: string) => {
+            if (typeof window !== 'undefined' && window.localStorage) {
+              localStorage.removeItem(key);
+            }
+          }
+        };
+      }
+    }
+
+    /**
+     * Get the current language from storage or user profile
+     * @param storageKeyPrefix - Optional prefix for storage key (default: 'oxy_session')
+     * @returns The current language code (e.g., 'en-US') or null if not set
+     */
+    async getCurrentLanguage(storageKeyPrefix: string = 'oxy_session'): Promise<string | null> {
+      try {
+        // First try to get from user profile if authenticated
+        try {
+          const user = await (this as any).getCurrentUser();
+          const userLanguage = (user as Record<string, unknown>)?.language as string | undefined;
+          if (userLanguage) {
+            return normalizeLanguageCode(userLanguage) || userLanguage;
+          }
+        } catch (e) {
+          // User not authenticated or error, continue to storage
+        }
+
+        // Fall back to storage
+        const storage = await this.getStorage();
+        const storageKey = `${storageKeyPrefix}_language`;
+        const storedLanguage = await storage.getItem(storageKey);
+        if (storedLanguage) {
+          return normalizeLanguageCode(storedLanguage) || storedLanguage;
+        }
+
+        return null;
+      } catch (error) {
+        if (__DEV__) {
+          console.warn('Failed to get current language:', error);
+        }
+        return null;
+      }
+    }
+
+    /**
+     * Get the current language with metadata (name, nativeName, etc.)
+     * @param storageKeyPrefix - Optional prefix for storage key (default: 'oxy_session')
+     * @returns Language metadata object or null if not set
+     */
+    async getCurrentLanguageMetadata(storageKeyPrefix: string = 'oxy_session'): Promise<LanguageMetadata | null> {
+      const languageCode = await this.getCurrentLanguage(storageKeyPrefix);
+      return getLanguageMetadata(languageCode);
+    }
+
+    /**
+     * Get the current language name (e.g., 'English')
+     * @param storageKeyPrefix - Optional prefix for storage key (default: 'oxy_session')
+     * @returns Language name or null if not set
+     */
+    async getCurrentLanguageName(storageKeyPrefix: string = 'oxy_session'): Promise<string | null> {
+      const languageCode = await this.getCurrentLanguage(storageKeyPrefix);
+      if (!languageCode) return null;
+      return getLanguageName(languageCode);
+    }
+
+    /**
+     * Get the current native language name (e.g., 'Español')
+     * @param storageKeyPrefix - Optional prefix for storage key (default: 'oxy_session')
+     * @returns Native language name or null if not set
+     */
+    async getCurrentNativeLanguageName(storageKeyPrefix: string = 'oxy_session'): Promise<string | null> {
+      const languageCode = await this.getCurrentLanguage(storageKeyPrefix);
+      if (!languageCode) return null;
+      return getNativeLanguageName(languageCode);
+    }
+  };
+}
+

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

@@ -0,0 +1,46 @@
+/**
+ * Location Methods Mixin
+ */
+import type { OxyServicesBase } from '../OxyServices.base';
+
+export function OxyServicesLocationMixin<T extends typeof OxyServicesBase>(Base: T) {
+  return class extends Base {
+    constructor(...args: any[]) {
+      super(...(args as [any]));
+    }
+
+    /**
+     * Update user location
+     * @param latitude - Latitude coordinate
+     * @param longitude - Longitude coordinate
+     * @returns Location update result
+     */
+    async updateLocation(latitude: number, longitude: number): Promise<any> {
+      try {
+        return await this.makeRequest('POST', '/api/location', {
+          latitude,
+          longitude
+        }, { cache: false });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Get nearby users
+     * @param radius - Optional search radius in meters
+     * @returns Array of nearby users
+     */
+    async getNearbyUsers(radius?: number): Promise<any[]> {
+      try {
+        const params: any = radius ? { radius } : undefined;
+        return await this.makeRequest('GET', '/api/location/nearby', params, {
+          cache: false, // Don't cache location data - always get fresh data
+        });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+  };
+}
+

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

@@ -0,0 +1,59 @@
+/**
+ * Payment Methods Mixin
+ * 
+ * Provides methods for payment processing and management
+ */
+import type { OxyServicesBase } from '../OxyServices.base';
+import { CACHE_TIMES } from './mixinHelpers';
+
+export function OxyServicesPaymentMixin<T extends typeof OxyServicesBase>(Base: T) {
+  return class extends Base {
+    constructor(...args: any[]) {
+      super(...(args as [any]));
+    }
+
+    /**
+     * Create a payment
+     * @param data - Payment data
+     * @returns Created payment object
+     */
+    async createPayment(data: any): Promise<any> {
+      try {
+        return await this.makeRequest('POST', '/api/payments', data, { cache: false });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Get payment by ID
+     * @param paymentId - The payment ID
+     * @returns Payment object
+     */
+    async getPayment(paymentId: string): Promise<any> {
+      try {
+        return await this.makeRequest('GET', `/api/payments/${paymentId}`, undefined, {
+          cache: true,
+          cacheTTL: CACHE_TIMES.LONG,
+        });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Get user payments
+     * @returns Array of user payments
+     */
+    async getUserPayments(): Promise<any[]> {
+      try {
+        return await this.makeRequest('GET', '/api/payments/user', undefined, {
+          cache: false, // Don't cache user payments - always get fresh data
+        });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+  };
+}
+

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

@@ -0,0 +1,182 @@
+/**
+ * Privacy Methods Mixin (Blocked & Restricted Users)
+ */
+import type { BlockedUser, RestrictedUser } from '../../models/interfaces';
+import type { OxyServicesBase } from '../OxyServices.base';
+
+export function OxyServicesPrivacyMixin<T extends typeof OxyServicesBase>(Base: T) {
+  return class extends Base {
+    constructor(...args: any[]) {
+      super(...(args as [any]));
+    }
+    /**
+     * Extract user ID from blocked/restricted user object
+     */
+    public extractUserId(userIdField: string | { _id: string; username?: string; avatar?: string }): string {
+      return typeof userIdField === 'string' ? userIdField : userIdField._id;
+    }
+
+    /**
+     * Check if a user is in a list (blocked or restricted)
+     */
+    public async isUserInList<T extends BlockedUser | RestrictedUser>(
+      userId: string,
+      getUserList: () => Promise<T[]>,
+      getIdField: (item: T) => string | { _id: string; username?: string; avatar?: string }
+    ): Promise<boolean> {
+      try {
+        if (!userId) {
+          return false;
+        }
+        const users = await getUserList();
+        return users.some(item => {
+          const itemId = this.extractUserId(getIdField(item));
+          return itemId === userId;
+        });
+      } catch (error) {
+        // If there's an error, assume not in list to avoid breaking functionality
+        if (__DEV__) {
+          console.warn('Error checking user list:', error);
+        }
+        return false;
+      }
+    }
+
+    // ============================================================================
+    // BLOCKED USERS METHODS
+    // ============================================================================
+
+    /**
+     * Get list of blocked users
+     * @returns Array of blocked users
+     */
+    async getBlockedUsers(): Promise<BlockedUser[]> {
+      try {
+        return await this.makeRequest<BlockedUser[]>('GET', '/api/privacy/blocked', undefined, {
+          cache: true,
+          cacheTTL: 1 * 60 * 1000, // 1 minute cache
+        });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Block a user
+     * @param userId - The user ID to block
+     * @returns Success message
+     */
+    async blockUser(userId: string): Promise<{ message: string }> {
+      try {
+        if (!userId) {
+          throw new Error('User ID is required');
+        }
+        return await this.makeRequest<{ message: string }>('POST', `/api/privacy/blocked/${userId}`, undefined, {
+          cache: false,
+        });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Unblock a user
+     * @param userId - The user ID to unblock
+     * @returns Success message
+     */
+    async unblockUser(userId: string): Promise<{ message: string }> {
+      try {
+        if (!userId) {
+          throw new Error('User ID is required');
+        }
+        return await this.makeRequest<{ message: string }>('DELETE', `/api/privacy/blocked/${userId}`, undefined, {
+          cache: false,
+        });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Check if a user is blocked
+     * @param userId - The user ID to check
+     * @returns True if the user is blocked, false otherwise
+     */
+    async isUserBlocked(userId: string): Promise<boolean> {
+      return this.isUserInList(
+        userId,
+        () => this.getBlockedUsers(),
+        (block) => block.blockedId
+      );
+    }
+
+    // ============================================================================
+    // RESTRICTED USERS METHODS
+    // ============================================================================
+
+    /**
+     * Get list of restricted users
+     * @returns Array of restricted users
+     */
+    async getRestrictedUsers(): Promise<RestrictedUser[]> {
+      try {
+        return await this.makeRequest<RestrictedUser[]>('GET', '/api/privacy/restricted', undefined, {
+          cache: true,
+          cacheTTL: 1 * 60 * 1000, // 1 minute cache
+        });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Restrict a user (limit their interactions without fully blocking)
+     * @param userId - The user ID to restrict
+     * @returns Success message
+     */
+    async restrictUser(userId: string): Promise<{ message: string }> {
+      try {
+        if (!userId) {
+          throw new Error('User ID is required');
+        }
+        return await this.makeRequest<{ message: string }>('POST', `/api/privacy/restricted/${userId}`, undefined, {
+          cache: false,
+        });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Unrestrict a user
+     * @param userId - The user ID to unrestrict
+     * @returns Success message
+     */
+    async unrestrictUser(userId: string): Promise<{ message: string }> {
+      try {
+        if (!userId) {
+          throw new Error('User ID is required');
+        }
+        return await this.makeRequest<{ message: string }>('DELETE', `/api/privacy/restricted/${userId}`, undefined, {
+          cache: false,
+        });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Check if a user is restricted
+     * @param userId - The user ID to check
+     * @returns True if the user is restricted, false otherwise
+     */
+    async isUserRestricted(userId: string): Promise<boolean> {
+      return this.isUserInList(
+        userId,
+        () => this.getRestrictedUsers(),
+        (restrict) => restrict.restrictedId
+      );
+    }
+  };
+}
+

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

@@ -0,0 +1,36 @@
+/**
+ * TOTP Enrollment Methods Mixin
+ */
+import type { OxyServicesBase } from '../OxyServices.base';
+
+export function OxyServicesTotpMixin<T extends typeof OxyServicesBase>(Base: T) {
+  return class extends Base {
+    constructor(...args: any[]) {
+      super(...(args as [any]));
+    }
+    async startTotpEnrollment(sessionId: string): Promise<{ secret: string; otpauthUrl: string; issuer: string; label: string }> {
+      try {
+        return await this.makeRequest('POST', '/api/auth/totp/enroll/start', { sessionId }, { cache: false });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    async verifyTotpEnrollment(sessionId: string, code: string): Promise<{ enabled: boolean; backupCodes?: string[]; recoveryKey?: string }> {
+      try {
+        return await this.makeRequest('POST', '/api/auth/totp/enroll/verify', { sessionId, code }, { cache: false });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    async disableTotp(sessionId: string, code: string): Promise<{ disabled: boolean }> {
+      try {
+        return await this.makeRequest('POST', '/api/auth/totp/disable', { sessionId, code }, { cache: false });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+  };
+}
+