@oxyhq/services 5.26.3 → 5.27.0

package/dist/web/types/core/mixins/OxyServices.redirect.d.ts

@@ -0,0 +1,245 @@
+import type { OxyServicesBase } from '../OxyServices.base';
+import type { SessionLoginResponse } from '../../models/session';
+export interface RedirectAuthOptions {
+    redirectUri?: string;
+    mode?: 'login' | 'signup';
+    preserveUrl?: boolean;
+}
+/**
+ * Redirect-based Cross-Domain Authentication Mixin
+ *
+ * Implements traditional OAuth2 redirect flow as a fallback when popup or
+ * FedCM are not available or fail (e.g., mobile browsers, popup blockers).
+ *
+ * Flow:
+ * 1. Save current URL
+ * 2. Redirect to auth.oxy.so/login
+ * 3. User signs in
+ * 4. Redirect back with token in URL
+ * 5. Extract token, restore session, clean URL
+ *
+ * Features:
+ * - Works on all browsers (including old mobile browsers)
+ * - Automatic URL cleanup after auth
+ * - State preservation option
+ * - CSRF protection via state parameter
+ *
+ * Trade-offs:
+ * - Loses JavaScript app state (full page navigation)
+ * - Visible redirect (user sees navigation)
+ * - Slower perceived performance
+ */
+export declare function OxyServicesRedirectAuthMixin<T extends typeof OxyServicesBase>(Base: T): {
+    new (...args: any[]): {
+        /**
+         * Sign in using full page redirect
+         *
+         * Redirects the user to auth.oxy.so for authentication. After successful
+         * sign-in, the user will be redirected back to the current page (or custom
+         * redirect URI) with authentication tokens in the URL.
+         *
+         * Call handleAuthCallback() on app startup to complete the flow.
+         *
+         * @param options - Redirect configuration options
+         *
+         * @example
+         * ```typescript
+         * // Initiate sign-in
+         * const handleSignIn = () => {
+         *   oxyServices.signInWithRedirect();
+         * };
+         *
+         * // Handle callback on app startup
+         * useEffect(() => {
+         *   const session = oxyServices.handleAuthCallback();
+         *   if (session) {
+         *     setUser(session.user);
+         *   }
+         * }, []);
+         * ```
+         */
+        signInWithRedirect(options?: RedirectAuthOptions): void;
+        /**
+         * Sign up using full page redirect
+         *
+         * Same as signInWithRedirect but opens the signup page by default.
+         */
+        signUpWithRedirect(options?: RedirectAuthOptions): void;
+        /**
+         * Handle authentication callback
+         *
+         * Call this on app startup to check if the current page load is a
+         * redirect back from the authentication server. If it is, this method
+         * will extract the tokens, store them, and clean up the URL.
+         *
+         * @returns Session data if this is a callback, null otherwise
+         * @throws {OxyAuthenticationError} If state validation fails (CSRF attack)
+         *
+         * @example
+         * ```typescript
+         * // In your app's root component or startup logic
+         * useEffect(() => {
+         *   try {
+         *     const session = oxyServices.handleAuthCallback();
+         *     if (session) {
+         *       console.log('Logged in:', session.user);
+         *       setUser(session.user);
+         *     } else {
+         *       // Not a callback, check for existing session
+         *       const restored = oxyServices.restoreSession();
+         *       if (!restored) {
+         *         // No session, show login button
+         *       }
+         *     }
+         *   } catch (error) {
+         *     console.error('Auth callback failed:', error);
+         *   }
+         * }, []);
+         * ```
+         */
+        handleAuthCallback(): SessionLoginResponse | null;
+        /**
+         * Restore session from storage
+         *
+         * Attempts to restore a previously authenticated session from localStorage.
+         * Call this on app startup if handleAuthCallback() returns null.
+         *
+         * @returns True if session was restored, false otherwise
+         *
+         * @example
+         * ```typescript
+         * useEffect(() => {
+         *   const session = oxyServices.handleAuthCallback();
+         *   if (!session) {
+         *     const restored = oxyServices.restoreSession();
+         *     if (!restored) {
+         *       // No session, user needs to sign in
+         *       setShowLogin(true);
+         *     }
+         *   }
+         * }, []);
+         * ```
+         */
+        restoreSession(): boolean;
+        /**
+         * Clear stored session
+         *
+         * Removes all authentication data from storage. Call this on logout.
+         */
+        clearStoredSession(): void;
+        /**
+         * Get stored session ID
+         */
+        getStoredSessionId(): string | null;
+        /**
+         * Build authentication URL with query parameters
+         *
+         * @private
+         */
+        buildAuthUrl(params: {
+            mode: string;
+            redirectUri: string;
+            state: string;
+            nonce: string;
+            clientId: string;
+        }): string;
+        /**
+         * Store tokens in localStorage
+         *
+         * @private
+         */
+        storeTokens(accessToken: string, sessionId: string): void;
+        /**
+         * Generate cryptographically secure state for CSRF protection
+         *
+         * @private
+         */
+        generateState(): string;
+        /**
+         * Generate nonce for replay attack prevention
+         *
+         * @private
+         */
+        generateNonce(): string;
+        /**
+         * Store auth state in session storage
+         *
+         * @private
+         */
+        storeAuthState(state: string, nonce: string): void;
+        /**
+         * Get stored state
+         *
+         * @private
+         */
+        getStoredState(): string | null;
+        /**
+         * Clear auth state from storage
+         *
+         * @private
+         */
+        clearAuthState(): void;
+        /**
+         * Save pre-authentication URL to restore later
+         *
+         * @private
+         */
+        savePreAuthUrl(url: string): void;
+        /**
+         * Clean authentication parameters from URL
+         *
+         * @private
+         */
+        cleanAuthCallbackUrl(url: URL): void;
+        httpService: import("../HttpService").HttpService;
+        cloudURL: string;
+        config: import("../OxyServices.base").OxyConfig;
+        makeRequest<T_1>(method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE", url: string, data?: any, options?: import("../HttpService").RequestOptions): Promise<T_1>;
+        getBaseURL(): string;
+        getClient(): import("../HttpService").HttpService;
+        getMetrics(): {
+            totalRequests: number;
+            successfulRequests: number;
+            failedRequests: number;
+            cacheHits: number;
+            cacheMisses: number;
+            averageResponseTime: number;
+        };
+        clearCache(): void;
+        clearCacheEntry(key: string): void;
+        getCacheStats(): {
+            size: number;
+            hits: number;
+            misses: number;
+            hitRate: number;
+        };
+        getCloudURL(): string;
+        setTokens(accessToken: string, refreshToken?: string): void;
+        clearTokens(): void;
+        getCurrentUserId(): string | null;
+        hasValidToken(): boolean;
+        getAccessToken(): string | null;
+        waitForAuth(timeoutMs?: number): Promise<boolean>;
+        withAuthRetry<T_1>(operation: () => Promise<T_1>, operationName: string, options?: {
+            maxRetries?: number;
+            retryDelay?: number;
+            authTimeoutMs?: number;
+        }): Promise<T_1>;
+        validate(): Promise<boolean>;
+        handleError(error: unknown): Error;
+        healthCheck(): Promise<{
+            status: string;
+            users?: number;
+            timestamp?: string;
+            [key: string]: any;
+        }>;
+    };
+    readonly AUTH_URL: "https://auth.oxy.so";
+    readonly TOKEN_STORAGE_KEY: "oxy_access_token";
+    readonly SESSION_STORAGE_KEY: "oxy_session_id";
+    readonly STATE_STORAGE_KEY: "oxy_auth_state";
+    readonly PRE_AUTH_URL_KEY: "oxy_pre_auth_url";
+    readonly NONCE_STORAGE_KEY: "oxy_auth_nonce";
+    __resetTokensForTests(): void;
+} & T;
+export { OxyServicesRedirectAuthMixin as RedirectAuthMixin };

package/dist/web/types/core/mixins/OxyServices.security.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Security Methods Mixin
+ */
+import type { OxyServicesBase } from '../OxyServices.base';
+import type { SecurityActivity, SecurityActivityResponse, SecurityEventType } from '../../models/interfaces';
+export declare function OxyServicesSecurityMixin<T extends typeof OxyServicesBase>(Base: T): {
+    new (...args: any[]): {
+        /**
+         * Get user's security activity with pagination
+         * @param limit - Number of results (default: 50, max: 100)
+         * @param offset - Pagination offset (default: 0)
+         * @param eventType - Optional filter by event type
+         * @returns Security activity response with pagination
+         */
+        getSecurityActivity(limit?: number, offset?: number, eventType?: SecurityEventType): Promise<SecurityActivityResponse>;
+        /**
+         * Get recent security activity (convenience method)
+         * @param limit - Number of recent events to fetch (default: 10)
+         * @returns Array of recent security activities
+         */
+        getRecentSecurityActivity(limit?: number): Promise<SecurityActivity[]>;
+        /**
+         * Log private key exported event
+         * @param deviceId - Optional device ID for tracking
+         * @returns Promise that resolves when event is logged
+         */
+        logPrivateKeyExported(deviceId?: string): Promise<void>;
+        /**
+         * Log backup created event
+         * @param deviceId - Optional device ID for tracking
+         * @returns Promise that resolves when event is logged
+         */
+        logBackupCreated(deviceId?: string): Promise<void>;
+        httpService: import("../HttpService").HttpService;
+        cloudURL: string;
+        config: import("../OxyServices.base").OxyConfig;
+        makeRequest<T_1>(method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE", url: string, data?: any, options?: import("../HttpService").RequestOptions): Promise<T_1>;
+        getBaseURL(): string;
+        getClient(): import("../HttpService").HttpService;
+        getMetrics(): {
+            totalRequests: number;
+            successfulRequests: number;
+            failedRequests: number;
+            cacheHits: number;
+            cacheMisses: number;
+            averageResponseTime: number;
+        };
+        clearCache(): void;
+        clearCacheEntry(key: string): void;
+        getCacheStats(): {
+            size: number;
+            hits: number;
+            misses: number;
+            hitRate: number;
+        };
+        getCloudURL(): string;
+        setTokens(accessToken: string, refreshToken?: string): void;
+        clearTokens(): void;
+        getCurrentUserId(): string | null;
+        hasValidToken(): boolean;
+        getAccessToken(): string | null;
+        waitForAuth(timeoutMs?: number): Promise<boolean>;
+        withAuthRetry<T_1>(operation: () => Promise<T_1>, operationName: string, options?: {
+            maxRetries?: number;
+            retryDelay?: number;
+            authTimeoutMs?: number;
+        }): Promise<T_1>;
+        validate(): Promise<boolean>;
+        handleError(error: unknown): Error;
+        healthCheck(): Promise<{
+            status: string;
+            users?: number;
+            timestamp?: string;
+            [key: string]: any;
+        }>;
+    };
+    __resetTokensForTests(): void;
+} & T;

package/dist/web/types/core/mixins/OxyServices.user.d.ts

@@ -0,0 +1,184 @@
+/**
+ * User Management Methods Mixin
+ */
+import type { User, Notification, SearchProfilesResponse } from '../../models/interfaces';
+import type { OxyServicesBase } from '../OxyServices.base';
+import { type PaginationParams } from '../../utils/apiUtils';
+export declare function OxyServicesUserMixin<T extends typeof OxyServicesBase>(Base: T): {
+    new (...args: any[]): {
+        /**
+         * Get profile by username
+         */
+        getProfileByUsername(username: string): Promise<User>;
+        /**
+         * Search user profiles
+         */
+        searchProfiles(query: string, pagination?: PaginationParams): Promise<SearchProfilesResponse>;
+        /**
+         * Get profile recommendations
+         */
+        getProfileRecommendations(): Promise<Array<{
+            id: string;
+            username: string;
+            name?: {
+                first?: string;
+                last?: string;
+                full?: string;
+            };
+            description?: string;
+            _count?: {
+                followers: number;
+                following: number;
+            };
+            [key: string]: any;
+        }>>;
+        /**
+         * Get user by ID
+         */
+        getUserById(userId: string): Promise<User>;
+        /**
+         * Get current user
+         */
+        getCurrentUser(): Promise<User>;
+        /**
+         * Update user profile
+         * TanStack Query handles offline queuing automatically
+         */
+        updateProfile(updates: Record<string, any>): Promise<User>;
+        /**
+         * Get privacy settings for a user
+         * @param userId - The user ID (defaults to current user)
+         */
+        getPrivacySettings(userId?: string): Promise<any>;
+        /**
+         * Update privacy settings
+         * @param settings - Partial privacy settings object
+         * @param userId - The user ID (defaults to current user)
+         */
+        updatePrivacySettings(settings: Record<string, any>, userId?: string): Promise<any>;
+        /**
+         * Request account verification
+         */
+        requestAccountVerification(reason: string, evidence?: string): Promise<{
+            message: string;
+            requestId: string;
+        }>;
+        /**
+         * Download account data export
+         */
+        downloadAccountData(format?: "json" | "csv"): Promise<Blob>;
+        /**
+         * Delete account permanently
+         * @param password - User password for confirmation
+         * @param confirmText - Confirmation text (usually username)
+         */
+        deleteAccount(password: string, confirmText: string): Promise<{
+            message: string;
+        }>;
+        /**
+         * Follow a user
+         */
+        followUser(userId: string): Promise<{
+            success: boolean;
+            message: string;
+        }>;
+        /**
+         * Unfollow a user
+         */
+        unfollowUser(userId: string): Promise<{
+            success: boolean;
+            message: string;
+        }>;
+        /**
+         * Get follow status
+         */
+        getFollowStatus(userId: string): Promise<{
+            isFollowing: boolean;
+        }>;
+        /**
+         * Get user followers
+         */
+        getUserFollowers(userId: string, pagination?: PaginationParams): Promise<{
+            followers: User[];
+            total: number;
+            hasMore: boolean;
+        }>;
+        /**
+         * Get user following
+         */
+        getUserFollowing(userId: string, pagination?: PaginationParams): Promise<{
+            following: User[];
+            total: number;
+            hasMore: boolean;
+        }>;
+        /**
+         * Get notifications
+         */
+        getNotifications(): Promise<Notification[]>;
+        /**
+         * Get unread notification count
+         */
+        getUnreadCount(): Promise<number>;
+        /**
+         * Create notification
+         */
+        createNotification(data: Partial<Notification>): Promise<Notification>;
+        /**
+         * Mark notification as read
+         */
+        markNotificationAsRead(notificationId: string): Promise<void>;
+        /**
+         * Mark all notifications as read
+         */
+        markAllNotificationsAsRead(): Promise<void>;
+        /**
+         * Delete notification
+         */
+        deleteNotification(notificationId: string): Promise<void>;
+        httpService: import("../HttpService").HttpService;
+        cloudURL: string;
+        config: import("../OxyServices.base").OxyConfig;
+        makeRequest<T_1>(method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE", url: string, data?: any, options?: import("../HttpService").RequestOptions): Promise<T_1>;
+        getBaseURL(): string;
+        getClient(): import("../HttpService").HttpService;
+        getMetrics(): {
+            totalRequests: number;
+            successfulRequests: number;
+            failedRequests: number;
+            cacheHits: number;
+            cacheMisses: number;
+            averageResponseTime: number;
+        };
+        clearCache(): void;
+        clearCacheEntry(key: string): void;
+        getCacheStats(): {
+            size: number;
+            hits: number;
+            misses: number;
+            hitRate: number;
+        };
+        getCloudURL(): string;
+        setTokens(accessToken: string, refreshToken?: string): void;
+        clearTokens(): void;
+        getCurrentUserId(): string | null;
+        hasValidToken(): boolean;
+        getAccessToken(): string | null;
+        waitForAuth(timeoutMs?: number): Promise<boolean>;
+        withAuthRetry<T_1>(operation: () => Promise<T_1>, operationName: string, options?: {
+            maxRetries?: number;
+            retryDelay?: number;
+            authTimeoutMs?: number;
+        }): Promise<T_1>;
+        validate(): Promise<boolean>;
+        handleError(error: unknown): Error;
+        healthCheck(): Promise<{
+            status: string;
+            users?: number;
+            timestamp? /**
+             * Get user followers
+             */: string;
+            [key: string]: any;
+        }>;
+    };
+    __resetTokensForTests(): void;
+} & T;

package/dist/web/types/core/mixins/OxyServices.utility.d.ts

@@ -0,0 +1,93 @@
+import type { ApiError } from '../../models/interfaces';
+import type { OxyServicesBase } from '../OxyServices.base';
+export declare function OxyServicesUtilityMixin<T extends typeof OxyServicesBase>(Base: T): {
+    new (...args: any[]): {
+        /**
+         * Fetch link metadata
+         */
+        fetchLinkMetadata(url: string): Promise<{
+            url: string;
+            title: string;
+            description: string;
+            image?: string;
+        }>;
+        /**
+         * 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;
+        }): (req: any, res: any, next: any) => any;
+        httpService: import("../HttpService").HttpService;
+        cloudURL: string;
+        config: import("../OxyServices.base").OxyConfig;
+        makeRequest<T_1>(method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE", url: string, data?: any, options?: import("../HttpService").RequestOptions): Promise<T_1>;
+        getBaseURL(): string;
+        getClient(): import("../HttpService").HttpService;
+        getMetrics(): {
+            totalRequests: number;
+            successfulRequests: number;
+            failedRequests: number;
+            cacheHits: number;
+            cacheMisses: number;
+            averageResponseTime: number;
+        };
+        clearCache(): void;
+        clearCacheEntry(key: string): void;
+        getCacheStats(): {
+            size: number;
+            hits: number;
+            misses: number;
+            hitRate: number;
+        };
+        getCloudURL(): string;
+        setTokens(accessToken: string, refreshToken?: string): void;
+        clearTokens(): void;
+        getCurrentUserId(): string | null;
+        hasValidToken(): boolean;
+        getAccessToken(): string | null;
+        waitForAuth(timeoutMs?: number): Promise<boolean>;
+        withAuthRetry<T_1>(operation: () => Promise<T_1>, operationName: string, options?: {
+            maxRetries?: number;
+            retryDelay?: number;
+            authTimeoutMs?: number;
+        }): Promise<T_1>;
+        validate(): Promise<boolean>;
+        handleError(error: unknown): Error;
+        healthCheck(): Promise<{
+            status: string;
+            users?: number;
+            timestamp?: string;
+            [key: string]: any;
+        }>;
+    };
+    __resetTokensForTests(): void;
+} & T;

package/dist/web/types/core/mixins/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Centralized mixin exports and composition helper
+ *
+ * This module provides a clean way to compose all mixins
+ * and ensures consistent ordering for better maintainability
+ */
+type MixinFunction = (Base: any) => any;
+/**
+ * Mixin pipeline - applied in order from first to last.
+ *
+ * Order matters for dependencies:
+ * 1. Base auth mixin first (required by all others)
+ * 2. Cross-domain auth mixins (FedCM, Popup, Redirect)
+ * 3. User mixin (requires auth)
+ * 4. Feature mixins (can depend on user)
+ * 5. Utility mixin last (augments all)
+ *
+ * To add a new mixin: insert it at the appropriate position in this array.
+ */
+declare const MIXIN_PIPELINE: MixinFunction[];
+/**
+ * Composes all OxyServices mixins using a pipeline pattern.
+ *
+ * This is equivalent to the nested calls but more readable and maintainable.
+ * Adding a new mixin: just add it to MIXIN_PIPELINE at the appropriate position.
+ *
+ * @returns The fully composed OxyServices class with all mixins applied
+ */
+export declare function composeOxyServices(): any;
+export { MIXIN_PIPELINE };

package/dist/web/types/core/mixins/mixinHelpers.d.ts

@@ -0,0 +1,31 @@
+/**
+ * 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 declare function withErrorHandling<T>(operation: () => Promise<T>, handleError: (error: any) => Error): Promise<T>;
+/**
+ * Creates a standard API request method with error handling
+ * Reduces duplication across mixin methods
+ */
+export declare 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;
+}): (...args: any[]) => Promise<T>;
+/**
+ * Cache time constants (in milliseconds)
+ */
+export declare const CACHE_TIMES: {
+    readonly SHORT: number;
+    readonly MEDIUM: number;
+    readonly LONG: number;
+    readonly VERY_LONG: number;
+    readonly EXTRA_LONG: number;
+};

package/dist/web/types/crypto/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Oxy Crypto Module
+ *
+ * Provides cryptographic identity management for the Oxy ecosystem.
+ * Handles key generation, secure storage, digital signatures, and recovery phrases.
+ */
+import './polyfill';
+export { KeyManager, type KeyPair } from './keyManager';
+export { SignatureService, type SignedMessage, type AuthChallenge } from './signatureService';
+export { RecoveryPhraseService, type RecoveryPhraseResult } from './recoveryPhrase';
+export { KeyManager as default } from './keyManager';