@oxyhq/services 0.1.0 → 0.1.2

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();

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

@@ -1,87 +0,0 @@
-/**
- * Authentication Service
- *
- * Manages user authentication, session validation, and token management.
- */
-/**
- * User profile information
- */
-export interface User {
-    id: string;
-    username: string;
-    email: string;
-    name?: {
-        first?: string;
-        last?: string;
-    };
-    avatar?: string;
-    avatarSource?: {
-        uri: string;
-    };
-}
-/**
- * Response from registration endpoint
- */
-interface RegisterResponse {
-    success: boolean;
-    message: string;
-    accessToken: string;
-    refreshToken: string;
-    user: User;
-}
-/**
- * Authentication service class
- */
-declare class AuthService {
-    /**
-     * Register a new user
-     */
-    register(user: {
-        username: string;
-        email: string;
-        password: string;
-    }): Promise<RegisterResponse>;
-    /**
-     * Login a user with credentials
-     */
-    login(credentials: {
-        username: string;
-        password: string;
-    }): Promise<void>;
-    /**
-     * Validate the current user session
-     */
-    validateCurrentSession(): Promise<boolean>;
-    /**
-     * Refresh the access token using the refresh token
-     */
-    refreshToken(): Promise<{
-        accessToken: string;
-        refreshToken: string;
-    } | false>;
-    /**
-     * Check if the token needs to be refreshed
-     */
-    shouldRefreshToken(token: string): boolean;
-    /**
-     * Logout the current user
-     */
-    logout(): Promise<void>;
-    /**
-     * Check if the user is authenticated
-     */
-    isAuthenticated(): Promise<boolean>;
-    /**
-     * Get the current user ID from stored data or JWT token
-     */
-    getCurrentSessionUserId(): Promise<string | null>;
-    /**
-     * Check if a username is available
-     */
-    checkUsernameAvailability(username: string): Promise<{
-        available: boolean;
-        message?: string;
-    }>;
-}
-export declare const authService: AuthService;
-export {};

package/dist/services/auth.service.js

@@ -1,266 +0,0 @@
-"use strict";
-/**
- * Authentication Service
- *
- * Manages user authentication, session validation, and token management.
- */
-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.authService = void 0;
-const axios_1 = __importDefault(require("axios"));
-const api_service_1 = require("./api.service");
-const storage_1 = require("../utils/storage");
-const user_service_1 = require("./user.service");
-const constants_1 = require("../constants");
-/**
- * Authentication service class
- */
-class AuthService {
-    /**
-     * Register a new user
-     */
-    register(user) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            try {
-                const response = yield api_service_1.apiService.post(constants_1.ENDPOINTS.AUTH.REGISTER, user);
-                if (response.data.success && response.data.accessToken && response.data.refreshToken) {
-                    // Store tokens and user data securely
-                    yield Promise.all([
-                        (0, storage_1.storeSecureData)(constants_1.STORAGE_KEYS.ACCESS_TOKEN, response.data.accessToken),
-                        (0, storage_1.storeSecureData)(constants_1.STORAGE_KEYS.REFRESH_TOKEN, response.data.refreshToken),
-                        (0, storage_1.storeData)(constants_1.STORAGE_KEYS.USER, response.data.user),
-                        (0, storage_1.storeData)(constants_1.STORAGE_KEYS.USER_ID, response.data.user.id)
-                    ]);
-                }
-                return response.data;
-            }
-            catch (error) {
-                if (axios_1.default.isAxiosError(error) && ((_a = error.response) === null || _a === void 0 ? void 0 : _a.data)) {
-                    throw error.response.data;
-                }
-                throw error;
-            }
-        });
-    }
-    /**
-     * Login a user with credentials
-     */
-    login(credentials) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            // Validate credentials before making the request
-            const validationErrors = {
-                username: !credentials.username ? "Username is required" : null,
-                password: !credentials.password ? "Password is required" : null
-            };
-            const hasErrors = Object.values(validationErrors).some(error => error !== null);
-            if (hasErrors) {
-                throw {
-                    message: constants_1.ERROR_MESSAGES.VALIDATION,
-                    details: validationErrors
-                };
-            }
-            try {
-                const response = yield api_service_1.apiService.post(constants_1.ENDPOINTS.AUTH.LOGIN, credentials);
-                const { user, accessToken, refreshToken } = response.data;
-                // Store tokens and user data securely
-                yield Promise.all([
-                    (0, storage_1.storeSecureData)(constants_1.STORAGE_KEYS.ACCESS_TOKEN, accessToken),
-                    (0, storage_1.storeSecureData)(constants_1.STORAGE_KEYS.REFRESH_TOKEN, refreshToken),
-                    (0, storage_1.storeData)(constants_1.STORAGE_KEYS.USER, user),
-                    (0, storage_1.storeData)(constants_1.STORAGE_KEYS.USER_ID, user.id),
-                    user_service_1.userService.addUserSession(user, accessToken, refreshToken)
-                ]);
-            }
-            catch (error) {
-                if (axios_1.default.isAxiosError(error) && ((_a = error.response) === null || _a === void 0 ? void 0 : _a.data)) {
-                    if (error.response.data.details) {
-                        throw {
-                            message: error.response.data.message || constants_1.ERROR_MESSAGES.VALIDATION,
-                            details: error.response.data.details
-                        };
-                    }
-                    throw error.response.data;
-                }
-                console.error('Login error:', error);
-                throw error;
-            }
-        });
-    }
-    /**
-     * Validate the current user session
-     */
-    validateCurrentSession() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const accessToken = yield (0, storage_1.getSecureData)(constants_1.STORAGE_KEYS.ACCESS_TOKEN);
-                if (!accessToken)
-                    return false;
-                // Check if token needs refresh
-                if (this.shouldRefreshToken(accessToken)) {
-                    const refreshResult = yield this.refreshToken();
-                    if (!refreshResult)
-                        return false;
-                }
-                const response = yield api_service_1.apiService.get(constants_1.ENDPOINTS.AUTH.VALIDATE);
-                return response.data.valid;
-            }
-            catch (error) {
-                return false;
-            }
-        });
-    }
-    /**
-     * Refresh the access token using the refresh token
-     */
-    refreshToken() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const currentRefreshToken = yield (0, storage_1.getSecureData)(constants_1.STORAGE_KEYS.REFRESH_TOKEN);
-                if (!currentRefreshToken) {
-                    return false;
-                }
-                const response = yield api_service_1.apiService.post(constants_1.ENDPOINTS.AUTH.REFRESH, { refreshToken: currentRefreshToken });
-                const { accessToken, refreshToken = currentRefreshToken } = response.data;
-                if (!accessToken) {
-                    throw new Error('Invalid refresh response');
-                }
-                // Store tokens securely
-                yield Promise.all([
-                    (0, storage_1.storeSecureData)(constants_1.STORAGE_KEYS.ACCESS_TOKEN, accessToken),
-                    (0, storage_1.storeSecureData)(constants_1.STORAGE_KEYS.REFRESH_TOKEN, refreshToken)
-                ]);
-                return { accessToken, refreshToken };
-            }
-            catch (error) {
-                console.error('Token refresh failed:', error);
-                yield this.logout();
-                return false;
-            }
-        });
-    }
-    /**
-     * Check if the token needs to be refreshed
-     */
-    shouldRefreshToken(token) {
-        try {
-            const parts = token.split('.');
-            if (parts.length !== 3)
-                return true;
-            const payload = JSON.parse(atob(parts[1]));
-            const exp = payload.exp * 1000; // Convert to milliseconds
-            const now = Date.now();
-            // Refresh if token expires in less than 5 minutes
-            return exp - now < 5 * 60 * 1000;
-        }
-        catch (error) {
-            console.error('Error checking token expiration:', error);
-            return true;
-        }
-    }
-    /**
-     * Logout the current user
-     */
-    logout() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const session = yield user_service_1.userService.getActiveSession();
-                if (session === null || session === void 0 ? void 0 : session.id) {
-                    yield user_service_1.userService.removeUserSession(session.id);
-                }
-                // Clear all secure data
-                yield Promise.all([
-                    (0, storage_1.clearSecureData)(constants_1.STORAGE_KEYS.ACCESS_TOKEN),
-                    (0, storage_1.clearSecureData)(constants_1.STORAGE_KEYS.REFRESH_TOKEN)
-                ]);
-                // Optional: Call logout endpoint to invalidate on server
-                try {
-                    yield api_service_1.apiService.post(constants_1.ENDPOINTS.AUTH.LOGOUT);
-                }
-                catch (error) {
-                    // Continue with logout even if server call fails
-                    console.warn('Server logout failed:', error);
-                }
-            }
-            catch (error) {
-                console.error('Logout error:', error);
-                throw error;
-            }
-        });
-    }
-    /**
-     * Check if the user is authenticated
-     */
-    isAuthenticated() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const session = yield user_service_1.userService.getActiveSession();
-                const accessToken = yield (0, storage_1.getSecureData)(constants_1.STORAGE_KEYS.ACCESS_TOKEN);
-                return !!(session && accessToken);
-            }
-            catch (_a) {
-                return false;
-            }
-        });
-    }
-    /**
-     * Get the current user ID from stored data or JWT token
-     */
-    getCurrentSessionUserId() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                // First try to get the stored userId
-                const userId = yield (0, storage_1.getSecureData)(constants_1.STORAGE_KEYS.USER_ID);
-                if (userId)
-                    return userId;
-                // If not available, try to decode from token
-                const token = yield (0, storage_1.getSecureData)(constants_1.STORAGE_KEYS.ACCESS_TOKEN);
-                if (!token)
-                    return null;
-                const parts = token.split('.');
-                if (parts.length !== 3)
-                    return null;
-                const payload = JSON.parse(atob(parts[1]));
-                return payload.id || null;
-            }
-            catch (error) {
-                console.error('Error decoding token:', error);
-                return null;
-            }
-        });
-    }
-    /**
-     * Check if a username is available
-     */
-    checkUsernameAvailability(username) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            try {
-                const response = yield api_service_1.apiService.get(`/auth/check-username/${username}`);
-                return response.data;
-            }
-            catch (error) {
-                if (axios_1.default.isAxiosError(error) && ((_a = error.response) === null || _a === void 0 ? void 0 : _a.data)) {
-                    return {
-                        available: false,
-                        message: error.response.data.message || 'Username is not available'
-                    };
-                }
-                throw error;
-            }
-        });
-    }
-}
-exports.authService = new AuthService();

package/dist/services/index.d.ts

@@ -1,30 +0,0 @@
-/**
- * OxyHQ Services
- *
- * This file exports all services for interacting with the OxyHQ API.
- * These services provide core functionality for authentication, data fetching,
- * and other backend operations.
- */
-export { apiService } from './api.service';
-export { OxyClient } from './OxyClient';
-import { OxyClient as OxyClientType } from './OxyClient';
-import { authService as AuthServiceType } from './auth.service';
-import { userService as UserServiceType } from './user.service';
-import { profileService as ProfileServiceType } from './profile.service';
-import { paymentService as PaymentServiceType } from './payment.service';
-import { subscriptionService as SubscriptionServiceType } from './subscription.service';
-import { privacyService as PrivacyServiceType } from './privacy.service';
-export declare const getOxyClient: () => OxyClientType;
-export declare const getAuthService: () => typeof AuthServiceType;
-export declare const getUserService: () => typeof UserServiceType;
-export declare const getProfileService: () => typeof ProfileServiceType;
-export declare const getPaymentService: () => typeof PaymentServiceType;
-export declare const getSubscriptionService: () => typeof SubscriptionServiceType;
-export declare const getPrivacyService: () => typeof PrivacyServiceType;
-export { getOxyClient as oxyClient };
-export { getAuthService as authService };
-export { getUserService as userService };
-export { getProfileService as profileService };
-export { getPaymentService as paymentService };
-export { getSubscriptionService as subscriptionService };
-export { getPrivacyService as privacyService };