@oxyhq/core 1.0.0

package/src/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/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/mixins/OxyServices.payment.ts

@@ -0,0 +1,163 @@
+/**
+ * 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);
+      }
+    }
+
+    /**
+     * Get user subscription
+     * @param userId - The user ID
+     * @returns Subscription object
+     */
+    async getSubscription(userId: string): Promise<any> {
+      try {
+        return await this.makeRequest('GET', `/api/subscription/${userId}`, undefined, {
+          cache: true,
+          cacheTTL: CACHE_TIMES.MEDIUM,
+        });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Get current user's subscription
+     * @returns Subscription object
+     */
+    async getCurrentUserSubscription(): Promise<any> {
+      try {
+        const userId = this.getCurrentUserId();
+        if (!userId) {
+          throw new Error('User not authenticated');
+        }
+        return await this.getSubscription(userId);
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Get user wallet
+     * @param userId - The user ID
+     * @returns Wallet object with balance
+     */
+    async getWallet(userId: string): Promise<any> {
+      try {
+        return await this.makeRequest('GET', `/api/wallet/${userId}`, undefined, {
+          cache: true,
+          cacheTTL: CACHE_TIMES.SHORT, // Cache wallet for short time as balance changes frequently
+        });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Get current user's wallet
+     * @returns Wallet object with balance
+     */
+    async getCurrentUserWallet(): Promise<any> {
+      try {
+        const userId = this.getCurrentUserId();
+        if (!userId) {
+          throw new Error('User not authenticated');
+        }
+        return await this.getWallet(userId);
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Get wallet transaction history
+     * @param userId - The user ID
+     * @param options - Pagination options
+     * @returns Transaction history
+     */
+    async getWalletTransactions(userId: string, options?: { limit?: number; offset?: number }): Promise<any> {
+      try {
+        const params = new URLSearchParams();
+        if (options?.limit) params.append('limit', options.limit.toString());
+        if (options?.offset) params.append('offset', options.offset.toString());
+        
+        const queryString = params.toString();
+        const url = `/api/wallet/transactions/${userId}${queryString ? `?${queryString}` : ''}`;
+        
+        return await this.makeRequest('GET', url, undefined, {
+          cache: false, // Don't cache transactions - always get fresh data
+        });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Get current user's wallet transaction history
+     * @param options - Pagination options
+     * @returns Transaction history
+     */
+    async getCurrentUserWalletTransactions(options?: { limit?: number; offset?: number }): Promise<any> {
+      try {
+        const userId = this.getCurrentUserId();
+        if (!userId) {
+          throw new Error('User not authenticated');
+        }
+        return await this.getWalletTransactions(userId, options);
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+  };
+}
+