@oxyhq/services 5.13.15 → 5.13.17

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

@@ -0,0 +1,384 @@
+/**
+ * User Management Methods Mixin
+ */
+import type { User, Notification, SearchProfilesResponse, PaginationInfo } from '../../models/interfaces';
+import type { OxyServicesBase } from '../OxyServices.base';
+import { buildSearchParams, buildPaginationParams, type PaginationParams } from '../../utils/apiUtils';
+
+export function OxyServicesUserMixin<T extends typeof OxyServicesBase>(Base: T) {
+  return class extends Base {
+    constructor(...args: any[]) {
+      super(...(args as [any]));
+    }
+    /**
+     * Get profile by username
+     */
+    async getProfileByUsername(username: string): Promise<User> {
+      try {
+        return await this.makeRequest<User>('GET', `/api/profiles/username/${username}`, undefined, {
+          cache: true,
+          cacheTTL: 5 * 60 * 1000, // 5 minutes cache for profiles
+        });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Search user profiles
+     */
+    async searchProfiles(query: string, pagination?: PaginationParams): Promise<SearchProfilesResponse> {
+      try {
+        const params = { query, ...pagination };
+        const searchParams = buildSearchParams(params);
+        const paramsObj = Object.fromEntries(searchParams.entries());
+
+        const response = await this.makeRequest<SearchProfilesResponse | User[]>(
+          'GET',
+          '/api/profiles/search',
+          paramsObj,
+          {
+            cache: true,
+            cacheTTL: 2 * 60 * 1000, // 2 minutes cache
+          }
+        );
+
+        // New API shape: { data: User[], pagination: {...} }
+        const isSearchProfilesResponse = (payload: unknown): payload is SearchProfilesResponse =>
+          typeof payload === 'object' &&
+          payload !== null &&
+          Array.isArray((payload as SearchProfilesResponse).data);
+
+        if (isSearchProfilesResponse(response)) {
+          const typedResponse = response;
+          const paginationInfo: PaginationInfo = typedResponse.pagination ?? {
+            total: typedResponse.data.length,
+            limit: pagination?.limit ?? typedResponse.data.length,
+            offset: pagination?.offset ?? 0,
+            hasMore: typedResponse.data.length === (pagination?.limit ?? typedResponse.data.length) &&
+              (pagination?.limit ?? typedResponse.data.length) > 0,
+          };
+
+          return {
+            data: typedResponse.data,
+            pagination: paginationInfo,
+          };
+        }
+
+        // Legacy API shape: returns raw User[]
+        if (Array.isArray(response)) {
+          const fallbackLimit = pagination?.limit ?? response.length;
+          const fallbackPagination: PaginationInfo = {
+            total: response.length,
+            limit: fallbackLimit,
+            offset: pagination?.offset ?? 0,
+            hasMore: fallbackLimit > 0 && response.length === fallbackLimit,
+          };
+
+          return { data: response, pagination: fallbackPagination };
+        }
+
+        // If response is unexpected, throw an error
+        throw new Error('Unexpected search response format');
+      } 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;
+    }>> {
+      return this.withAuthRetry(async () => {
+        return await this.makeRequest('GET', '/api/profiles/recommendations', undefined, { cache: true });
+      }, 'getProfileRecommendations');
+    }
+
+    /**
+     * Get user by ID
+     */
+    async getUserById(userId: string): Promise<User> {
+      try {
+        return await this.makeRequest<User>('GET', `/api/users/${userId}`, undefined, {
+          cache: true,
+          cacheTTL: 5 * 60 * 1000, // 5 minutes cache
+        });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Get current user
+     */
+    async getCurrentUser(): Promise<User> {
+      return this.withAuthRetry(async () => {
+        return await this.makeRequest<User>('GET', '/api/users/me', undefined, {
+          cache: true,
+          cacheTTL: 1 * 60 * 1000, // 1 minute cache for current user
+        });
+      }, 'getCurrentUser');
+    }
+
+    /**
+     * Update user profile
+     */
+    async updateProfile(updates: Record<string, any>): Promise<User> {
+      try {
+        return await this.makeRequest<User>('PUT', '/api/users/me', updates, { cache: false });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Get privacy settings for a user
+     * @param userId - The user ID (defaults to current user)
+     */
+    async getPrivacySettings(userId?: string): Promise<any> {
+      try {
+        const id = userId || (await this.getCurrentUser()).id;
+        return await this.makeRequest<any>('GET', `/api/privacy/${id}/privacy`, undefined, {
+          cache: true,
+          cacheTTL: 2 * 60 * 1000, // 2 minutes cache
+        });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Update privacy settings
+     * @param settings - Partial privacy settings object
+     * @param userId - The user ID (defaults to current user)
+     */
+    async updatePrivacySettings(settings: Record<string, any>, userId?: string): Promise<any> {
+      try {
+        const id = userId || (await this.getCurrentUser()).id;
+        return await this.makeRequest<any>('PATCH', `/api/privacy/${id}/privacy`, settings, {
+          cache: false,
+        });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Request account verification
+     */
+    async requestAccountVerification(reason: string, evidence?: string): Promise<{ message: string; requestId: string }> {
+      try {
+        return await this.makeRequest<{ message: string; requestId: string }>('POST', '/api/users/verify/request', {
+          reason,
+          evidence,
+        }, { cache: false });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Download account data export
+     */
+    async downloadAccountData(format: 'json' | 'csv' = 'json'): Promise<Blob> {
+      try {
+        // Use axios instance directly for blob responses since RequestManager doesn't handle blobs
+        const axiosInstance = this.getClient().getAxiosInstance();
+        
+        const response = await axiosInstance.get(`/api/users/me/data?format=${format}`, {
+          responseType: 'blob',
+        });
+        
+        return response.data as Blob;
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Delete account permanently
+     * @param password - User password for confirmation
+     * @param confirmText - Confirmation text (usually username)
+     */
+    async deleteAccount(password: string, confirmText: string): Promise<{ message: string }> {
+      try {
+        return await this.makeRequest<{ message: string }>('DELETE', '/api/users/me', {
+          password,
+          confirmText,
+        }, { cache: false });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Update user by ID (admin function)
+     */
+    async updateUser(userId: string, updates: Record<string, any>): Promise<User> {
+      try {
+        return await this.makeRequest<User>('PUT', `/api/users/${userId}`, updates, { cache: false });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Follow a user
+     */
+    async followUser(userId: string): Promise<{ success: boolean; message: string }> {
+      try {
+        return await this.makeRequest('POST', `/api/users/${userId}/follow`, undefined, { cache: false });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Unfollow a user
+     */
+    async unfollowUser(userId: string): Promise<{ success: boolean; message: string }> {
+      try {
+        return await this.makeRequest('DELETE', `/api/users/${userId}/follow`, undefined, { cache: false });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Get follow status
+     */
+    async getFollowStatus(userId: string): Promise<{ isFollowing: boolean }> {
+      try {
+        return await this.makeRequest('GET', `/api/users/${userId}/follow-status`, undefined, {
+          cache: true,
+          cacheTTL: 1 * 60 * 1000, // 1 minute cache
+        });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Get user followers
+     */
+    async getUserFollowers(
+      userId: string,
+      pagination?: PaginationParams
+    ): Promise<{ followers: User[]; total: number; hasMore: boolean }> {
+      try {
+        const params = buildPaginationParams(pagination || {});
+        const response = await this.makeRequest<{ data: User[]; pagination: { total: number; hasMore: boolean } }>('GET', `/api/users/${userId}/followers`, params, {
+          cache: true,
+          cacheTTL: 2 * 60 * 1000, // 2 minutes cache
+        });
+        return {
+          followers: response.data || [],
+          total: response.pagination.total,
+          hasMore: response.pagination.hasMore,
+        };
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Get user following
+     */
+    async getUserFollowing(
+      userId: string,
+      pagination?: PaginationParams
+    ): Promise<{ following: User[]; total: number; hasMore: boolean }> {
+      try {
+        const params = buildPaginationParams(pagination || {});
+        const response = await this.makeRequest<{ data: User[]; pagination: { total: number; hasMore: boolean } }>('GET', `/api/users/${userId}/following`, params, {
+          cache: true,
+          cacheTTL: 2 * 60 * 1000, // 2 minutes cache
+        });
+        return {
+          following: response.data || [],
+          total: response.pagination.total,
+          hasMore: response.pagination.hasMore,
+        };
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Get notifications
+     */
+    async getNotifications(): Promise<Notification[]> {
+      return this.withAuthRetry(async () => {
+        return await this.makeRequest<Notification[]>('GET', '/api/notifications', undefined, {
+          cache: false, // Don't cache notifications - always get fresh data
+        });
+      }, 'getNotifications');
+    }
+
+    /**
+     * Get unread notification count
+     */
+    async getUnreadCount(): Promise<number> {
+      try {
+        const res = await this.makeRequest<{ count: number }>('GET', '/api/notifications/unread-count', undefined, {
+          cache: false, // Don't cache unread count - always get fresh data
+        });
+        return res.count;
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Create notification
+     */
+    async createNotification(data: Partial<Notification>): Promise<Notification> {
+      try {
+        return await this.makeRequest<Notification>('POST', '/api/notifications', data, { cache: false });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Mark notification as read
+     */
+    async markNotificationAsRead(notificationId: string): Promise<void> {
+      try {
+        await this.makeRequest('PUT', `/api/notifications/${notificationId}/read`, undefined, { cache: false });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Mark all notifications as read
+     */
+    async markAllNotificationsAsRead(): Promise<void> {
+      try {
+        await this.makeRequest('PUT', '/api/notifications/read-all', undefined, { cache: false });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Delete notification
+     */
+    async deleteNotification(notificationId: string): Promise<void> {
+      try {
+        await this.makeRequest('DELETE', `/api/notifications/${notificationId}`, undefined, { cache: false });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+  };
+}
+

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

@@ -0,0 +1,187 @@
+/**
+ * Utility Methods Mixin
+ * 
+ * Provides utility methods including link metadata fetching
+ * and Express.js authentication middleware
+ */
+import { jwtDecode } from 'jwt-decode';
+import type { ApiError, User } from '../../models/interfaces';
+import type { OxyServicesBase } from '../OxyServices.base';
+import { CACHE_TIMES } from './mixinHelpers';
+
+interface JwtPayload {
+  exp?: number;
+  userId?: string;
+  id?: string;
+  sessionId?: string;
+  [key: string]: any;
+}
+
+export function OxyServicesUtilityMixin<T extends typeof OxyServicesBase>(Base: T) {
+  return class extends Base {
+    constructor(...args: any[]) {
+      super(...(args as [any]));
+    }
+    /**
+     * Fetch link metadata
+     */
+    async fetchLinkMetadata(url: string): Promise<{
+      url: string;
+      title: string;
+      description: string;
+      image?: string;
+    }> {
+      try {
+        return await this.makeRequest<{
+          url: string;
+          title: string;
+          description: string;
+          image?: string;
+        }>('GET', '/api/link-metadata', { url }, {
+          cache: true,
+          cacheTTL: CACHE_TIMES.EXTRA_LONG,
+        });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Simple Express.js authentication middleware
+     * 
+     * Built-in authentication middleware that validates JWT tokens and adds user data to requests.
+     * 
+     * @example
+     * ```typescript
+     * // Basic usage - just add it to your routes
+     * app.use('/api/protected', oxyServices.auth());
+     * 
+     * // With debug logging
+     * app.use('/api/protected', oxyServices.auth({ debug: true }));
+     * 
+     * // With custom error handling
+     * app.use('/api/protected', oxyServices.auth({
+     *   onError: (error) => console.error('Auth failed:', error)
+     * }));
+     * 
+     * // Load full user data
+     * app.use('/api/protected', oxyServices.auth({ loadUser: true }));
+     * ```
+     * 
+     * @param options Optional configuration
+     * @param options.debug Enable debug logging (default: false)
+     * @param options.onError Custom error handler
+     * @param options.loadUser Load full user data (default: false for performance)
+     * @param options.session Use session-based validation (default: false)
+     * @returns Express middleware function
+     */
+    auth(options: {
+      debug?: boolean;
+      onError?: (error: ApiError) => any;
+      loadUser?: boolean;
+      session?: boolean;
+    } = {}) {
+      const { debug = false, onError, loadUser = false, session = false } = options;
+      
+      // Return a synchronous middleware function
+      return (req: any, res: any, next: any) => {
+        try {
+          // Extract token from Authorization header
+          const authHeader = req.headers['authorization'];
+          const token = authHeader?.startsWith('Bearer ') ? authHeader.substring(7) : null;
+          
+          if (debug) {
+            console.log(`🔐 Auth: Processing ${req.method} ${req.path}`);
+            console.log(`🔐 Auth: Token present: ${!!token}`);
+          }
+          
+          if (!token) {
+            const error = {
+              message: 'Access token required',
+              code: 'MISSING_TOKEN',
+              status: 401
+            };
+            
+            if (debug) console.log(`❌ Auth: Missing token`);
+            
+            if (onError) return onError(error);
+            return res.status(401).json(error);
+          }
+          
+          // Decode and validate token
+          let decoded: JwtPayload;
+          try {
+            decoded = jwtDecode<JwtPayload>(token);
+            
+            if (debug) {
+              console.log(`🔐 Auth: Token decoded, User ID: ${decoded.userId || decoded.id}`);
+            }
+          } catch (decodeError) {
+            const error = {
+              message: 'Invalid token format',
+              code: 'INVALID_TOKEN_FORMAT',
+              status: 403
+            };
+            
+            if (debug) console.log(`❌ Auth: Token decode failed`);
+            
+            if (onError) return onError(error);
+            return res.status(403).json(error);
+          }
+          
+          const userId = decoded.userId || decoded.id;
+          if (!userId) {
+            const error = {
+              message: 'Token missing user ID',
+              code: 'INVALID_TOKEN_PAYLOAD',
+              status: 403
+            };
+            
+            if (debug) console.log(`❌ Auth: Token missing user ID`);
+            
+            if (onError) return onError(error);
+            return res.status(403).json(error);
+          }
+          
+          // Check token expiration
+          if (decoded.exp && decoded.exp < Math.floor(Date.now() / 1000)) {
+            const error = {
+              message: 'Token expired',
+              code: 'TOKEN_EXPIRED',
+              status: 403
+            };
+            
+            if (debug) console.log(`❌ Auth: Token expired`);
+            
+            if (onError) return onError(error);
+            return res.status(403).json(error);
+          }
+          
+          // For now, skip session validation to keep it simple
+          // Session validation can be added later if needed
+          
+          // Set request properties immediately
+          req.userId = userId;
+          req.accessToken = token;
+          req.user = { id: userId } as User;
+          
+          if (debug) {
+            console.log(`✅ Auth: Authentication successful for user ${userId}`);
+          }
+          
+          next();
+        } catch (error) {
+          const apiError = this.handleError(error) as any;
+          
+          if (debug) {
+            console.log(`❌ Auth: Unexpected error:`, apiError);
+          }
+          
+          if (onError) return onError(apiError);
+          return res.status((apiError && apiError.status) || 500).json(apiError);
+        }
+      };
+    }
+  };
+}
+

package/src/core/mixins/index.ts

@@ -0,0 +1,58 @@
+/**
+ * Centralized mixin exports and composition helper
+ * 
+ * This module provides a clean way to compose all mixins
+ * and ensures consistent ordering for better maintainability
+ */
+
+import { OxyServicesBase } from '../OxyServices.base';
+import { OxyServicesAuthMixin } from './OxyServices.auth';
+import { OxyServicesUserMixin } from './OxyServices.user';
+import { OxyServicesTotpMixin } from './OxyServices.totp';
+import { OxyServicesPrivacyMixin } from './OxyServices.privacy';
+import { OxyServicesLanguageMixin } from './OxyServices.language';
+import { OxyServicesPaymentMixin } from './OxyServices.payment';
+import { OxyServicesKarmaMixin } from './OxyServices.karma';
+import { OxyServicesAssetsMixin } from './OxyServices.assets';
+import { OxyServicesDeveloperMixin } from './OxyServices.developer';
+import { OxyServicesLocationMixin } from './OxyServices.location';
+import { OxyServicesAnalyticsMixin } from './OxyServices.analytics';
+import { OxyServicesDevicesMixin } from './OxyServices.devices';
+import { OxyServicesUtilityMixin } from './OxyServices.utility';
+
+/**
+ * Composes all OxyServices mixins in the correct order
+ * 
+ * Order matters for mixins - dependencies should be applied first.
+ * This function ensures consistent composition across the codebase.
+ * 
+ * @returns The fully composed OxyServices class with all mixins applied
+ */
+export function composeOxyServices() {
+  return OxyServicesUtilityMixin(
+    OxyServicesDevicesMixin(
+      OxyServicesAnalyticsMixin(
+        OxyServicesLocationMixin(
+          OxyServicesDeveloperMixin(
+            OxyServicesAssetsMixin(
+              OxyServicesKarmaMixin(
+                OxyServicesPaymentMixin(
+                  OxyServicesLanguageMixin(
+                    OxyServicesPrivacyMixin(
+                      OxyServicesTotpMixin(
+                        OxyServicesUserMixin(
+                          OxyServicesAuthMixin(OxyServicesBase)
+                        )
+                      )
+                    )
+                  )
+                )
+              )
+            )
+          )
+        )
+      )
+    )
+  );
+}
+

package/src/core/mixins/mixinHelpers.ts

@@ -0,0 +1,69 @@
+/**
+ * Helper utilities for mixin classes
+ * Provides common patterns to reduce code duplication
+ */
+
+import type { OxyServicesBase } from '../OxyServices.base';
+
+/**
+ * Wraps an async method with standard error handling
+ * Reduces boilerplate in mixin methods
+ */
+export async function withErrorHandling<T>(
+  operation: () => Promise<T>,
+  handleError: (error: any) => Error
+): Promise<T> {
+  try {
+    return await operation();
+  } catch (error) {
+    throw handleError(error);
+  }
+}
+
+/**
+ * Creates a standard API request method with error handling
+ * Reduces duplication across mixin methods
+ */
+export function createApiMethod<T>(
+  makeRequest: OxyServicesBase['makeRequest'],
+  handleError: OxyServicesBase['handleError'],
+  method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE',
+  url: string | ((...args: any[]) => string),
+  options: {
+    cache?: boolean;
+    cacheTTL?: number;
+    retry?: boolean;
+    transformData?: (data: any) => any;
+    transformResponse?: (response: any) => T;
+  } = {}
+) {
+  return async (...args: any[]): Promise<T> => {
+    const urlString = typeof url === 'function' ? url(...args) : url;
+    const requestData = options.transformData ? options.transformData(args) : args[0];
+    
+    const requestOptions = {
+      cache: options.cache ?? true,
+      cacheTTL: options.cacheTTL,
+      retry: options.retry ?? true,
+    };
+
+    try {
+      const response = await makeRequest<T>(method, urlString, requestData, requestOptions);
+      return options.transformResponse ? options.transformResponse(response) : response;
+    } catch (error) {
+      throw handleError(error);
+    }
+  };
+}
+
+/**
+ * Cache time constants (in milliseconds)
+ */
+export const CACHE_TIMES = {
+  SHORT: 1 * 60 * 1000,      // 1 minute
+  MEDIUM: 2 * 60 * 1000,     // 2 minutes
+  LONG: 5 * 60 * 1000,       // 5 minutes
+  VERY_LONG: 10 * 60 * 1000, // 10 minutes
+  EXTRA_LONG: 30 * 60 * 1000, // 30 minutes
+} as const;
+