@oxyhq/services 5.16.35 → 5.16.36

package/src/core/services/AuthService.ts

@@ -1,153 +0,0 @@
-/**
- * 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/SessionTransportService.ts

@@ -1,69 +0,0 @@
-/**
- * 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/UserService.ts

@@ -1,125 +0,0 @@
-/**
- * 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

@@ -1,14 +0,0 @@
-/**
- * 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/shared/crypto/messageBuilders.ts

@@ -1,89 +0,0 @@
-/**
- * Canonical Message Builders
- * 
- * Creates standardized, canonical message formats for signing.
- * These formats are used consistently across Accounts, Services SDK, and API.
- */
-
-import type { SignedMessage, AuthChallengeResponse } from '../models/index';
-
-/**
- * Build authentication message for challenge-response
- * Format: auth:{publicKey}:{challenge}:{timestamp}
- */
-export function buildAuthMessage(
-  publicKey: string,
-  challenge: string,
-  timestamp: number
-): string {
-  return `auth:${publicKey}:${challenge}:${timestamp}`;
-}
-
-/**
- * Build registration message
- * Format: oxy:register:{publicKey}:{timestamp}
- */
-export function buildRegistrationMessage(
-  publicKey: string,
-  timestamp: number
-): string {
-  return `oxy:register:${publicKey}:${timestamp}`;
-}
-
-/**
- * Build request signing message
- * Format: request:{publicKey}:{timestamp}:{canonicalData}
- */
-export function buildRequestMessage(
-  publicKey: string,
-  timestamp: number,
-  data: Record<string, unknown>
-): string {
-  // Create canonical string representation
-  const sortedKeys = Object.keys(data).sort();
-  const canonicalParts = sortedKeys.map(key => `${key}:${JSON.stringify(data[key])}`);
-  const canonicalString = canonicalParts.join('|');
-  
-  return `request:${publicKey}:${timestamp}:${canonicalString}`;
-}
-
-/**
- * Create canonical data representation for signing
- * Sorts keys and creates a consistent string representation
- */
-export function canonicalizeData(data: Record<string, unknown>): string {
-  const sortedKeys = Object.keys(data).sort();
-  const canonicalParts = sortedKeys.map(key => `${key}:${JSON.stringify(data[key])}`);
-  return canonicalParts.join('|');
-}
-
-/**
- * Build auth challenge response payload
- * Helper to construct the signed challenge response
- */
-export function buildAuthChallengeResponse(
-  publicKey: string,
-  challenge: string,
-  signature: string,
-  timestamp: number
-): AuthChallengeResponse {
-  return {
-    challenge,
-    publicKey,
-    signature,
-    timestamp,
-  };
-}
-
-/**
- * Validate timestamp freshness
- * Ensures signed messages are not too old
- */
-export function isTimestampFresh(
-  timestamp: number,
-  maxAgeMs: number = 5 * 60 * 1000 // 5 minutes default
-): boolean {
-  const now = Date.now();
-  return (now - timestamp) <= maxAgeMs && timestamp <= now;
-}
-

package/src/shared/crypto/platform.ts

@@ -1,140 +0,0 @@
-/**
- * Platform Detection and Adapters
- * 
- * Provides environment detection and platform-specific crypto adapters
- * to support Node.js, React Native, and Web environments.
- */
-
-/**
- * Platform types
- */
-export type Platform = 'node' | 'react-native' | 'web';
-
-/**
- * Platform detection utilities
- */
-export const PlatformDetector = {
-  /**
-   * Detect current platform
-   */
-  detect(): Platform {
-    if (typeof window === 'undefined' && typeof process !== 'undefined' && process.versions?.node) {
-      return 'node';
-    }
-    if (typeof navigator !== 'undefined' && navigator.product === 'ReactNative') {
-      return 'react-native';
-    }
-    return 'web';
-  },
-
-  /**
-   * Check if running in Node.js
-   */
-  isNode(): boolean {
-    return this.detect() === 'node';
-  },
-
-  /**
-   * Check if running in React Native
-   */
-  isReactNative(): boolean {
-    return this.detect() === 'react-native';
-  },
-
-  /**
-   * Check if running in Web browser
-   */
-  isWeb(): boolean {
-    return this.detect() === 'web';
-  },
-};
-
-/**
- * Crypto adapter interface
- * Platform-specific implementations must implement this interface
- */
-export interface CryptoAdapter {
-  /**
-   * Generate random bytes
-   */
-  randomBytes(size: number): Promise<Uint8Array>;
-
-  /**
-   * Compute SHA-256 hash
-   */
-  sha256(message: string): Promise<string>;
-
-  /**
-   * Synchronous SHA-256 hash (Node.js only)
-   */
-  sha256Sync?(message: string): string;
-}
-
-/**
- * Get the appropriate crypto adapter for the current platform
- */
-export async function getCryptoAdapter(): Promise<CryptoAdapter> {
-  const platform = PlatformDetector.detect();
-
-  if (platform === 'node') {
-    // eslint-disable-next-line @typescript-eslint/no-implied-eval
-    const getCrypto = new Function('return require("crypto")');
-    const crypto = getCrypto();
-    
-    return {
-      async randomBytes(size: number): Promise<Uint8Array> {
-        return new Uint8Array(crypto.randomBytes(size));
-      },
-      async sha256(message: string): Promise<string> {
-        return crypto.createHash('sha256').update(message).digest('hex');
-      },
-      sha256Sync(message: string): string {
-        return crypto.createHash('sha256').update(message).digest('hex');
-      },
-    };
-  }
-
-  if (platform === 'react-native') {
-    // Lazy load expo-crypto (peer dependency)
-    try {
-      // @ts-ignore - expo-crypto is an optional peer dependency
-      const ExpoCrypto = await import('expo-crypto');
-      
-      return {
-        async randomBytes(size: number): Promise<Uint8Array> {
-          const bytes = await ExpoCrypto.getRandomBytesAsync(size);
-          return new Uint8Array(bytes);
-        },
-        async sha256(message: string): Promise<string> {
-          return ExpoCrypto.digestStringAsync(
-            ExpoCrypto.CryptoDigestAlgorithm.SHA256,
-            message
-          );
-        },
-      };
-    } catch (error) {
-      throw new Error(
-        `expo-crypto is required in React Native environment: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-
-  // Web platform - use Web Crypto API
-  if (typeof window !== 'undefined' && window.crypto) {
-    return {
-      async randomBytes(size: number): Promise<Uint8Array> {
-        return window.crypto.getRandomValues(new Uint8Array(size));
-      },
-      async sha256(message: string): Promise<string> {
-        const encoder = new TextEncoder();
-        const data = encoder.encode(message);
-        const hashBuffer = await window.crypto.subtle.digest('SHA-256', data);
-        const hashArray = Array.from(new Uint8Array(hashBuffer));
-        return hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
-      },
-    };
-  }
-
-  throw new Error('No suitable crypto implementation found for current platform');
-}
-