@oxyhq/services 0.1.0 → 0.1.1

package/dist/services/OxyClient.js

@@ -1,309 +0,0 @@
-"use strict";
-/**
- * OxyClient Service
- *
- * A client library for interacting with the OxyHQ platform APIs.
- * Provides methods for accessing files, user profiles, and managing sessions.
- */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.oxyClient = exports.OxyClient = void 0;
-const api_service_1 = require("./api.service");
-const config_1 = require("../config");
-const storage_1 = require("../utils/storage");
-const constants_1 = require("../constants");
-const errorHandler_1 = __importDefault(require("../utils/errorHandler"));
-/**
- * Client library for OxyHQ platform services
- */
-class OxyClient {
-    constructor(baseUrl) {
-        this.profileCache = new Map();
-        this.PROFILE_CACHE_TTL = 5 * 60 * 1000; // 5 minutes
-        this.pendingRequests = new Map();
-        this.baseUrl = baseUrl || config_1.OXY_API_CONFIG.CLOUD_URL;
-    }
-    /**
-     * Get metadata for multiple files by their IDs
-     * @param mediaIds Array of file IDs
-     * @returns Promise resolving to array of file metadata objects
-     */
-    getFilesData(mediaIds) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!mediaIds || mediaIds.length === 0)
-                return [];
-            try {
-                const validIds = mediaIds.filter(Boolean);
-                if (validIds.length === 0)
-                    return [];
-                const cacheKey = `files_data_${validIds.join(",")}`;
-                // Return existing promise if request is already in progress
-                if (this.pendingRequests.has(cacheKey)) {
-                    return this.pendingRequests.get(cacheKey);
-                }
-                // Create new request promise
-                const requestPromise = new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-                    try {
-                        const response = yield api_service_1.apiService.get(`/files/data/${validIds.join(",")}`, {
-                            useCache: true,
-                            cacheTTL: 2 * 60 * 1000 // 2 minutes cache
-                        });
-                        resolve(Array.isArray(response.data) ? response.data : []);
-                    }
-                    catch (error) {
-                        errorHandler_1.default.handleError(error, {
-                            context: 'Error fetching files data',
-                            showToast: false
-                        });
-                        resolve([]); // Resolve with empty array instead of rejecting
-                    }
-                    finally {
-                        // Remove from pending requests
-                        this.pendingRequests.delete(cacheKey);
-                    }
-                }));
-                // Store the pending request
-                this.pendingRequests.set(cacheKey, requestPromise);
-                return requestPromise;
-            }
-            catch (error) {
-                errorHandler_1.default.handleError(error, {
-                    context: 'Error in getFilesData',
-                    showToast: false
-                });
-                return [];
-            }
-        });
-    }
-    /**
-     * Get the URL for accessing a file
-     * @param fileId ID of the file
-     * @returns Promise resolving to the file URL
-     */
-    getFileUrl(fileId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!fileId)
-                throw new Error('File ID is required');
-            return `${this.baseUrl}/${fileId}`;
-        });
-    }
-    /**
-     * Get a user profile by ID
-     * @param userId ID of the user
-     * @returns Promise resolving to the user profile
-     */
-    getProfile(userId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!userId)
-                throw new Error('User ID is required');
-            try {
-                // Check cache first
-                const cachedProfile = this.profileCache.get(userId);
-                if (cachedProfile && (Date.now() - cachedProfile.timestamp) < this.PROFILE_CACHE_TTL) {
-                    return cachedProfile.profile;
-                }
-                const cacheKey = `profile_${userId}`;
-                // Return existing promise if request is already in progress
-                if (this.pendingRequests.has(cacheKey)) {
-                    return this.pendingRequests.get(cacheKey);
-                }
-                // Create new request promise
-                const requestPromise = new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-                    try {
-                        const response = yield api_service_1.apiService.get(constants_1.ENDPOINTS.USERS.PROFILE(userId), { useCache: true });
-                        // Update cache
-                        this.profileCache.set(userId, {
-                            profile: response.data,
-                            timestamp: Date.now()
-                        });
-                        resolve(response.data);
-                    }
-                    catch (error) {
-                        errorHandler_1.default.handleError(error, {
-                            context: 'Error fetching profile',
-                            fallbackMessage: constants_1.ERROR_MESSAGES.DEFAULT
-                        });
-                        reject(new Error(constants_1.ERROR_MESSAGES.DEFAULT));
-                    }
-                    finally {
-                        // Remove from pending requests
-                        this.pendingRequests.delete(cacheKey);
-                    }
-                }));
-                // Store the pending request
-                this.pendingRequests.set(cacheKey, requestPromise);
-                return requestPromise;
-            }
-            catch (error) {
-                errorHandler_1.default.handleError(error, {
-                    context: 'Error in getProfile',
-                    fallbackMessage: constants_1.ERROR_MESSAGES.DEFAULT
-                });
-                throw new Error(constants_1.ERROR_MESSAGES.DEFAULT);
-            }
-        });
-    }
-    /**
-     * Get a user profile by username
-     * @param username Username of the user
-     * @returns Promise resolving to the user profile
-     */
-    getProfileByUsername(username) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!username)
-                throw new Error('Username is required');
-            try {
-                const cacheKey = `profile_username_${username}`;
-                // Return existing promise if request is already in progress
-                if (this.pendingRequests.has(cacheKey)) {
-                    return this.pendingRequests.get(cacheKey);
-                }
-                // Create new request promise
-                const requestPromise = new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-                    try {
-                        const response = yield api_service_1.apiService.get(`/profiles/username/${username}`, { useCache: true });
-                        // Also cache by user ID for future lookups
-                        if (response.data.userID) {
-                            this.profileCache.set(response.data.userID, {
-                                profile: response.data,
-                                timestamp: Date.now()
-                            });
-                        }
-                        resolve(response.data);
-                    }
-                    catch (error) {
-                        errorHandler_1.default.handleError(error, {
-                            context: 'Error fetching profile by username',
-                            fallbackMessage: constants_1.ERROR_MESSAGES.DEFAULT
-                        });
-                        reject(new Error(constants_1.ERROR_MESSAGES.DEFAULT));
-                    }
-                    finally {
-                        // Remove from pending requests
-                        this.pendingRequests.delete(cacheKey);
-                    }
-                }));
-                // Store the pending request
-                this.pendingRequests.set(cacheKey, requestPromise);
-                return requestPromise;
-            }
-            catch (error) {
-                errorHandler_1.default.handleError(error, {
-                    context: 'Error in getProfileByUsername',
-                    fallbackMessage: constants_1.ERROR_MESSAGES.DEFAULT
-                });
-                throw new Error(constants_1.ERROR_MESSAGES.DEFAULT);
-            }
-        });
-    }
-    /**
-     * Get all user sessions
-     * @returns Promise resolving to session data
-     */
-    getSessions() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                // Get the current user ID
-                const userId = yield (0, storage_1.getData)(constants_1.STORAGE_KEYS.USER_ID);
-                if (!userId) {
-                    console.warn('No user ID available when fetching sessions');
-                    // Return empty sessions if there's no user ID
-                    return { sessions: [] };
-                }
-                // First try to get from API with the user ID as a query parameter
-                const response = yield api_service_1.apiService.get(constants_1.ENDPOINTS.USERS.SESSIONS, {
-                    useCache: true,
-                    params: { userId } // Include userId as a parameter
-                });
-                // Store the sessions locally for offline access
-                yield (0, storage_1.storeData)(constants_1.STORAGE_KEYS.SESSIONS, response.data.sessions);
-                return response.data;
-            }
-            catch (error) {
-                errorHandler_1.default.handleError(error, {
-                    context: 'Error fetching sessions',
-                    showToast: false
-                });
-                // Fallback to locally stored sessions
-                const localSessions = yield (0, storage_1.getData)(constants_1.STORAGE_KEYS.SESSIONS);
-                if (localSessions) {
-                    return { sessions: localSessions };
-                }
-                return { sessions: [] }; // Return empty sessions array if nothing found
-            }
-        });
-    }
-    /**
-     * Switch to a different user session
-     * @param userId ID of the user to switch to
-     * @returns Promise resolving to session switch response
-     */
-    switchSession(userId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!userId)
-                throw new Error('User ID is required');
-            try {
-                const response = yield api_service_1.apiService.post('/auth/switch-session', { userId });
-                return response.data;
-            }
-            catch (error) {
-                errorHandler_1.default.handleError(error, {
-                    context: 'Error switching session',
-                    fallbackMessage: constants_1.ERROR_MESSAGES.DEFAULT
-                });
-                throw new Error(constants_1.ERROR_MESSAGES.DEFAULT);
-            }
-        });
-    }
-    /**
-     * Get recommended profiles to follow
-     * @param limit Optional number of recommendations to return
-     * @returns Promise resolving to array of recommended profiles
-     */
-    getRecommendations(limit) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const params = limit ? { limit: limit.toString() } : undefined;
-                const response = yield api_service_1.apiService.get('/profiles/recommendations', {
-                    params,
-                    useCache: true,
-                    cacheTTL: 15 * 60 * 1000 // 15 minutes cache for recommendations
-                });
-                return response.data;
-            }
-            catch (error) {
-                errorHandler_1.default.handleError(error, {
-                    context: 'Error fetching recommendations',
-                    showToast: false
-                });
-                return []; // Return empty array instead of throwing
-            }
-        });
-    }
-    /**
-     * Clear profile cache
-     * @param userId Optional user ID to clear specific cache entry
-     */
-    clearProfileCache(userId) {
-        if (userId) {
-            this.profileCache.delete(userId);
-        }
-        else {
-            this.profileCache.clear();
-        }
-    }
-}
-exports.OxyClient = OxyClient;
-// Export singleton instance
-exports.oxyClient = new OxyClient();

package/dist/services/api.service.d.ts

@@ -1,61 +0,0 @@
-import { AxiosResponse } from 'axios';
-declare class ApiService {
-    private api;
-    private isRefreshing;
-    private failedQueue;
-    private cache;
-    private abortControllers;
-    constructor();
-    private setupInterceptors;
-    private processQueue;
-    private getRequestId;
-    private getCacheKey;
-    private isCacheValid;
-    /**
-     * Cancel all pending requests
-     */
-    cancelAllRequests(): void;
-    /**
-     * Cancel a specific request
-     */
-    cancelRequest(requestId: string): void;
-    /**
-     * Clear the entire cache
-     */
-    clearCache(): void;
-    /**
-     * Clear a specific cache entry
-     */
-    clearCacheEntry(url: string, params?: any): void;
-    /**
-     * Make a GET request with optional caching
-     */
-    get<T>(url: string, config?: {
-        params?: any;
-        useCache?: boolean;
-        cacheTTL?: number;
-        headers?: any;
-    }): Promise<AxiosResponse<T>>;
-    /**
-     * Make a POST request
-     */
-    post<T>(url: string, data?: any, config?: any): Promise<AxiosResponse<T>>;
-    /**
-     * Make a PUT request
-     */
-    put<T>(url: string, data?: any, config?: any): Promise<AxiosResponse<T>>;
-    /**
-     * Make a DELETE request
-     */
-    delete<T>(url: string, config?: any): Promise<AxiosResponse<T>>;
-    /**
-     * Make a PATCH request
-     */
-    patch<T>(url: string, data?: any, config?: any): Promise<AxiosResponse<T>>;
-    /**
-     * Handle common request errors
-     */
-    private handleRequestError;
-}
-export declare const apiService: ApiService;
-export {};

package/dist/services/api.service.js

@@ -1,289 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.apiService = void 0;
-const axios_1 = __importDefault(require("axios"));
-const storage_1 = require("../utils/storage");
-const config_1 = require("../config");
-const constants_1 = require("../constants");
-// Import authEvents instead of showAuthBottomSheet
-const authEvents_1 = require("../utils/authEvents");
-class ApiService {
-    constructor() {
-        this.isRefreshing = false;
-        this.failedQueue = [];
-        this.cache = new Map();
-        this.abortControllers = new Map();
-        this.api = axios_1.default.create({
-            baseURL: config_1.OXY_API_CONFIG.BASE_URL,
-            timeout: config_1.OXY_API_CONFIG.TIMEOUT,
-            headers: {
-                'Content-Type': 'application/json'
-            }
-        });
-        this.setupInterceptors();
-    }
-    setupInterceptors() {
-        this.api.interceptors.request.use((config) => __awaiter(this, void 0, void 0, function* () {
-            try {
-                const accessToken = yield (0, storage_1.getSecureData)('accessToken');
-                if (accessToken && config.headers) {
-                    config.headers.Authorization = `Bearer ${accessToken}`;
-                }
-                // Add abort controller to each request
-                if (config.method && ['get', 'post', 'put', 'delete', 'patch'].includes(config.method)) {
-                    const controller = new AbortController();
-                    const requestId = this.getRequestId(config);
-                    this.abortControllers.set(requestId, controller);
-                    config.signal = controller.signal;
-                }
-                return config;
-            }
-            catch (error) {
-                console.error('Error in request interceptor:', error);
-                return config;
-            }
-        }));
-        this.api.interceptors.response.use((response) => response, (error) => __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const originalRequest = error.config;
-            // Clean up abort controller after request completes
-            if (originalRequest) {
-                const requestId = this.getRequestId(originalRequest);
-                this.abortControllers.delete(requestId);
-            }
-            if (!originalRequest || ((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) !== 401 || originalRequest._retry) {
-                return Promise.reject(error);
-            }
-            if (this.isRefreshing) {
-                return new Promise((resolve, reject) => {
-                    this.failedQueue.push({ resolve, reject, config: originalRequest });
-                });
-            }
-            originalRequest._retry = true;
-            this.isRefreshing = true;
-            try {
-                const refreshToken = yield (0, storage_1.getSecureData)('refreshToken');
-                if (!refreshToken) {
-                    throw new Error('No refresh token available');
-                }
-                const response = yield axios_1.default.post(`${config_1.OXY_API_CONFIG.BASE_URL}/auth/refresh`, { refreshToken });
-                const { accessToken, refreshToken: newRefreshToken } = response.data;
-                if (!accessToken) {
-                    throw new Error('Invalid refresh response');
-                }
-                // Store new tokens
-                yield Promise.all([
-                    (0, storage_1.storeSecureData)('accessToken', accessToken),
-                    newRefreshToken ? (0, storage_1.storeSecureData)('refreshToken', newRefreshToken) : Promise.resolve()
-                ]);
-                // Update authorization header
-                this.api.defaults.headers.common['Authorization'] = `Bearer ${accessToken}`;
-                if (originalRequest.headers) {
-                    originalRequest.headers['Authorization'] = `Bearer ${accessToken}`;
-                }
-                // Process queued requests
-                this.processQueue(null, accessToken);
-                // Retry original request
-                return this.api(originalRequest);
-            }
-            catch (refreshError) {
-                // Process queued requests with error
-                this.processQueue(refreshError);
-                // Clear tokens and show auth screen
-                yield Promise.all([
-                    (0, storage_1.storeSecureData)('accessToken', null),
-                    (0, storage_1.storeSecureData)('refreshToken', null)
-                ]);
-                // Use authEvents instead of direct function call
-                authEvents_1.authEvents.requireAuth();
-                return Promise.reject(refreshError);
-            }
-            finally {
-                this.isRefreshing = false;
-            }
-        }));
-    }
-    processQueue(error, accessToken) {
-        this.failedQueue.forEach(({ resolve, reject, config }) => {
-            if (error) {
-                reject(error);
-            }
-            else if (accessToken && config.headers) {
-                config.headers['Authorization'] = `Bearer ${accessToken}`;
-                resolve(this.api(config));
-            }
-        });
-        this.failedQueue = [];
-    }
-    getRequestId(config) {
-        const { method, url, params, data } = config;
-        return `${method}:${url}:${JSON.stringify(params || {})}:${JSON.stringify(data || {})}`;
-    }
-    getCacheKey(url, params) {
-        return `${url}:${JSON.stringify(params || {})}`;
-    }
-    isCacheValid(cacheItem) {
-        return Date.now() < cacheItem.expiresAt;
-    }
-    /**
-     * Cancel all pending requests
-     */
-    cancelAllRequests() {
-        this.abortControllers.forEach(controller => {
-            controller.abort();
-        });
-        this.abortControllers.clear();
-    }
-    /**
-     * Cancel a specific request
-     */
-    cancelRequest(requestId) {
-        const controller = this.abortControllers.get(requestId);
-        if (controller) {
-            controller.abort();
-            this.abortControllers.delete(requestId);
-        }
-    }
-    /**
-     * Clear the entire cache
-     */
-    clearCache() {
-        this.cache.clear();
-    }
-    /**
-     * Clear a specific cache entry
-     */
-    clearCacheEntry(url, params) {
-        const cacheKey = this.getCacheKey(url, params);
-        this.cache.delete(cacheKey);
-    }
-    /**
-     * Make a GET request with optional caching
-     */
-    get(url, config) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { params, useCache = false, cacheTTL = config_1.OXY_CACHE_CONFIG.DEFAULT_TTL } = config || {};
-            if (useCache) {
-                const cacheKey = this.getCacheKey(url, params);
-                const cachedItem = this.cache.get(cacheKey);
-                if (cachedItem && this.isCacheValid(cachedItem)) {
-                    return {
-                        data: cachedItem.data,
-                        status: 200,
-                        statusText: 'OK (cached)',
-                        headers: {},
-                        config: {}
-                    };
-                }
-            }
-            try {
-                const response = yield this.api.get(url, Object.assign({}, config));
-                if (useCache) {
-                    const cacheKey = this.getCacheKey(url, params);
-                    this.cache.set(cacheKey, {
-                        data: response.data,
-                        timestamp: Date.now(),
-                        expiresAt: Date.now() + cacheTTL
-                    });
-                }
-                return response;
-            }
-            catch (error) {
-                this.handleRequestError(error);
-                throw error;
-            }
-        });
-    }
-    /**
-     * Make a POST request
-     */
-    post(url, data, config) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                return yield this.api.post(url, data, config);
-            }
-            catch (error) {
-                this.handleRequestError(error);
-                throw error;
-            }
-        });
-    }
-    /**
-     * Make a PUT request
-     */
-    put(url, data, config) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                return yield this.api.put(url, data, config);
-            }
-            catch (error) {
-                this.handleRequestError(error);
-                throw error;
-            }
-        });
-    }
-    /**
-     * Make a DELETE request
-     */
-    delete(url, config) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                return yield this.api.delete(url, config);
-            }
-            catch (error) {
-                this.handleRequestError(error);
-                throw error;
-            }
-        });
-    }
-    /**
-     * Make a PATCH request
-     */
-    patch(url, data, config) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                return yield this.api.patch(url, data, config);
-            }
-            catch (error) {
-                this.handleRequestError(error);
-                throw error;
-            }
-        });
-    }
-    /**
-     * Handle common request errors
-     */
-    handleRequestError(error) {
-        if (axios_1.default.isAxiosError(error)) {
-            const axiosError = error;
-            if (axiosError.code === 'ECONNABORTED') {
-                console.error('Request timeout:', axiosError.message);
-            }
-            else if (axiosError.response) {
-                console.error(`API Error ${axiosError.response.status}:`, axiosError.response.data || constants_1.ERROR_MESSAGES.DEFAULT);
-            }
-            else if (axiosError.request) {
-                console.error('No response received:', axiosError.message);
-            }
-            else {
-                console.error('Request error:', axiosError.message);
-            }
-        }
-        else {
-            console.error('Unexpected error:', error);
-        }
-    }
-}
-exports.apiService = new ApiService();