@oxyhq/services 5.26.4 → 5.27.0

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

@@ -0,0 +1,96 @@
+/**
+ * Device Methods Mixin
+ */
+import type { OxyServicesBase } from '../OxyServices.base';
+export declare function OxyServicesDevicesMixin<T extends typeof OxyServicesBase>(Base: T): {
+    new (...args: any[]): {
+        /**
+         * Register a new device
+         * @param deviceData - Device information
+         * @returns Registered device object
+         */
+        registerDevice(deviceData: any): Promise<any>;
+        /**
+         * Get all devices for the current user
+         * @returns Array of user devices
+         */
+        getUserDevices(): Promise<any[]>;
+        /**
+         * Remove a device
+         * @param deviceId - The device ID to remove
+         */
+        removeDevice(deviceId: string): Promise<void>;
+        /**
+         * 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
+         */
+        getDeviceSessions(sessionId: string): Promise<any[]>;
+        /**
+         * 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
+         */
+        logoutAllDeviceSessions(sessionId: string, deviceId?: string, excludeCurrent?: boolean): Promise<any>;
+        /**
+         * Update device name
+         * @param sessionId - The session ID
+         * @param deviceName - New device name
+         * @returns Updated device object
+         */
+        updateDeviceName(sessionId: string, deviceName: string): Promise<any>;
+        /**
+         * Get security information
+         * @returns Security information object
+         */
+        getSecurityInfo(): Promise<{
+            recoveryEmail: string | null;
+        }>;
+        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.features.d.ts

@@ -0,0 +1,228 @@
+/**
+ * Features Methods Mixin
+ *
+ * Provides methods for various features:
+ * - Feedback submission
+ * - Subscription plans
+ * - Saves/Collections
+ * - User history
+ * - FAQ
+ * - User stats
+ * - Achievements
+ */
+import type { OxyServicesBase } from '../OxyServices.base';
+export interface FeedbackPayload {
+    type: 'bug' | 'feature' | 'general' | 'support';
+    title: string;
+    description: string;
+    priority: 'low' | 'medium' | 'high' | 'critical';
+    category: string;
+    contactEmail?: string;
+    systemInfo?: {
+        platform: string;
+        version: string;
+        appVersion: string;
+        userId?: string;
+        username?: string;
+        timestamp: string;
+    };
+}
+export interface FeedbackResult {
+    id: string;
+    status: string;
+    createdAt: string;
+}
+export interface SubscriptionPlan {
+    id: string;
+    name: string;
+    description: string;
+    price: number;
+    currency: string;
+    interval: 'month' | 'year';
+    features: string[];
+}
+export interface SubscriptionResult {
+    subscriptionId: string;
+    status: string;
+    currentPeriodEnd: string;
+}
+export interface SavedItem {
+    id: string;
+    itemId: string;
+    itemType: string;
+    title: string;
+    createdAt: string;
+}
+export interface Collection {
+    id: string;
+    name: string;
+    description?: string;
+    itemCount: number;
+    createdAt: string;
+}
+export interface UserStats {
+    postCount: number;
+    commentCount: number;
+    followerCount: number;
+    followingCount: number;
+    karmaScore?: number;
+}
+export interface HistoryItem {
+    id: string;
+    type: string;
+    title: string;
+    timestamp: string;
+    metadata?: Record<string, any>;
+}
+export interface FAQ {
+    id: string;
+    question: string;
+    answer: string;
+    category: string;
+}
+export interface Achievement {
+    id: string;
+    name: string;
+    description: string;
+    icon: string;
+    unlockedAt?: string;
+}
+export declare function OxyServicesFeaturesMixin<T extends typeof OxyServicesBase>(Base: T): {
+    new (...args: any[]): {
+        /**
+         * Submit user feedback
+         */
+        submitFeedback(payload: FeedbackPayload): Promise<FeedbackResult>;
+        /**
+         * Get available subscription plans
+         */
+        getSubscriptionPlans(): Promise<SubscriptionPlan[]>;
+        /**
+         * Get individual purchasable features
+         */
+        getIndividualFeatures(): Promise<any[]>;
+        /**
+         * Subscribe to a plan
+         */
+        subscribe(planId: string, paymentMethodId?: string): Promise<SubscriptionResult>;
+        /**
+         * Subscribe to an individual feature
+         */
+        subscribeToFeature(featureId: string, paymentMethodId?: string): Promise<SubscriptionResult>;
+        /**
+         * Cancel subscription
+         */
+        cancelSubscription(subscriptionId: string): Promise<void>;
+        /**
+         * Reactivate subscription
+         */
+        reactivateSubscription(subscriptionId: string): Promise<void>;
+        /**
+         * Get current user's subscription
+         */
+        getCurrentSubscription(): Promise<SubscriptionResult | null>;
+        /**
+         * Get user's saved items
+         */
+        getSavedItems(userId?: string): Promise<SavedItem[]>;
+        /**
+         * Get user's collections
+         */
+        getCollections(userId?: string): Promise<Collection[]>;
+        /**
+         * Save an item
+         */
+        saveItem(itemId: string, itemType: string, collectionId?: string): Promise<SavedItem>;
+        /**
+         * Remove an item from saves
+         */
+        removeSavedItem(saveId: string): Promise<void>;
+        /**
+         * Create a collection
+         */
+        createCollection(name: string, description?: string): Promise<Collection>;
+        /**
+         * Delete a collection
+         */
+        deleteCollection(collectionId: string): Promise<void>;
+        /**
+         * Get user statistics
+         */
+        getUserStats(userId: string): Promise<UserStats>;
+        /**
+         * Get user history
+         */
+        getUserHistory(userId?: string, limit?: number, offset?: number): Promise<HistoryItem[]>;
+        /**
+         * Clear user history
+         */
+        clearUserHistory(): Promise<void>;
+        /**
+         * Delete a history item
+         */
+        deleteHistoryItem(itemId: string): Promise<void>;
+        /**
+         * Get FAQs
+         */
+        getFAQs(category?: string): Promise<FAQ[]>;
+        /**
+         * Search FAQs
+         */
+        searchFAQs(query: string): Promise<FAQ[]>;
+        /**
+         * Get user achievements
+         */
+        getUserAchievements(userId?: string): Promise<Achievement[]>;
+        /**
+         * Get all available achievements
+         */
+        getAllAchievements(): Promise<Achievement[]>;
+        /**
+         * Delete user account (requires password confirmation)
+         */
+        deleteAccount(password: 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.fedcm.d.ts

@@ -0,0 +1,200 @@
+import type { OxyServicesBase } from '../OxyServices.base';
+import type { SessionLoginResponse } from '../../models/session';
+export interface FedCMAuthOptions {
+    nonce?: string;
+    context?: 'signin' | 'signup' | 'continue' | 'use';
+}
+export interface FedCMConfig {
+    enabled: boolean;
+    configURL: string;
+    clientId?: string;
+}
+/**
+ * Federated Credential Management (FedCM) Authentication Mixin
+ *
+ * Implements the modern browser-native identity federation API that enables
+ * Google-style cross-domain authentication without third-party cookies.
+ *
+ * Browser Support:
+ * - Chrome 108+
+ * - Safari 16.4+
+ * - Edge 108+
+ * - Firefox: Not yet supported (fallback required)
+ *
+ * Key Features:
+ * - No redirects or popups required
+ * - Browser-native UI prompts
+ * - Privacy-preserving (IdP can't track users)
+ * - Automatic SSO across domains
+ * - Silent re-authentication support
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/FedCM_API
+ */
+export declare function OxyServicesFedCMMixin<T extends typeof OxyServicesBase>(Base: T): {
+    new (...args: any[]): {
+        /**
+         * Instance method to check FedCM support
+         */
+        isFedCMSupported(): boolean;
+        /**
+         * Sign in using FedCM (Federated Credential Management API)
+         *
+         * This provides a Google-style authentication experience:
+         * - Browser shows native "Sign in with Oxy" prompt
+         * - No redirect or popup required
+         * - User approves → credential exchange happens in browser
+         * - All apps automatically get SSO after first sign-in
+         *
+         * @param options - Authentication options
+         * @returns Session with access token and user data
+         * @throws {OxyAuthenticationError} If FedCM not supported or user cancels
+         *
+         * @example
+         * ```typescript
+         * try {
+         *   const session = await oxyServices.signInWithFedCM();
+         *   console.log('Signed in:', session.user);
+         * } catch (error) {
+         *   // Fallback to popup or redirect auth
+         *   await oxyServices.signInWithPopup();
+         * }
+         * ```
+         */
+        signInWithFedCM(options?: FedCMAuthOptions): Promise<SessionLoginResponse>;
+        /**
+         * Silent sign-in using FedCM
+         *
+         * Attempts to automatically re-authenticate the user without any UI.
+         * This is what enables "instant sign-in" across all Oxy domains after
+         * the user has signed in once.
+         *
+         * The browser will:
+         * 1. Check if user has previously signed in to Oxy
+         * 2. Check if user is still signed in at auth.oxy.so
+         * 3. If yes, automatically provide credential without prompting
+         *
+         * @returns Session if user is already signed in, null otherwise
+         *
+         * @example
+         * ```typescript
+         * // On app startup
+         * useEffect(() => {
+         *   const checkAuth = async () => {
+         *     const session = await oxyServices.silentSignInWithFedCM();
+         *     if (session) {
+         *       setUser(session.user);
+         *     } else {
+         *       // Show sign-in button
+         *     }
+         *   };
+         *   checkAuth();
+         * }, []);
+         * ```
+         */
+        silentSignInWithFedCM(): Promise<SessionLoginResponse | null>;
+        /**
+         * Request identity credential from browser using FedCM API
+         *
+         * Uses a global lock to prevent concurrent requests, as FedCM only
+         * allows one navigator.credentials.get request at a time.
+         *
+         * Interactive requests (optional/required) wait for any silent request to finish first.
+         *
+         * @private
+         */
+        requestIdentityCredential(options: {
+            configURL: string;
+            clientId: string;
+            nonce: string;
+            context?: string;
+            mediation?: "silent" | "optional" | "required";
+        }): Promise<{
+            token: string;
+        } | null>;
+        /**
+         * Exchange FedCM ID token for Oxy session
+         *
+         * The ID token is a JWT issued by auth.oxy.so that proves the user's
+         * identity. We exchange it for a full Oxy session with access token.
+         *
+         * @private
+         */
+        exchangeIdTokenForSession(idToken: string): Promise<SessionLoginResponse>;
+        /**
+         * Revoke FedCM credential (sign out)
+         *
+         * This tells the browser to forget the FedCM credential for this app.
+         * The user will need to re-authenticate next time.
+         */
+        revokeFedCMCredential(): Promise<void>;
+        /**
+         * Get configuration for FedCM
+         *
+         * @returns FedCM configuration with browser support info
+         */
+        getFedCMConfig(): FedCMConfig;
+        /**
+         * Generate a cryptographically secure nonce for FedCM
+         *
+         * @private
+         */
+        generateNonce(): string;
+        /**
+         * Get the client ID for this origin
+         *
+         * @private
+         */
+        getClientId(): string;
+        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 DEFAULT_CONFIG_URL: "https://auth.oxy.so/fedcm.json";
+    readonly FEDCM_TIMEOUT: 60000;
+    readonly FEDCM_SILENT_TIMEOUT: 10000;
+    /**
+     * Check if FedCM is supported in the current browser
+     */
+    isFedCMSupported(): boolean;
+    __resetTokensForTests(): void;
+} & T;
+export { OxyServicesFedCMMixin as FedCMMixin };

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

@@ -0,0 +1,85 @@
+/**
+ * Karma Methods Mixin
+ *
+ * Provides methods for karma system management
+ */
+import type { OxyServicesBase } from '../OxyServices.base';
+export declare function OxyServicesKarmaMixin<T extends typeof OxyServicesBase>(Base: T): {
+    new (...args: any[]): {
+        /**
+         * Get user karma
+         */
+        getUserKarma(userId: string): Promise<any>;
+        /**
+         * Give karma to user
+         */
+        giveKarma(userId: string, amount: number, reason?: string): Promise<any>;
+        /**
+         * Get user karma total
+         * @param userId - The user ID
+         * @returns User karma total
+         */
+        getUserKarmaTotal(userId: string): Promise<any>;
+        /**
+         * 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
+         */
+        getUserKarmaHistory(userId: string, limit?: number, offset?: number): Promise<any>;
+        /**
+         * Get karma leaderboard
+         * @returns Karma leaderboard
+         */
+        getKarmaLeaderboard(): Promise<any>;
+        /**
+         * Get karma rules
+         * @returns Karma rules
+         */
+        getKarmaRules(): Promise<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/OxyServices.language.d.ts

@@ -0,0 +1,81 @@
+import type { LanguageMetadata } from '../../utils/languageUtils';
+import type { OxyServicesBase } from '../OxyServices.base';
+export declare function OxyServicesLanguageMixin<T extends typeof OxyServicesBase>(Base: T): {
+    new (...args: any[]): {
+        /**
+         * Get appropriate storage for the platform (similar to DeviceManager)
+         */
+        getStorage(): Promise<{
+            getItem: (key: string) => Promise<string | null>;
+            setItem: (key: string, value: string) => Promise<void>;
+            removeItem: (key: string) => Promise<void>;
+        }>;
+        /**
+         * Get the current language from storage or user profile
+         * @param storageKeyPrefix - Optional prefix for storage key (default: 'oxy_session')
+         * @returns The current language code (e.g., 'en-US') or null if not set
+         */
+        getCurrentLanguage(storageKeyPrefix?: string): Promise<string | null>;
+        /**
+         * Get the current language with metadata (name, nativeName, etc.)
+         * @param storageKeyPrefix - Optional prefix for storage key (default: 'oxy_session')
+         * @returns Language metadata object or null if not set
+         */
+        getCurrentLanguageMetadata(storageKeyPrefix?: string): Promise<LanguageMetadata | null>;
+        /**
+         * Get the current language name (e.g., 'English')
+         * @param storageKeyPrefix - Optional prefix for storage key (default: 'oxy_session')
+         * @returns Language name or null if not set
+         */
+        getCurrentLanguageName(storageKeyPrefix?: string): Promise<string | null>;
+        /**
+         * Get the current native language name (e.g., 'Español')
+         * @param storageKeyPrefix - Optional prefix for storage key (default: 'oxy_session')
+         * @returns Native language name or null if not set
+         */
+        getCurrentNativeLanguageName(storageKeyPrefix?: string): Promise<string | null>;
+        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;