@oxyhq/services 5.13.15 → 5.13.16

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

@@ -0,0 +1,275 @@
+/**
+ * Authentication Methods Mixin
+ */
+import type { User } from '../../models/interfaces';
+import type { SessionLoginResponse } from '../../models/session';
+import type { OxyServicesBase } from '../OxyServices.base';
+import { OxyAuthenticationError } from '../OxyServices.errors';
+
+export function OxyServicesAuthMixin<T extends typeof OxyServicesBase>(Base: T) {
+  return class extends Base {
+    constructor(...args: any[]) {
+      super(...(args as [any]));
+    }
+    /**
+     * Sign up a new user
+     */
+    async signUp(username: string, email: string, password: string): Promise<{ message: string; token: string; user: User }> {
+      try {
+        const res = await this.makeRequest<{ message: string; token: string; user: User }>('POST', '/api/auth/signup', {
+          username,
+          email,
+          password
+        }, { cache: false });
+        if (!res || (typeof res === 'object' && Object.keys(res).length === 0)) {
+          throw new OxyAuthenticationError('Sign up failed', 'SIGNUP_FAILED', 400);
+        }
+        return res;
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Request account recovery (send verification code)
+     */
+    async requestRecovery(identifier: string): Promise<{ delivery?: string; destination?: string }> {
+      try {
+        return await this.makeRequest('POST', '/api/auth/recover/request', { identifier }, { cache: false });
+      } catch (error: any) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Verify recovery code
+     */
+    async verifyRecoveryCode(identifier: string, code: string): Promise<{ verified: boolean }> {
+      try {
+        return await this.makeRequest('POST', '/api/auth/recover/verify', { identifier, code }, { cache: false });
+      } catch (error: any) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Reset password using verified code
+     */
+    async resetPassword(identifier: string, code: string, newPassword: string): Promise<{ success: boolean }> {
+      try {
+        return await this.makeRequest('POST', '/api/auth/recover/reset', { identifier, code, newPassword }, { cache: false });
+      } catch (error: any) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Reset password using TOTP code (recommended recovery)
+     */
+    async resetPasswordWithTotp(identifier: string, code: string, newPassword: string): Promise<{ success: boolean }> {
+      try {
+        return await this.makeRequest('POST', '/api/auth/recover/totp/reset', { identifier, code, newPassword }, { cache: false });
+      } catch (error: any) {
+        throw this.handleError(error);
+      }
+    }
+
+    async resetPasswordWithBackupCode(identifier: string, backupCode: string, newPassword: string): Promise<{ success: boolean }> {
+      try {
+        return await this.makeRequest('POST', '/api/auth/recover/backup/reset', { identifier, backupCode, newPassword }, { cache: false });
+      } catch (error: any) {
+        throw this.handleError(error);
+      }
+    }
+
+    async resetPasswordWithRecoveryKey(identifier: string, recoveryKey: string, newPassword: string): Promise<{ success: boolean; nextRecoveryKey?: string }> {
+      try {
+        return await this.makeRequest('POST', '/api/auth/recover/recovery-key/reset', { identifier, recoveryKey, newPassword }, { cache: false });
+      } catch (error: any) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Sign in with device management
+     */
+    async signIn(
+      username: string,
+      password: string,
+      deviceName?: string,
+      deviceFingerprint?: any
+    ): Promise<SessionLoginResponse | { mfaRequired: true; mfaToken: string; expiresAt: string }> {
+      try {
+        return await this.makeRequest<SessionLoginResponse | { mfaRequired: true; mfaToken: string; expiresAt: string }>('POST', '/api/auth/login', {
+          username,
+          password,
+          deviceName,
+          deviceFingerprint
+        }, { cache: false });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Complete login by verifying TOTP with MFA token
+     */
+    async verifyTotpLogin(mfaToken: string, code: string): Promise<SessionLoginResponse> {
+      try {
+        return await this.makeRequest<SessionLoginResponse>('POST', '/api/auth/totp/verify-login', { mfaToken, code }, { cache: false });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Get user by session ID
+     */
+    async getUserBySession(sessionId: string): Promise<User> {
+      try {
+        return await this.makeRequest<User>('GET', `/api/session/user/${sessionId}`, undefined, {
+          cache: true,
+          cacheTTL: 2 * 60 * 1000, // 2 minutes cache for user data
+        });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Batch get multiple user profiles by session IDs (optimized for account switching)
+     * Returns array of { sessionId, user } objects
+     */
+    async getUsersBySessions(sessionIds: string[]): Promise<Array<{ sessionId: string; user: User | null }>> {
+      try {
+        if (!Array.isArray(sessionIds) || sessionIds.length === 0) {
+          return [];
+        }
+        
+        // Deduplicate and sort sessionIds for consistent cache keys
+        const uniqueSessionIds = Array.from(new Set(sessionIds)).sort();
+        
+        return await this.makeRequest<Array<{ sessionId: string; user: User | null }>>(
+          'POST',
+          '/api/session/users/batch',
+          { sessionIds: uniqueSessionIds },
+          {
+            cache: true,
+            cacheTTL: 2 * 60 * 1000, // 2 minutes cache
+            deduplicate: true, // Important for batch requests
+          }
+        );
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Get access token by session ID and set it in the token store
+     */
+    async getTokenBySession(sessionId: string): Promise<{ accessToken: string; expiresAt: string }> {
+      try {
+        const res = await this.makeRequest<{ accessToken: string; expiresAt: string }>('GET', `/api/session/token/${sessionId}`, undefined, {
+          cache: false,
+          retry: false,
+        });
+        
+        // Set the token in the centralized token store
+        this.setTokens(res.accessToken);
+        
+        return res;
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Get sessions by session ID
+     */
+    async getSessionsBySessionId(sessionId: string): Promise<any[]> {
+      try {
+        return await this.makeRequest('GET', `/api/session/sessions/${sessionId}`, undefined, {
+          cache: false,
+        });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Logout from a specific session
+     */
+    async logoutSession(sessionId: string, targetSessionId?: string): Promise<void> {
+      try {
+        const url = targetSessionId 
+          ? `/api/session/logout/${sessionId}/${targetSessionId}`
+          : `/api/session/logout/${sessionId}`;
+        
+        await this.makeRequest('POST', url, undefined, { cache: false });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Logout from all sessions
+     */
+    async logoutAllSessions(sessionId: string): Promise<void> {
+      try {
+        await this.makeRequest('POST', `/api/session/logout-all/${sessionId}`, undefined, { cache: false });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Validate session
+     */
+    async validateSession(
+      sessionId: string, 
+      options: {
+        deviceFingerprint?: string;
+        useHeaderValidation?: boolean;
+      } = {}
+    ): Promise<{ 
+      valid: boolean; 
+      expiresAt: string; 
+      lastActivity: string; 
+      user: User;
+      sessionId?: string;
+      source?: string;
+    }> {
+      try {
+        const urlParams: any = {};
+        if (options.deviceFingerprint) urlParams.deviceFingerprint = options.deviceFingerprint;
+        if (options.useHeaderValidation) urlParams.useHeaderValidation = 'true';
+        return await this.makeRequest('GET', `/api/session/validate/${sessionId}`, urlParams, { cache: false });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Check username availability
+     */
+    async checkUsernameAvailability(username: string): Promise<{ available: boolean; message: string }> {
+      try {
+        return await this.makeRequest('GET', `/api/auth/check-username/${username}`, undefined, { cache: false });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Check email availability
+     */
+    async checkEmailAvailability(email: string): Promise<{ available: boolean; message: string }> {
+      try {
+        return await this.makeRequest('GET', `/api/auth/check-email/${email}`, undefined, { cache: false });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+  };
+}
+

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

@@ -0,0 +1,114 @@
+/**
+ * Developer API Methods Mixin
+ * 
+ * Provides methods for managing developer applications and API keys
+ */
+import type { OxyServicesBase } from '../OxyServices.base';
+import { CACHE_TIMES } from './mixinHelpers';
+
+export function OxyServicesDeveloperMixin<T extends typeof OxyServicesBase>(Base: T) {
+  return class extends Base {
+    constructor(...args: any[]) {
+      super(...(args as [any]));
+    }
+
+    /**
+     * Get developer apps for the current user
+     * @returns Array of developer apps
+     */
+    async getDeveloperApps(): Promise<any[]> {
+      try {
+        const res = await this.makeRequest<{ apps?: any[] }>('GET', '/api/developer/apps', undefined, {
+          cache: true,
+          cacheTTL: CACHE_TIMES.MEDIUM,
+        });
+        return res.apps || [];
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Create a new developer app
+     * @param data - Developer app configuration
+     * @returns Created developer app
+     */
+    async createDeveloperApp(data: {
+      name: string;
+      description?: string;
+      webhookUrl: string;
+      devWebhookUrl?: string;
+      scopes?: string[];
+    }): Promise<any> {
+      try {
+        const res = await this.makeRequest<{ app: any }>('POST', '/api/developer/apps', data, { cache: false });
+        return res.app;
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Get a specific developer app
+     */
+    async getDeveloperApp(appId: string): Promise<any> {
+      try {
+      const res = await this.makeRequest<{ app: any }>('GET', `/api/developer/apps/${appId}`, undefined, {
+        cache: true,
+        cacheTTL: CACHE_TIMES.LONG,
+      });
+        return res.app;
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Update a developer app
+     * @param appId - The developer app ID
+     * @param data - Updated app configuration
+     * @returns Updated developer app
+     */
+    async updateDeveloperApp(appId: string, data: {
+      name?: string;
+      description?: string;
+      webhookUrl?: string;
+      devWebhookUrl?: string;
+      scopes?: string[];
+    }): Promise<any> {
+      try {
+        const res = await this.makeRequest<{ app: any }>('PATCH', `/api/developer/apps/${appId}`, data, { cache: false });
+        return res.app;
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Regenerate API secret for a developer app
+     * @param appId - The developer app ID
+     * @returns App with new secret
+     */
+    async regenerateDeveloperAppSecret(appId: string): Promise<any> {
+      try {
+        return await this.makeRequest('POST', `/api/developer/apps/${appId}/regenerate-secret`, undefined, { cache: false });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Delete a developer app
+     * @param appId - The developer app ID
+     * @returns Deletion result
+     */
+    async deleteDeveloperApp(appId: string): Promise<any> {
+      try {
+        return await this.makeRequest('DELETE', `/api/developer/apps/${appId}`, undefined, { cache: false });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+  };
+}
+

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

@@ -0,0 +1,103 @@
+/**
+ * Device Methods Mixin
+ */
+import type { OxyServicesBase } from '../OxyServices.base';
+
+export function OxyServicesDevicesMixin<T extends typeof OxyServicesBase>(Base: T) {
+  return class extends Base {
+    constructor(...args: any[]) {
+      super(...(args as [any]));
+    }
+
+    /**
+     * Register a new device
+     * @param deviceData - Device information
+     * @returns Registered device object
+     */
+    async registerDevice(deviceData: any): Promise<any> {
+      try {
+        return await this.makeRequest('POST', '/api/devices', deviceData, { cache: false });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Get all devices for the current user
+     * @returns Array of user devices
+     */
+    async getUserDevices(): Promise<any[]> {
+      try {
+        return await this.makeRequest('GET', '/api/devices', undefined, {
+          cache: false, // Don't cache device list - always get fresh data
+        });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Remove a device
+     * @param deviceId - The device ID to remove
+     */
+    async removeDevice(deviceId: string): Promise<void> {
+      try {
+        await this.makeRequest('DELETE', `/api/devices/${deviceId}`, undefined, { cache: false });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Get device sessions for a given session ID
+     * Note: Not cached by default to ensure fresh data
+     * @param sessionId - The session ID
+     * @returns Array of device sessions
+     */
+    async getDeviceSessions(sessionId: string): Promise<any[]> {
+      try {
+        // Use makeRequest for consistent error handling and optional caching
+        // Cache disabled by default to ensure fresh session data
+        return await this.makeRequest<any[]>('GET', `/api/session/device/sessions/${sessionId}`, undefined, {
+          cache: false, // Don't cache sessions - always get fresh data
+          deduplicate: true, // Deduplicate concurrent requests for same sessionId
+        });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Logout all device sessions
+     * @param sessionId - The session ID
+     * @param deviceId - Optional device ID to target
+     * @param excludeCurrent - Whether to exclude the current session
+     * @returns Logout result
+     */
+    async logoutAllDeviceSessions(sessionId: string, deviceId?: string, excludeCurrent?: boolean): Promise<any> {
+      try {
+        const urlParams: any = {};
+        if (deviceId) urlParams.deviceId = deviceId;
+        if (excludeCurrent) urlParams.excludeCurrent = 'true';
+        return await this.makeRequest('POST', `/api/session/device/logout-all/${sessionId}`, urlParams, { cache: false });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Update device name
+     * @param sessionId - The session ID
+     * @param deviceName - New device name
+     * @returns Updated device object
+     */
+    async updateDeviceName(sessionId: string, deviceName: string): Promise<any> {
+      try {
+        return await this.makeRequest('PUT', `/api/session/device/name/${sessionId}`, { deviceName }, { cache: false });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+  };
+}
+

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

@@ -0,0 +1,111 @@
+/**
+ * Karma Methods Mixin
+ * 
+ * Provides methods for karma system management
+ */
+import type { OxyServicesBase } from '../OxyServices.base';
+import { CACHE_TIMES } from './mixinHelpers';
+
+export function OxyServicesKarmaMixin<T extends typeof OxyServicesBase>(Base: T) {
+  return class extends Base {
+    constructor(...args: any[]) {
+      super(...(args as [any]));
+    }
+    /**
+     * Get user karma
+     */
+    async getUserKarma(userId: string): Promise<any> {
+      try {
+        return await this.makeRequest('GET', `/api/karma/${userId}`, undefined, {
+          cache: true,
+          cacheTTL: 2 * 60 * 1000, // 2 minutes cache
+        });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Give karma to user
+     */
+    async giveKarma(userId: string, amount: number, reason?: string): Promise<any> {
+      try {
+        return await this.makeRequest('POST', `/api/karma/${userId}/give`, {
+          amount,
+          reason
+        }, { cache: false });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Get user karma total
+     * @param userId - The user ID
+     * @returns User karma total
+     */
+    async getUserKarmaTotal(userId: string): Promise<any> {
+      try {
+        return await this.makeRequest('GET', `/api/karma/${userId}/total`, undefined, {
+          cache: true,
+          cacheTTL: CACHE_TIMES.MEDIUM,
+        });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Get user karma history
+     * @param userId - The user ID
+     * @param limit - Optional limit for results
+     * @param offset - Optional offset for pagination
+     * @returns User karma history
+     */
+    async getUserKarmaHistory(userId: string, limit?: number, offset?: number): Promise<any> {
+      try {
+        const params: any = {};
+        if (limit) params.limit = limit;
+        if (offset) params.offset = offset;
+        
+        return await this.makeRequest('GET', `/api/karma/${userId}/history`, params, {
+          cache: true,
+          cacheTTL: CACHE_TIMES.MEDIUM,
+        });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Get karma leaderboard
+     * @returns Karma leaderboard
+     */
+    async getKarmaLeaderboard(): Promise<any> {
+      try {
+        return await this.makeRequest('GET', '/api/karma/leaderboard', undefined, {
+          cache: true,
+          cacheTTL: CACHE_TIMES.LONG,
+        });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Get karma rules
+     * @returns Karma rules
+     */
+    async getKarmaRules(): Promise<any> {
+      try {
+        return await this.makeRequest('GET', '/api/karma/rules', undefined, {
+          cache: true,
+          cacheTTL: CACHE_TIMES.EXTRA_LONG, // Rules don't change often
+        });
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+  };
+}
+