@oxyhq/services 5.26.4 → 5.27.0

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

@@ -0,0 +1,81 @@
+/**
+ * OxyServices - Unified client for Oxy API and Oxy Cloud
+ *
+ * # Usage Examples
+ *
+ * ## Browser (ESM/TypeScript)
+ *
+ * ```typescript
+ * import { OxyServices } from './core/OxyServices';
+ *
+ * const oxy = new OxyServices({
+ *   baseURL: 'https://api.oxy.so',
+ *   cloudURL: 'https://cloud.oxy.so',
+ * });
+ *
+ * // Authenticate and fetch user
+ * await oxy.setTokens('ACCESS_TOKEN');
+ * const user = await oxy.getCurrentUser();
+ *
+ * // Upload a file (browser File API)
+ * const fileInput = document.querySelector('input[type=file]');
+ * const file = fileInput.files[0];
+ * await oxy.uploadRawFile(file);
+ *
+ * // Get a file download URL for <img src>
+ * const url = oxy.getFileDownloadUrl('fileId', 'thumb');
+ * ```
+ *
+ * ## Node.js (CommonJS/TypeScript)
+ *
+ * ```typescript
+ * import { OxyServices } from './core/OxyServices';
+ * import fs from 'fs';
+ *
+ * const oxy = new OxyServices({
+ *   baseURL: 'https://api.oxy.so',
+ *   cloudURL: 'https://cloud.oxy.so',
+ * });
+ *
+ * // Authenticate and fetch user
+ * await oxy.setTokens('ACCESS_TOKEN');
+ * const user = await oxy.getCurrentUser();
+ *
+ * // Upload a file (Node.js Buffer)
+ * const buffer = fs.readFileSync('myfile.png');
+ * const blob = new Blob([buffer]);
+ * await oxy.uploadRawFile(blob, { filename: 'myfile.png' });
+ *
+ * // Get a file download URL
+ * const url = oxy.getFileDownloadUrl('fileId');
+ * ```
+ *
+ * ## Configuration
+ * - `baseURL`: Oxy API endpoint (e.g., https://api.oxy.so)
+ * - `cloudURL`: Oxy Cloud/CDN endpoint (e.g., https://cloud.oxy.so)
+ *
+ * See method JSDoc for more details and options.
+ */
+import { type OxyConfig } from './OxyServices.base';
+import { OxyAuthenticationError, OxyAuthenticationTimeoutError } from './OxyServices.errors';
+import { composeOxyServices } from './mixins';
+declare const OxyServices_base: any;
+export declare class OxyServices extends OxyServices_base {
+    constructor(config: OxyConfig);
+}
+export interface OxyServices extends InstanceType<ReturnType<typeof composeOxyServices>> {
+}
+export { OxyAuthenticationError, OxyAuthenticationTimeoutError };
+/**
+ * Export the default Oxy Cloud URL (for backward compatibility)
+ */
+export declare const OXY_CLOUD_URL = "https://cloud.oxy.so";
+/**
+ * Export the default Oxy API URL (for documentation)
+ */
+export declare const OXY_API_URL: any;
+/**
+ * Pre-configured client instance for easy import
+ * Uses OXY_API_URL as baseURL and OXY_CLOUD_URL as cloudURL
+ */
+export declare const oxyClient: OxyServices;

package/dist/web/types/core/OxyServices.errors.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Custom error types for better error handling
+ */
+export declare class OxyAuthenticationError extends Error {
+    readonly code: string;
+    readonly status: number;
+    constructor(message: string, code?: string, status?: number);
+}
+export declare class OxyAuthenticationTimeoutError extends OxyAuthenticationError {
+    constructor(operationName: string, timeoutMs: number);
+}

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

@@ -0,0 +1,20 @@
+/**
+ * OxyServices Core Module - Unified Architecture
+ *
+ * This module exports the unified OxyServices class that provides all API functionality
+ * in one simple, easy-to-use interface.
+ */
+export { OxyServices, OxyAuthenticationError, OxyAuthenticationTimeoutError } from './OxyServices';
+export { OXY_CLOUD_URL, oxyClient } from './OxyServices';
+export { CrossDomainAuth, createCrossDomainAuth } from './CrossDomainAuth';
+export type { CrossDomainAuthOptions } from './CrossDomainAuth';
+export { AuthManager, createAuthManager } from './AuthManager';
+export type { StorageAdapter, AuthStateChangeCallback, AuthMethod, AuthManagerConfig } from './AuthManager';
+export * from '../models/interfaces';
+export * from '../models/session';
+export { DeviceManager } from '../utils/deviceManager';
+export type { DeviceFingerprint, StoredDeviceInfo } from '../utils/deviceManager';
+export { SUPPORTED_LANGUAGES, getLanguageMetadata, getLanguageName, getNativeLanguageName, normalizeLanguageCode } from '../utils/languageUtils';
+export type { LanguageMetadata } from '../utils/languageUtils';
+import { OxyServices } from './OxyServices';
+export default OxyServices;

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

@@ -0,0 +1,66 @@
+/**
+ * Analytics Methods Mixin
+ *
+ * Provides methods for analytics tracking and data retrieval
+ */
+import type { OxyServicesBase } from '../OxyServices.base';
+export declare function OxyServicesAnalyticsMixin<T extends typeof OxyServicesBase>(Base: T): {
+    new (...args: any[]): {
+        /**
+         * Track an analytics event
+         * @param eventName - Name of the event to track
+         * @param properties - Optional event properties
+         */
+        trackEvent(eventName: string, properties?: Record<string, any>): Promise<void>;
+        /**
+         * Get analytics data for a date range
+         * @param startDate - Optional start date (ISO string)
+         * @param endDate - Optional end date (ISO string)
+         * @returns Analytics data
+         */
+        getAnalytics(startDate?: string, endDate?: 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/web/types/core/mixins/OxyServices.assets.d.ts

@@ -0,0 +1,135 @@
+import type { AccountStorageUsageResponse, AssetUrlResponse, AssetVariant } from '../../models/interfaces';
+import type { OxyServicesBase } from '../OxyServices.base';
+export declare function OxyServicesAssetsMixin<T extends typeof OxyServicesBase>(Base: T): {
+    new (...args: any[]): {
+        /**
+         * Delete file
+         */
+        deleteFile(fileId: string): Promise<any>;
+        /**
+         * Get file download URL (synchronous - uses stream endpoint for images to avoid ORB blocking)
+         */
+        getFileDownloadUrl(fileId: string, variant?: string, expiresIn?: number): string;
+        /**
+         * Get file download URL asynchronously (returns signed URL directly from CDN)
+         */
+        getFileDownloadUrlAsync(fileId: string, variant?: string, expiresIn?: number): Promise<string>;
+        /**
+         * List user files
+         */
+        listUserFiles(limit?: number, offset?: number): Promise<{
+            files: any[];
+            total: number;
+            hasMore: boolean;
+        }>;
+        /**
+         * Get account storage usage (server-side usage aggregated from assets)
+         */
+        getAccountStorageUsage(): Promise<AccountStorageUsageResponse>;
+        /**
+         * Get file content as text
+         */
+        getFileContentAsText(fileId: string, variant?: string): Promise<string>;
+        /**
+         * Get file content as blob
+         */
+        getFileContentAsBlob(fileId: string, variant?: string): Promise<Blob>;
+        /**
+         * Get batch access to multiple files
+         */
+        getBatchFileAccess(fileIds: string[], context?: string): Promise<Record<string, any>>;
+        /**
+         * Get download URLs for multiple files efficiently
+         */
+        getFileDownloadUrls(fileIds: string[], context?: string): Promise<Record<string, string>>;
+        /**
+         * Upload raw file data
+         */
+        uploadRawFile(file: File | Blob, visibility?: "private" | "public" | "unlisted", metadata?: Record<string, any>): Promise<any>;
+        /**
+         * Upload file using Central Asset Service
+         */
+        assetUpload(file: File, visibility?: "private" | "public" | "unlisted", metadata?: Record<string, any>, onProgress?: (progress: number) => void): Promise<any>;
+        /**
+         * Link asset to an entity
+         */
+        assetLink(fileId: string, app: string, entityType: string, entityId: string, visibility?: "private" | "public" | "unlisted", webhookUrl?: string): Promise<any>;
+        /**
+         * Unlink asset from an entity
+         */
+        assetUnlink(fileId: string, app: string, entityType: string, entityId: string): Promise<any>;
+        /**
+         * Get asset metadata
+         */
+        assetGet(fileId: string): Promise<any>;
+        /**
+         * Get asset URL (CDN or signed URL)
+         */
+        assetGetUrl(fileId: string, variant?: string, expiresIn?: number): Promise<AssetUrlResponse>;
+        /**
+         * Restore asset from trash
+         */
+        assetRestore(fileId: string): Promise<any>;
+        /**
+         * Delete asset with optional force
+         */
+        assetDelete(fileId: string, force?: boolean): Promise<any>;
+        /**
+         * Get list of available variants for an asset
+         */
+        assetGetVariants(fileId: string): Promise<AssetVariant[]>;
+        /**
+         * Update asset visibility
+         */
+        assetUpdateVisibility(fileId: string, visibility: "private" | "public" | "unlisted"): Promise<any>;
+        uploadAvatar(file: File, userId: string, app?: string): Promise<any>;
+        uploadProfileBanner(file: File, userId: string, app?: string): Promise<any>;
+        getAssetUrlCacheTTL(expiresIn?: number): number;
+        fetchAssetDownloadUrl(fileId: string, variant?: string, cacheTTL?: number, expiresIn?: number): Promise<string | null>;
+        fetchAssetContent(url: string, type: "text"): Promise<string>;
+        fetchAssetContent(url: string, type: "blob"): Promise<Blob>;
+        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.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/web/types/core/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;