@oxyhq/services 5.9.2 → 5.9.4

package/src/core/karma/KarmaService.ts

@@ -0,0 +1,104 @@
+import { OxyServices } from '../OxyServices';
+import {
+  KarmaRule,
+  KarmaHistory,
+  KarmaLeaderboardEntry,
+  KarmaAwardRequest
+} from '../../models/interfaces';
+
+/**
+ * Karma service for handling karma system operations
+ */
+export class KarmaService extends OxyServices {
+  /**
+   * Get karma leaderboard
+   */
+  async getKarmaLeaderboard(): Promise<KarmaLeaderboardEntry[]> {
+    try {
+      const res = await this.getClient().get('/karma/leaderboard');
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Get karma rules
+   */
+  async getKarmaRules(): Promise<KarmaRule[]> {
+    try {
+      const res = await this.getClient().get('/karma/rules');
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Get user karma total
+   */
+  async getUserKarmaTotal(userId: string): Promise<{ total: number }> {
+    try {
+      const res = await this.getClient().get(`/karma/users/${userId}/total`);
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Get user karma history
+   */
+  async getUserKarmaHistory(
+    userId: string, 
+    limit?: number, 
+    offset?: number
+  ): Promise<{ history: KarmaHistory[]; total: number; hasMore: boolean }> {
+    try {
+      const params = new URLSearchParams();
+      if (limit) params.append('limit', limit.toString());
+      if (offset) params.append('offset', offset.toString());
+      
+      const res = await this.getClient().get(`/karma/users/${userId}/history?${params.toString()}`);
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Award karma to user
+   */
+  async awardKarma(data: KarmaAwardRequest): Promise<{ success: boolean; message: string; history: KarmaHistory }> {
+    try {
+      const res = await this.getClient().post('/karma/award', data);
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Deduct karma from user
+   */
+  async deductKarma(data: KarmaAwardRequest): Promise<{ success: boolean; message: string; history: KarmaHistory }> {
+    try {
+      const res = await this.getClient().post('/karma/deduct', data);
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Create or update karma rule
+   */
+  async createOrUpdateKarmaRule(data: Partial<KarmaRule>): Promise<KarmaRule> {
+    try {
+      const res = await this.getClient().post('/karma/rules', data);
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+} 

package/src/core/locations/LocationService.ts

@@ -0,0 +1,141 @@
+import { OxyServices } from '../OxyServices';
+
+/**
+ * Location service for handling location search and geolocation features
+ */
+export class LocationService extends OxyServices {
+  /**
+   * Search locations
+   */
+  async searchLocations(query: string, limit: number = 5, countrycodes?: string): Promise<any[]> {
+    try {
+      const params = new URLSearchParams({
+        query,
+        limit: limit.toString()
+      });
+      
+      if (countrycodes) {
+        params.append('countrycodes', countrycodes);
+      }
+      
+      const res = await this.getClient().get(`/location-search/search?${params.toString()}`);
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Get location details by coordinates
+   */
+  async getLocationDetails(lat: number, lon: number): Promise<any> {
+    try {
+      const res = await this.getClient().get(`/location-search/reverse?lat=${lat}&lon=${lon}`);
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Find locations near coordinates
+   */
+  async findLocationsNear(
+    lat: number, 
+    lon: number, 
+    maxDistance: number = 10000,
+    limit: number = 10,
+    skip: number = 0
+  ): Promise<any> {
+    try {
+      const params = new URLSearchParams({
+        lat: lat.toString(),
+        lon: lon.toString(),
+        maxDistance: maxDistance.toString(),
+        limit: limit.toString(),
+        skip: skip.toString()
+      });
+      
+      const res = await this.getClient().get(`/location-search/near?${params.toString()}`);
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Search locations in database
+   */
+  async searchLocationsInDB(
+    query: string,
+    limit: number = 10,
+    skip: number = 0,
+    type?: string,
+    country?: string,
+    city?: string
+  ): Promise<any> {
+    try {
+      const params = new URLSearchParams({
+        query,
+        limit: limit.toString(),
+        skip: skip.toString()
+      });
+      if (type) params.append('type', type);
+      if (country) params.append('country', country);
+      if (city) params.append('city', city);
+      
+      const res = await this.getClient().get(`/location-search/db-search?${params.toString()}`);
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Get location statistics
+   */
+  async getLocationStats(): Promise<any> {
+    try {
+      const res = await this.getClient().get('/location-search/stats');
+      return res.data.stats;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Get cache statistics
+   */
+  async getLocationCacheStats(): Promise<any> {
+    try {
+      const res = await this.getClient().get('/location-search/cache/stats');
+      return res.data.stats;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Clear location cache
+   */
+  async clearLocationCache(): Promise<any> {
+    try {
+      const res = await this.getClient().delete('/location-search/cache');
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Get performance statistics
+   */
+  async getLocationPerformanceStats(): Promise<any> {
+    try {
+      const res = await this.getClient().get('/location-search/performance');
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+} 

package/src/core/payments/PaymentService.ts

@@ -0,0 +1,133 @@
+import { OxyServices } from '../OxyServices';
+import {
+  Wallet,
+  Transaction,
+  TransferFundsRequest,
+  PurchaseRequest,
+  WithdrawalRequest,
+  TransactionResponse,
+  PaymentMethod,
+  PaymentRequest,
+  PaymentResponse
+} from '../../models/interfaces';
+
+/**
+ * Payment service for handling payments, wallet operations, and transactions
+ */
+export class PaymentService extends OxyServices {
+  /**
+   * Process payment
+   */
+  async processPayment(data: PaymentRequest): Promise<PaymentResponse> {
+    try {
+      const res = await this.getClient().post('/payments/process', data);
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Validate payment method
+   */
+  async validatePaymentMethod(paymentMethod: any): Promise<{ valid: boolean }> {
+    try {
+      const res = await this.getClient().post('/payments/validate-method', paymentMethod);
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Get payment methods for user
+   */
+  async getPaymentMethods(userId: string): Promise<PaymentMethod[]> {
+    try {
+      const res = await this.getClient().get(`/payments/methods/${userId}`);
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Get user wallet
+   */
+  async getWallet(userId: string): Promise<Wallet> {
+    try {
+      const res = await this.getClient().get(`/wallet/${userId}`);
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Get transaction history
+   */
+  async getTransactionHistory(
+    userId: string, 
+    limit?: number, 
+    offset?: number
+  ): Promise<{ transactions: Transaction[]; total: number; hasMore: boolean }> {
+    try {
+      const params = new URLSearchParams();
+      if (limit) params.append('limit', limit.toString());
+      if (offset) params.append('offset', offset.toString());
+      
+      const res = await this.getClient().get(`/wallet/${userId}/transactions?${params.toString()}`);
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Get specific transaction
+   */
+  async getTransaction(transactionId: string): Promise<Transaction> {
+    try {
+      const res = await this.getClient().get(`/transactions/${transactionId}`);
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Transfer funds between users
+   */
+  async transferFunds(data: TransferFundsRequest): Promise<TransactionResponse> {
+    try {
+      const res = await this.getClient().post('/wallet/transfer', data);
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Process purchase
+   */
+  async processPurchase(data: PurchaseRequest): Promise<TransactionResponse> {
+    try {
+      const res = await this.getClient().post('/wallet/purchase', data);
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Request withdrawal
+   */
+  async requestWithdrawal(data: WithdrawalRequest): Promise<TransactionResponse> {
+    try {
+      const res = await this.getClient().post('/wallet/withdraw', data);
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+} 

package/src/core/users/UserService.ts

@@ -0,0 +1,241 @@
+import { OxyServices } from '../OxyServices';
+import { User, Notification } from '../../models/interfaces';
+import { buildSearchParams, buildPaginationParams, PaginationParams } from '../../utils/apiUtils';
+
+/**
+ * User service for handling user operations, profiles, and social features
+ */
+export class UserService extends OxyServices {
+  /**
+   * Get profile by username
+   */
+  async getProfileByUsername(username: string): Promise<User> {
+    try {
+      const res = await this.getClient().get(`/users/profile/${username}`);
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Search user profiles
+   */
+  async searchProfiles(query: string, pagination?: PaginationParams): Promise<User[]> {
+    try {
+      const params = { query, ...pagination };
+      const searchParams = buildSearchParams(params);
+      
+      const res = await this.getClient().get(`/users/search?${searchParams.toString()}`);
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Get profile recommendations
+   */
+  async getProfileRecommendations(): Promise<Array<{
+    id: string;
+    username: string;
+    name?: { first?: string; last?: string; full?: string };
+    description?: string;
+    _count?: { followers: number; following: number };
+    [key: string]: any;
+  }>> {
+    try {
+      const res = await this.getClient().get('/users/recommendations');
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Get user by ID
+   */
+  async getUserById(userId: string): Promise<User> {
+    try {
+      const res = await this.getClient().get(`/users/${userId}`);
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Get current user
+   */
+  async getCurrentUser(): Promise<User> {
+    try {
+      const res = await this.getClient().get('/users/me');
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Update user profile
+   */
+  async updateProfile(updates: Record<string, any>): Promise<User> {
+    try {
+      const res = await this.getClient().put('/users/profile', updates);
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Update user by ID (admin function)
+   */
+  async updateUser(userId: string, updates: Record<string, any>): Promise<User> {
+    try {
+      const res = await this.getClient().put(`/users/${userId}`, updates);
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Follow a user
+   */
+  async followUser(userId: string): Promise<{ success: boolean; message: string }> {
+    try {
+      const res = await this.getClient().post(`/users/${userId}/follow`);
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Unfollow a user
+   */
+  async unfollowUser(userId: string): Promise<{ success: boolean; message: string }> {
+    try {
+      const res = await this.getClient().delete(`/users/${userId}/follow`);
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Get follow status
+   */
+  async getFollowStatus(userId: string): Promise<{ isFollowing: boolean }> {
+    try {
+      const res = await this.getClient().get(`/users/${userId}/follow-status`);
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Get user followers
+   */
+  async getUserFollowers(
+    userId: string,
+    pagination?: PaginationParams
+  ): Promise<{ followers: User[]; total: number; hasMore: boolean }> {
+    try {
+      const searchParams = buildPaginationParams(pagination || {});
+      
+      const res = await this.getClient().get(`/users/${userId}/followers?${searchParams.toString()}`);
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Get user following
+   */
+  async getUserFollowing(
+    userId: string,
+    pagination?: PaginationParams
+  ): Promise<{ following: User[]; total: number; hasMore: boolean }> {
+    try {
+      const searchParams = buildPaginationParams(pagination || {});
+      
+      const res = await this.getClient().get(`/users/${userId}/following?${searchParams.toString()}`);
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Get notifications
+   */
+  async getNotifications(): Promise<Notification[]> {
+    try {
+      const res = await this.getClient().get('/notifications');
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Get unread notification count
+   */
+  async getUnreadCount(): Promise<number> {
+    try {
+      const res = await this.getClient().get('/notifications/unread-count');
+      return res.data.count;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Create notification
+   */
+  async createNotification(data: Partial<Notification>): Promise<Notification> {
+    try {
+      const res = await this.getClient().post('/notifications', data);
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Mark notification as read
+   */
+  async markNotificationAsRead(notificationId: string): Promise<void> {
+    try {
+      await this.getClient().put(`/notifications/${notificationId}/read`);
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Mark all notifications as read
+   */
+  async markAllNotificationsAsRead(): Promise<void> {
+    try {
+      await this.getClient().put('/notifications/read-all');
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Delete notification
+   */
+  async deleteNotification(notificationId: string): Promise<void> {
+    try {
+      await this.getClient().delete(`/notifications/${notificationId}`);
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+} 

package/src/index.ts

@@ -10,10 +10,6 @@
 export { OxyServices } from './core';
 export { OXY_CLOUD_URL } from './core';
 
-// Middleware exports (for server-side use)
-export type { AuthRequest, SimpleAuthRequest } from './types/middleware';
-export { createAuthMiddleware } from './middleware';
-
 // React context
 export { 
   OxyContextProvider, // Backward compatibility
@@ -62,10 +58,10 @@ export type {
 } from './models/interfaces';
 
 export type {
-  SecureLoginResponse,
-  SecureClientSession,
+  SessionLoginResponse,
+  ClientSession,
   MinimalUserData
-} from './models/secureSession';
+} from './models/session';
 
 // UI components and hooks
 export { useAuthStore } from './ui/stores/authStore';
@@ -73,4 +69,29 @@ export { useSessionSocket } from './ui/hooks/useSessionSocket';
 
 // UI components
 export { OxySignInButton } from './ui/components/OxySignInButton';
-export { OxyLogo, FollowButton } from './ui';
+export { OxyLogo, FollowButton } from './ui';
+
+// New consolidated utilities
+export * from './utils/apiUtils';
+export { 
+  ErrorCodes, 
+  createApiError, 
+  handleHttpError, 
+  validateRequiredFields,
+  retryWithBackoff 
+} from './utils/errorUtils';
+export * from './utils/validationUtils';
+export { 
+  logger, 
+  LogLevel, 
+  LogContext,
+  logAuth,
+  logApi,
+  logSession,
+  logUser,
+  logDevice,
+  logPayment,
+  logPerformance
+} from './utils/loggerUtils';
+export * from './utils/asyncUtils';
+export * from './utils/hookUtils';

package/src/models/{secureSession.ts → session.ts}

@@ -1,4 +1,4 @@
-export interface SecureClientSession {
+export interface ClientSession {
   sessionId: string;
   deviceId: string;
   expiresAt: string;
@@ -7,8 +7,8 @@ export interface SecureClientSession {
   userId?: string;
 }
 
-export interface SecureStorageKeys {
-  sessions: string; // Array of SecureClientSession objects
+export interface StorageKeys {
+  sessions: string; // Array of ClientSession objects
   activeSessionId: string; // ID of currently active session
 }
 
@@ -21,9 +21,9 @@ export interface MinimalUserData {
   };
 }
 
-export interface SecureLoginResponse {
+export interface SessionLoginResponse {
   sessionId: string;
   deviceId: string;
   expiresAt: string;
   user: MinimalUserData;
-}
+}