@oxyhq/services 5.16.33 → 5.16.35

package/src/core/services/AuthService.ts

@@ -0,0 +1,153 @@
+/**
+ * Auth Service
+ * 
+ * Handles authentication operations:
+ * - Challenge retrieval
+ * - Signing orchestration (delegated to Accounts/KeyManager)
+ * - Session verification
+ * - Access token retrieval
+ * - Registration
+ */
+
+import type { OxyConfig } from '../../models/interfaces';
+import type { User, LoginResponse, ChallengePayload } from '../../shared';
+import { HttpService } from '../HttpService';
+import { SignatureService } from '../../crypto/signatureService';
+
+export interface PublicKeyCheckResponse {
+  registered: boolean;
+  message: string;
+}
+
+export class AuthService {
+  private httpService: HttpService;
+
+  constructor(config: OxyConfig) {
+    this.httpService = new HttpService(config);
+  }
+
+  /**
+   * Check if a public key is registered on the server
+   */
+  async checkPublicKeyRegistered(publicKey: string): Promise<PublicKeyCheckResponse> {
+    try {
+      return await this.httpService.request<PublicKeyCheckResponse>({
+        method: 'GET',
+        url: `/api/auth/check-publickey?publicKey=${encodeURIComponent(publicKey)}`,
+        cache: true,
+        cacheTTL: 2 * 60 * 1000,
+      });
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  /**
+   * Request an authentication challenge
+   */
+  async requestChallenge(publicKey: string): Promise<ChallengePayload> {
+    try {
+      return await this.httpService.request<ChallengePayload>({
+        method: 'POST',
+        url: '/api/auth/challenge',
+        data: { publicKey },
+        cache: false,
+      });
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  /**
+   * Verify a challenge and authenticate (creates session)
+   * This orchestrates signing via SignatureService (which uses KeyManager)
+   */
+  async verifyChallenge(challenge: string): Promise<LoginResponse> {
+    try {
+      // Sign the challenge using SignatureService (requires private key)
+      const signedChallenge = await SignatureService.signChallenge(challenge);
+      
+      // Verify challenge and get session
+      return await this.httpService.request<LoginResponse>({
+        method: 'POST',
+        url: '/api/auth/verify',
+        data: {
+          publicKey: signedChallenge.publicKey,
+          challenge: challenge,
+          signature: signedChallenge.challenge,
+          timestamp: signedChallenge.timestamp,
+        },
+        cache: false,
+      });
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  /**
+   * Register a new identity with the server
+   */
+  async register(publicKey: string, signature: string, timestamp: number, username?: string, email?: string): Promise<User> {
+    try {
+      return await this.httpService.request<User>({
+        method: 'POST',
+        url: '/api/auth/register',
+        data: {
+          publicKey,
+          signature,
+          timestamp,
+          username,
+          email,
+        },
+        cache: false,
+      });
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  /**
+   * Register using current identity (signs automatically)
+   */
+  async registerCurrentIdentity(username?: string, email?: string): Promise<User> {
+    try {
+      const { signature, publicKey, timestamp } = await SignatureService.createRegistrationSignature();
+      return this.register(publicKey, signature, timestamp, username, email);
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  /**
+   * Get user by public key
+   */
+  async getUserByPublicKey(publicKey: string): Promise<User> {
+    try {
+      return await this.httpService.request<User>({
+        method: 'GET',
+        url: `/api/auth/user/${encodeURIComponent(publicKey)}`,
+        cache: true,
+        cacheTTL: 2 * 60 * 1000,
+      });
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  /**
+   * Get user by session ID
+   */
+  async getUserBySession(sessionId: string): Promise<User> {
+    try {
+      return await this.httpService.request<User>({
+        method: 'GET',
+        url: `/api/auth/user/session/${encodeURIComponent(sessionId)}`,
+        cache: true,
+        cacheTTL: 2 * 60 * 1000,
+      });
+    } catch (error) {
+      throw error;
+    }
+  }
+}
+

package/src/core/services/SessionService.ts

@@ -8,20 +8,18 @@
  * - Single source of truth for session operations
  * - Handles both online and offline sessions
  * - Integrates with TokenService for token management
- * - publicKey is the canonical user identity (primary identifier)
- * - Sessions are bound to local identity stored in Accounts app
+ * - userId is always MongoDB ObjectId, never publicKey
  */
 
 import type { OxyServices } from '../OxyServices';
 import { tokenService } from './TokenService';
 import type { ClientSession, SessionLoginResponse } from '../../models/session';
-import type { User } from '../../models/interfaces';
+import type { User } from '../../shared';
 
 export interface Session {
   sessionId: string;
   deviceId: string;
-  publicKey: string;  // Canonical user identity - PRIMARY IDENTIFIER
-  userId?: string;     // MongoDB ObjectId (internal backend reference, optional)
+  userId: string;  // MongoDB ObjectId - PRIMARY IDENTIFIER
   expiresAt: string;
   lastActive: string;
   isCurrent: boolean;

package/src/core/services/SessionTransportService.ts

@@ -0,0 +1,69 @@
+/**
+ * Session Transport Service
+ * 
+ * Uses shared transport abstraction for WebSocket/SSE/polling
+ * Provides unified interface for session status updates
+ */
+
+import type { OxyConfig } from '../../models/interfaces';
+import {
+  TransportFactory,
+  type TransportConfig,
+  type TransportCallbacks,
+  type TransportUpdate,
+} from '../../shared';
+
+export class SessionTransportService {
+  private transport: any = null;
+  private config: OxyConfig;
+
+  constructor(config: OxyConfig) {
+    this.config = config;
+  }
+
+  /**
+   * Connect to session status updates
+   * Automatically chooses best available transport (WebSocket > SSE > Polling)
+   */
+  async connect(
+    sessionToken: string,
+    callbacks: TransportCallbacks
+  ): Promise<void> {
+    const transportConfig: TransportConfig = {
+      baseURL: this.config.baseURL,
+      namespace: 'auth-session',
+      sessionToken,
+      pollingInterval: 3000, // 3 seconds
+      reconnectAttempts: 3,
+      reconnectDelay: 1000,
+    };
+
+    this.transport = await TransportFactory.create(transportConfig, callbacks);
+    await this.transport.connect();
+  }
+
+  /**
+   * Disconnect from session updates
+   */
+  disconnect(): void {
+    if (this.transport) {
+      this.transport.disconnect();
+      this.transport = null;
+    }
+  }
+
+  /**
+   * Check if currently connected
+   */
+  isConnected(): boolean {
+    return this.transport?.isConnected() ?? false;
+  }
+
+  /**
+   * Get the transport type being used
+   */
+  getTransportType(): string {
+    return this.transport?.getType() ?? 'none';
+  }
+}
+

package/src/core/services/TokenService.ts

@@ -8,17 +8,17 @@
  * - Single storage location (no duplication)
  * - Automatic token refresh when expiring soon
  * - Type-safe token payload handling
- * - publicKey is the canonical user identity
+ * - userId is always MongoDB ObjectId, never publicKey
  */
 
 import { jwtDecode } from 'jwt-decode';
 
 /**
  * AccessTokenPayload - Matches the token payload structure from API
- * publicKey is the canonical user identity (ECDSA secp256k1 public key)
+ * userId is always MongoDB ObjectId (24 hex characters), never publicKey
  */
 interface AccessTokenPayload {
-  publicKey: string;   // User's public key - CANONICAL USER IDENTITY
+  userId: string;      // MongoDB ObjectId - PRIMARY IDENTIFIER
   sessionId: string;   // Session UUID
   deviceId: string;   // Device identifier
   type: 'access';
@@ -116,29 +116,21 @@ class TokenService {
   }
 
   /**
-   * Get publicKey from current access token
-   * Returns the user's public key (canonical user identity)
+   * Get userId from current access token
+   * Returns MongoDB ObjectId (never publicKey)
    */
-  getPublicKeyFromToken(): string | null {
+  getUserIdFromToken(): string | null {
     const token = this.tokenStore.accessToken;
     if (!token) return null;
 
     try {
       const decoded = jwtDecode<AccessTokenPayload>(token);
-      return decoded.publicKey || null;
+      return decoded.userId || null;
     } catch {
       return null;
     }
   }
 
-  /**
-   * @deprecated Use getPublicKeyFromToken() instead. This method is kept for backward compatibility.
-   * Get userId from current access token (returns publicKey, not MongoDB ObjectId)
-   */
-  getUserIdFromToken(): string | null {
-    return this.getPublicKeyFromToken();
-  }
-
   /**
    * Refresh access token if expiring soon
    * Returns promise that resolves when token is refreshed (or already valid)
@@ -201,10 +193,10 @@ class TokenService {
         throw new Error('No access token in refresh response');
       }
 
-      // Validate new token has publicKey (canonical user identity)
+      // Validate new token has correct userId format (ObjectId)
       const newDecoded = jwtDecode<AccessTokenPayload>(newToken);
-      if (!newDecoded.publicKey) {
-        throw new Error('Token missing publicKey after refresh');
+      if (newDecoded.userId && !/^[0-9a-fA-F]{24}$/.test(newDecoded.userId)) {
+        throw new Error(`Invalid userId format in refreshed token: ${newDecoded.userId.substring(0, 20)}...`);
       }
 
       this.setTokens(newToken);

package/src/core/services/UserService.ts

@@ -0,0 +1,125 @@
+/**
+ * User Service
+ * 
+ * Handles user profile operations (no key handling):
+ * - Profile fetch/update
+ * - Profile search
+ * - User recommendations
+ */
+
+import type { OxyConfig } from '../../models/interfaces';
+import type { User, SearchProfilesResponse, PaginationInfo } from '../../shared';
+import { HttpService } from '../HttpService';
+
+export interface PaginationParams {
+  limit?: number;
+  offset?: number;
+}
+
+export class UserService {
+  private httpService: HttpService;
+
+  constructor(config: OxyConfig) {
+    this.httpService = new HttpService(config);
+  }
+
+  /**
+   * Get user profile by ID
+   */
+  async getUserById(userId: string): Promise<User> {
+    try {
+      return await this.httpService.request<User>({
+        method: 'GET',
+        url: `/api/profiles/${userId}`,
+        cache: true,
+        cacheTTL: 5 * 60 * 1000,
+      });
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  /**
+   * Get profile by username
+   */
+  async getProfileByUsername(username: string): Promise<User> {
+    try {
+      return await this.httpService.request<User>({
+        method: 'GET',
+        url: `/api/profiles/username/${username}`,
+        cache: true,
+        cacheTTL: 5 * 60 * 1000,
+      });
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  /**
+   * Search user profiles
+   */
+  async searchProfiles(query: string, pagination?: PaginationParams): Promise<SearchProfilesResponse> {
+    try {
+      const params = new URLSearchParams();
+      params.set('query', query);
+      if (pagination?.limit) params.set('limit', pagination.limit.toString());
+      if (pagination?.offset) params.set('offset', pagination.offset.toString());
+
+      const response = await this.httpService.request<SearchProfilesResponse | User[]>({
+        method: 'GET',
+        url: `/api/profiles/search?${params.toString()}`,
+        cache: true,
+        cacheTTL: 2 * 60 * 1000,
+      });
+
+      // Handle response format
+      if (Array.isArray(response)) {
+        const limit = pagination?.limit ?? response.length;
+        const paginationInfo: PaginationInfo = {
+          total: response.length,
+          limit,
+          offset: pagination?.offset ?? 0,
+          hasMore: limit > 0 && response.length === limit,
+        };
+        return { data: response, pagination: paginationInfo };
+      }
+
+      return response;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  /**
+   * Get profile recommendations
+   */
+  async getProfileRecommendations(): Promise<User[]> {
+    try {
+      return await this.httpService.request<User[]>({
+        method: 'GET',
+        url: '/api/profiles/recommendations',
+        cache: true,
+        cacheTTL: 5 * 60 * 1000,
+      });
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  /**
+   * Update user profile
+   */
+  async updateProfile(updates: Partial<User>): Promise<User> {
+    try {
+      return await this.httpService.request<User>({
+        method: 'PATCH',
+        url: '/api/profiles/me',
+        data: updates,
+        cache: false,
+      });
+    } catch (error) {
+      throw error;
+    }
+  }
+}
+

package/src/core/services/index.ts

@@ -0,0 +1,14 @@
+/**
+ * Focused Services
+ * 
+ * Single-responsibility services replacing the mixin pattern:
+ * - AuthService: Authentication, challenges, registration
+ * - SessionService: Session management (already exists)
+ * - UserService: User profile operations
+ */
+
+export { AuthService } from './AuthService';
+export { sessionService } from './SessionService';
+export { UserService } from './UserService';
+export { tokenService } from './TokenService';
+

package/src/crypto/index.ts

@@ -3,6 +3,15 @@
  * 
  * Provides cryptographic identity management for the Oxy ecosystem.
  * Handles key generation, secure storage, and digital signatures.
+ * 
+ * ⚠️ IMPORTANT: KeyManager is primarily intended for use in the Oxy Accounts app.
+ * While it's exported here for convenience, third-party applications should NOT
+ * generate or store user identities. The Accounts app is the identity wallet.
+ * 
+ * For third-party apps:
+ * - Use SignatureService for signing operations (but keys come from Accounts app)
+ * - Do NOT call KeyManager.createIdentity() or KeyManager.importKeyPair()
+ * - The Oxy Accounts app handles all identity generation and key storage
  */
 
 // Import polyfills first - this ensures Buffer is available for crypto libraries

package/src/crypto/keyManager.ts

@@ -8,6 +8,7 @@
 import { ec as EC } from 'elliptic';
 import type { ECKeyPair } from 'elliptic';
 import { Platform } from 'react-native';
+import { shortenPublicKey as sharedShortenPublicKey } from '../shared';
 
 // Lazy imports for React Native specific modules
 let SecureStore: typeof import('expo-secure-store') | null = null;
@@ -539,8 +540,8 @@ export class KeyManager {
    * Format: first 8 chars...last 8 chars
    */
   static shortenPublicKey(publicKey: string): string {
-    if (publicKey.length <= 20) return publicKey;
-    return `${publicKey.slice(0, 8)}...${publicKey.slice(-8)}`;
+    // Use shared utility
+    return sharedShortenPublicKey(publicKey);
   }
 }