@oxyhq/core 1.0.0

package/dist/types/mixins/OxyServices.auth.d.ts

@@ -0,0 +1,186 @@
+/**
+ * Authentication Methods Mixin
+ *
+ * Supports password-based login (email/username) and public key challenge-response.
+ */
+import type { User } from '../models/interfaces';
+import type { SessionLoginResponse } from '../models/session';
+import type { OxyServicesBase } from '../OxyServices.base';
+export interface ChallengeResponse {
+    challenge: string;
+    expiresAt: string;
+}
+export interface RegistrationRequest {
+    publicKey: string;
+    username: string;
+    email?: string;
+    signature: string;
+    timestamp: number;
+}
+export interface ChallengeVerifyRequest {
+    publicKey: string;
+    challenge: string;
+    signature: string;
+    timestamp: number;
+    deviceName?: string;
+    deviceFingerprint?: string;
+}
+export interface PublicKeyCheckResponse {
+    registered: boolean;
+    message: string;
+}
+export declare function OxyServicesAuthMixin<T extends typeof OxyServicesBase>(Base: T): {
+    new (...args: any[]): {
+        /**
+         * Register a new identity with public key authentication
+         * Identity is purely cryptographic - username and profile data are optional
+         *
+         * @param publicKey - The user's ECDSA public key (hex)
+         * @param signature - Signature of the registration request
+         * @param timestamp - Timestamp when the signature was created
+         */
+        register(publicKey: string, signature: string, timestamp: number): Promise<{
+            message: string;
+            user: User;
+        }>;
+        /**
+         * Request an authentication challenge
+         * The client must sign this challenge with their private key
+         *
+         * @param publicKey - The user's public key
+         */
+        requestChallenge(publicKey: string): Promise<ChallengeResponse>;
+        /**
+         * Verify a signed challenge and create a session
+         *
+         * @param publicKey - The user's public key
+         * @param challenge - The challenge string from requestChallenge
+         * @param signature - Signature of the auth message
+         * @param timestamp - Timestamp when the signature was created
+         * @param deviceName - Optional device name
+         * @param deviceFingerprint - Optional device fingerprint
+         */
+        verifyChallenge(publicKey: string, challenge: string, signature: string, timestamp: number, deviceName?: string, deviceFingerprint?: string): Promise<SessionLoginResponse>;
+        /**
+         * Check if a public key is already registered
+         */
+        checkPublicKeyRegistered(publicKey: string): Promise<PublicKeyCheckResponse>;
+        /**
+         * Get user by public key
+         */
+        getUserByPublicKey(publicKey: string): Promise<User>;
+        /**
+         * Get user by session ID
+         */
+        getUserBySession(sessionId: string): Promise<User>;
+        /**
+         * Batch get multiple user profiles by session IDs
+         */
+        getUsersBySessions(sessionIds: string[]): Promise<Array<{
+            sessionId: string;
+            user: User | null;
+        }>>;
+        /**
+         * Get access token by session ID
+         */
+        getTokenBySession(sessionId: string): Promise<{
+            accessToken: string;
+            expiresAt: string;
+        }>;
+        /**
+         * Get sessions by session ID
+         */
+        getSessionsBySessionId(sessionId: string): Promise<any[]>;
+        /**
+         * Logout from a specific session
+         */
+        logoutSession(sessionId: string, targetSessionId?: string): Promise<void>;
+        /**
+         * Logout from all sessions
+         */
+        logoutAllSessions(sessionId: string): Promise<void>;
+        /**
+         * Validate session
+         */
+        validateSession(sessionId: string, options?: {
+            deviceFingerprint?: string;
+            useHeaderValidation?: boolean;
+        }): Promise<{
+            valid: boolean;
+            expiresAt: string;
+            lastActivity: string;
+            user: User;
+            sessionId?: string;
+            source?: string;
+        }>;
+        /**
+         * Check username availability
+         */
+        checkUsernameAvailability(username: string): Promise<{
+            available: boolean;
+            message: string;
+        }>;
+        /**
+         * Check email availability
+         */
+        checkEmailAvailability(email: string): Promise<{
+            available: boolean;
+            message: string;
+        }>;
+        /**
+         * Register a new user with email/username and password
+         */
+        signUp(username: string, email: string, password: string, deviceName?: string, deviceFingerprint?: any): Promise<SessionLoginResponse>;
+        /**
+         * Sign in with email or username and password
+         */
+        signIn(identifier: string, password: string, deviceName?: string, deviceFingerprint?: any): Promise<SessionLoginResponse>;
+        /**
+         * Convenience helper for email sign-in
+         */
+        signInWithEmail(email: string, password: string, deviceName?: string, deviceFingerprint?: any): Promise<SessionLoginResponse>;
+        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/types/mixins/OxyServices.developer.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Developer API Methods Mixin
+ *
+ * Provides methods for managing developer applications and API keys
+ */
+import type { OxyServicesBase } from '../OxyServices.base';
+export declare function OxyServicesDeveloperMixin<T extends typeof OxyServicesBase>(Base: T): {
+    new (...args: any[]): {
+        /**
+         * Get developer apps for the current user
+         * @returns Array of developer apps
+         */
+        getDeveloperApps(): Promise<any[]>;
+        /**
+         * Create a new developer app
+         * @param data - Developer app configuration
+         * @returns Created developer app
+         */
+        createDeveloperApp(data: {
+            name: string;
+            description?: string;
+            webhookUrl: string;
+            devWebhookUrl?: string;
+            scopes?: string[];
+        }): Promise<any>;
+        /**
+         * Get a specific developer app
+         */
+        getDeveloperApp(appId: string): Promise<any>;
+        /**
+         * Update a developer app
+         * @param appId - The developer app ID
+         * @param data - Updated app configuration
+         * @returns Updated developer app
+         */
+        updateDeveloperApp(appId: string, data: {
+            name?: string;
+            description?: string;
+            webhookUrl?: string;
+            devWebhookUrl?: string;
+            scopes?: string[];
+        }): Promise<any>;
+        /**
+         * Regenerate API secret for a developer app
+         * @param appId - The developer app ID
+         * @returns App with new secret
+         */
+        regenerateDeveloperAppSecret(appId: string): Promise<any>;
+        /**
+         * Delete a developer app
+         * @param appId - The developer app ID
+         * @returns Deletion result
+         */
+        deleteDeveloperApp(appId: string): 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/types/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/types/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;