@oxyhq/services 0.0.84 → 0.1.0

package/dist/constants.d.ts

@@ -0,0 +1,54 @@
+/**
+ * OxyHQ Services Constants
+ *
+ * This file contains constants used throughout the OxyHQ services module.
+ * Centralizing these values helps maintain consistency across the application.
+ */
+export declare const ENDPOINTS: {
+    AUTH: {
+        LOGIN: string;
+        REGISTER: string;
+        REFRESH: string;
+        LOGOUT: string;
+        VALIDATE: string;
+    };
+    USERS: {
+        PROFILE: (id: string) => string;
+        SESSIONS: string;
+        FOLLOWERS: (id: string) => string;
+        FOLLOWING: (id: string) => string;
+    };
+    FILES: {
+        LIST: (userId: string) => string;
+        UPLOAD: string;
+        DELETE: (fileId: string) => string;
+    };
+    SUBSCRIPTION: {
+        GET: (userId: string) => string;
+        UPDATE: (userId: string) => string;
+        CANCEL: (userId: string) => string;
+    };
+};
+export declare const STORAGE_KEYS: {
+    readonly ACCESS_TOKEN: "@oxy/access_token";
+    readonly REFRESH_TOKEN: "@oxy/refresh_token";
+    readonly USER: "@oxy/user";
+    readonly USER_ID: "@oxy/user_id";
+    readonly SESSIONS: "@oxy/sessions";
+};
+export declare const DEFAULTS: {
+    SESSION_EXPIRE_TIME: number;
+    CACHE_TIMEOUT: number;
+    MAX_FILES: number;
+    MAX_UPLOAD_SIZE: number;
+    ALLOWED_FILE_TYPES: string[];
+};
+export declare const ERROR_MESSAGES: {
+    DEFAULT: string;
+    NETWORK: string;
+    UNAUTHORIZED: string;
+    VALIDATION: string;
+    FILE_SIZE: string;
+    FILE_TYPE: string;
+    SESSION_EXPIRED: string;
+};

package/dist/constants.js

@@ -0,0 +1,61 @@
+"use strict";
+/**
+ * OxyHQ Services Constants
+ *
+ * This file contains constants used throughout the OxyHQ services module.
+ * Centralizing these values helps maintain consistency across the application.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERROR_MESSAGES = exports.DEFAULTS = exports.STORAGE_KEYS = exports.ENDPOINTS = void 0;
+// API Endpoints
+exports.ENDPOINTS = {
+    AUTH: {
+        LOGIN: '/auth/login',
+        REGISTER: '/auth/register',
+        REFRESH: '/auth/refresh',
+        LOGOUT: '/auth/logout',
+        VALIDATE: '/auth/validate',
+    },
+    USERS: {
+        PROFILE: (id) => `/users/${id}`,
+        SESSIONS: '/users/sessions',
+        FOLLOWERS: (id) => `/users/${id}/followers`,
+        FOLLOWING: (id) => `/users/${id}/following`,
+    },
+    FILES: {
+        LIST: (userId) => `/files/list/${userId}`,
+        UPLOAD: '/files/upload',
+        DELETE: (fileId) => `/files/${fileId}`,
+    },
+    SUBSCRIPTION: {
+        GET: (userId) => `/subscriptions/${userId}`,
+        UPDATE: (userId) => `/subscriptions/${userId}`,
+        CANCEL: (userId) => `/subscriptions/${userId}`,
+    }
+};
+// Storage Keys
+exports.STORAGE_KEYS = {
+    ACCESS_TOKEN: '@oxy/access_token',
+    REFRESH_TOKEN: '@oxy/refresh_token',
+    USER: '@oxy/user',
+    USER_ID: '@oxy/user_id',
+    SESSIONS: '@oxy/sessions'
+};
+// Default values
+exports.DEFAULTS = {
+    SESSION_EXPIRE_TIME: 7 * 24 * 60 * 60 * 1000, // 7 days
+    CACHE_TIMEOUT: 5 * 60 * 1000, // 5 minutes
+    MAX_FILES: 5,
+    MAX_UPLOAD_SIZE: 10 * 1024 * 1024, // 10MB
+    ALLOWED_FILE_TYPES: ['image/', 'video/', 'application/pdf'],
+};
+// Error messages
+exports.ERROR_MESSAGES = {
+    DEFAULT: 'An error occurred. Please try again.',
+    NETWORK: 'Network error. Please check your connection.',
+    UNAUTHORIZED: 'Session expired. Please sign in again.',
+    VALIDATION: 'Please check the form for errors.',
+    FILE_SIZE: 'File too large. Maximum size is 10MB.',
+    FILE_TYPE: 'Invalid file type.',
+    SESSION_EXPIRED: 'Your session has expired. Please sign in again.'
+};

package/dist/hooks/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * OxyHQ Services Hooks
+ *
+ * This file exports all hooks for use with OxyHQ services module.
+ * These hooks provide React-friendly interfaces to the underlying services.
+ */
+export { useAuth } from './useAuth';
+export { useSession } from './useSession';
+export { useProfile } from './useProfile';
+export { useFiles } from './useFiles';
+export { useSubscription } from './useSubscription';

package/dist/hooks/index.js

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * OxyHQ Services Hooks
+ *
+ * This file exports all hooks for use with OxyHQ services module.
+ * These hooks provide React-friendly interfaces to the underlying services.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSubscription = exports.useFiles = exports.useProfile = exports.useSession = exports.useAuth = void 0;
+// Authentication and Session Management
+var useAuth_1 = require("./useAuth");
+Object.defineProperty(exports, "useAuth", { enumerable: true, get: function () { return useAuth_1.useAuth; } });
+var useSession_1 = require("./useSession");
+Object.defineProperty(exports, "useSession", { enumerable: true, get: function () { return useSession_1.useSession; } });
+// Profile Management
+var useProfile_1 = require("./useProfile");
+Object.defineProperty(exports, "useProfile", { enumerable: true, get: function () { return useProfile_1.useProfile; } });
+// File Management
+var useFiles_1 = require("./useFiles");
+Object.defineProperty(exports, "useFiles", { enumerable: true, get: function () { return useFiles_1.useFiles; } });
+// Subscription Management
+var useSubscription_1 = require("./useSubscription");
+Object.defineProperty(exports, "useSubscription", { enumerable: true, get: function () { return useSubscription_1.useSubscription; } });

package/dist/hooks/useAuth.d.ts

@@ -0,0 +1,6 @@
+import type { User } from '../services/auth.service';
+export declare function useAuth(): {
+    token: string | null;
+    user: User | null;
+    isAuthenticated: boolean;
+};

package/dist/hooks/useAuth.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAuth = useAuth;
+const react_1 = require("react");
+const SessionProvider_1 = require("../components/SessionProvider");
+function useAuth() {
+    var _a;
+    const context = (0, react_1.useContext)(SessionProvider_1.SessionContext);
+    if (!context) {
+        throw new Error('useAuth must be used within a SessionProvider');
+    }
+    return {
+        token: ((_a = context.state.user) === null || _a === void 0 ? void 0 : _a.id) ? 'secured' : null,
+        user: context.state.user,
+        isAuthenticated: !!context.state.user,
+    };
+}

package/dist/hooks/useFiles.d.ts

@@ -0,0 +1,10 @@
+import { FileType, UseFilesOptions } from '../components/FileSelectorModal/types';
+export declare function useFiles({ fileTypeFilter, maxFiles, userId }?: UseFilesOptions): {
+    files: FileType[];
+    loading: boolean;
+    uploading: boolean;
+    error: string | null;
+    fetchFiles: (forceRefresh?: boolean) => Promise<void>;
+    uploadFiles: () => Promise<void>;
+    deleteFile: (fileId: string) => Promise<void>;
+};

package/dist/hooks/useFiles.js

@@ -0,0 +1,329 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFiles = useFiles;
+const react_1 = require("react");
+const react_i18next_1 = require("react-i18next");
+const sonner_1 = require("sonner");
+const ImagePicker = __importStar(require("expo-image-picker"));
+const DocumentPicker = __importStar(require("expo-document-picker"));
+const react_native_1 = require("react-native");
+const api_1 = __importStar(require("../utils/api"));
+const storage_1 = require("../utils/storage");
+const api_2 = require("../utils/api");
+const SessionProvider_1 = require("../components/SessionProvider");
+const constants_1 = require("../constants");
+// Cache for files to improve performance across component instances
+const globalFileCache = new Map();
+// Cache expiration time (5 minutes)
+const CACHE_EXPIRATION = 5 * 60 * 1000;
+// Error handling utility
+const handleFileError = (error, t, context) => {
+    var _a, _b;
+    console.error(`[Files][${context}] Error:`, error);
+    let errorMessage = t("An error occurred");
+    if ((_b = (_a = error === null || error === void 0 ? void 0 : error.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.message) {
+        errorMessage = error.response.data.message;
+    }
+    else if (error === null || error === void 0 ? void 0 : error.message) {
+        errorMessage = error.message;
+    }
+    sonner_1.toast.error(errorMessage);
+};
+function useFiles({ fileTypeFilter = [], maxFiles = 5, userId } = {}) {
+    const [files, setFiles] = (0, react_1.useState)([]);
+    const [loading, setLoading] = (0, react_1.useState)(true);
+    const [uploading, setUploading] = (0, react_1.useState)(false);
+    const [error, setError] = (0, react_1.useState)(null);
+    const { t } = (0, react_i18next_1.useTranslation)();
+    const sessionContext = (0, react_1.useContext)(SessionProvider_1.SessionContext);
+    // Use a ref to track the abort controller for fetch operations
+    const abortControllerRef = (0, react_1.useRef)(null);
+    // Use a ref to track the current user ID for cleanup
+    const currentUserIdRef = (0, react_1.useRef)(userId);
+    // Memoize the effective user ID
+    const effectiveUserId = (0, react_1.useMemo)(() => userId || (sessionContext === null || sessionContext === void 0 ? void 0 : sessionContext.getCurrentUserId()) || undefined, [userId, sessionContext]);
+    // Update the ref when userId changes
+    (0, react_1.useEffect)(() => {
+        currentUserIdRef.current = userId;
+    }, [userId]);
+    // Cleanup function for component unmount
+    (0, react_1.useEffect)(() => {
+        return () => {
+            if (abortControllerRef.current) {
+                abortControllerRef.current.abort();
+            }
+        };
+    }, []);
+    // Generate cache key based on user ID and file type filter
+    const getCacheKey = (0, react_1.useCallback)((uid) => `${uid}-${fileTypeFilter.join(',')}`, [fileTypeFilter]);
+    const fetchFiles = (0, react_1.useCallback)((...args_1) => __awaiter(this, [...args_1], void 0, function* (forceRefresh = false) {
+        var _a, _b;
+        if (!effectiveUserId) {
+            console.warn('[Files] No user ID available');
+            setFiles([]);
+            setLoading(false);
+            setError("User not authenticated");
+            return;
+        }
+        try {
+            setError(null);
+            const accessToken = yield (0, storage_1.getSecureData)(constants_1.STORAGE_KEYS.ACCESS_TOKEN);
+            const refreshToken = yield (0, storage_1.getSecureData)(constants_1.STORAGE_KEYS.REFRESH_TOKEN);
+            if (!accessToken || !refreshToken) {
+                console.warn('[Files] Missing auth tokens');
+                setFiles([]);
+                setLoading(false);
+                setError("Authentication required");
+                return;
+            }
+            // Check cache first
+            const cacheKey = getCacheKey(effectiveUserId);
+            const cachedData = globalFileCache.get(cacheKey);
+            const now = Date.now();
+            if (!forceRefresh && cachedData && (now - cachedData.timestamp < CACHE_EXPIRATION)) {
+                console.log('[Files] Using cached files data');
+                setFiles(cachedData.files);
+                setLoading(false);
+                return;
+            }
+            console.log('[Files] Fetching files for user:', effectiveUserId);
+            setLoading(true);
+            // Cancel any in-progress requests
+            if (abortControllerRef.current) {
+                abortControllerRef.current.abort();
+            }
+            abortControllerRef.current = new AbortController();
+            const signal = abortControllerRef.current.signal;
+            // Attempt token refresh only if needed
+            const isValid = yield (0, api_1.validateSession)().catch(() => false);
+            if (!isValid) {
+                console.log('[Files] Session invalid, refreshing token');
+                try {
+                    yield (0, api_2.refreshAccessToken)();
+                }
+                catch (refreshError) {
+                    console.error('[Files] Token refresh failed:', refreshError);
+                    setFiles([]);
+                    setLoading(false);
+                    setError("Session expired");
+                    return;
+                }
+            }
+            const response = yield api_1.default.get(`/files/list/${effectiveUserId}`, {
+                signal,
+                params: forceRefresh ? { _t: Date.now() } : undefined
+            });
+            let fetchedFiles = response.data;
+            if (fileTypeFilter.length > 0) {
+                fetchedFiles = fetchedFiles.filter((file) => fileTypeFilter.some(type => file.contentType.startsWith(type)));
+            }
+            // Sort files by upload date (newest first)
+            fetchedFiles.sort((a, b) => {
+                const dateA = a.uploadDate || '';
+                const dateB = b.uploadDate || '';
+                return new Date(dateB).getTime() - new Date(dateA).getTime();
+            });
+            globalFileCache.set(cacheKey, {
+                files: fetchedFiles,
+                timestamp: now,
+                userId: effectiveUserId
+            });
+            if (currentUserIdRef.current === userId) {
+                setFiles(fetchedFiles);
+                setError(null);
+            }
+        }
+        catch (error) {
+            if (error.name === 'AbortError') {
+                console.log('[Files] Fetch aborted');
+                return;
+            }
+            handleFileError(error, t, 'fetchFiles');
+            setFiles([]);
+            setError(((_b = (_a = error === null || error === void 0 ? void 0 : error.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.message) || t("Error fetching files"));
+        }
+        finally {
+            if (currentUserIdRef.current === userId) {
+                setLoading(false);
+            }
+        }
+    }), [effectiveUserId, fileTypeFilter, t, getCacheKey, userId]);
+    const uploadFiles = (0, react_1.useCallback)(() => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c;
+        if (!effectiveUserId) {
+            sonner_1.toast.error(t("User not authenticated"));
+            setError("User not authenticated");
+            return;
+        }
+        try {
+            setError(null);
+            const accessToken = yield (0, storage_1.getSecureData)(constants_1.STORAGE_KEYS.ACCESS_TOKEN);
+            if (!accessToken) {
+                sonner_1.toast.error(t("Authentication required"));
+                setError("Authentication required");
+                return;
+            }
+            let result;
+            if (fileTypeFilter.includes("image/") || fileTypeFilter.includes("video/")) {
+                result = yield ImagePicker.launchImageLibraryAsync({
+                    mediaTypes: fileTypeFilter.includes("video/") ?
+                        ImagePicker.MediaTypeOptions.All :
+                        ImagePicker.MediaTypeOptions.Images,
+                    allowsMultipleSelection: true,
+                    quality: 0.8,
+                    exif: false
+                });
+            }
+            else {
+                result = yield DocumentPicker.getDocumentAsync({
+                    type: fileTypeFilter.length > 0 ? fileTypeFilter.map(type => `${type}*`).join(",") : "*/*",
+                    multiple: true,
+                    copyToCacheDirectory: true
+                });
+            }
+            if (!result.canceled && result.assets && result.assets.length > 0) {
+                setUploading(true);
+                const formData = new FormData();
+                // Limit the number of files to upload
+                const assetsToUpload = result.assets.slice(0, maxFiles);
+                for (const asset of assetsToUpload) {
+                    const fileUri = react_native_1.Platform.OS === 'ios' ? asset.uri.replace('file://', '') : asset.uri;
+                    let fileName;
+                    let fileType;
+                    if ('mimeType' in asset) {
+                        fileName = asset.name;
+                        fileType = asset.mimeType || 'application/octet-stream';
+                    }
+                    else {
+                        const extension = fileUri.split('.').pop() || 'jpg';
+                        fileName = `image-${Date.now()}.${extension}`;
+                        fileType = `image/${extension}`;
+                    }
+                    try {
+                        const response = yield fetch(fileUri);
+                        const blob = yield response.blob();
+                        const file = new File([blob], fileName, { type: fileType });
+                        formData.append('files', file);
+                    }
+                    catch (error) {
+                        console.error('Error processing file:', error);
+                        sonner_1.toast.error(t("Error processing file"));
+                        setUploading(false);
+                        setError("Error processing file");
+                        return;
+                    }
+                }
+                const response = yield api_1.default.post('/files/upload', formData, {
+                    headers: {
+                        'Accept': 'application/json',
+                        'Content-Type': 'multipart/form-data',
+                        'Authorization': `Bearer ${accessToken}`
+                    },
+                    transformRequest: [(data) => data],
+                    onUploadProgress: (progressEvent) => {
+                        const percentCompleted = Math.round((progressEvent.loaded * 100) / (progressEvent.total || 1));
+                        console.log(`Upload progress: ${percentCompleted}%`);
+                    }
+                });
+                if ((_a = response.data) === null || _a === void 0 ? void 0 : _a.files) {
+                    sonner_1.toast.success(t("Files uploaded successfully"));
+                    // Invalidate cache for this user
+                    const cacheKey = getCacheKey(effectiveUserId);
+                    globalFileCache.delete(cacheKey);
+                    // Refresh files list
+                    yield fetchFiles(true);
+                    setError(null);
+                }
+            }
+        }
+        catch (error) {
+            handleFileError(error, t, 'uploadFiles');
+            setError(((_c = (_b = error === null || error === void 0 ? void 0 : error.response) === null || _b === void 0 ? void 0 : _b.data) === null || _c === void 0 ? void 0 : _c.message) || t("Error uploading files"));
+        }
+        finally {
+            setUploading(false);
+        }
+    }), [effectiveUserId, fileTypeFilter, maxFiles, t, fetchFiles, getCacheKey]);
+    const deleteFile = (0, react_1.useCallback)((fileId) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c;
+        if (!fileId) {
+            sonner_1.toast.error(t("Invalid file ID"));
+            return;
+        }
+        try {
+            setError(null);
+            const response = yield api_1.default.delete(`/files/${fileId}`);
+            if ((_a = response.data) === null || _a === void 0 ? void 0 : _a.success) {
+                sonner_1.toast.success(t("File deleted successfully"));
+                // Update local state
+                setFiles(prevFiles => prevFiles.filter(file => file._id !== fileId));
+                // Invalidate cache for this user
+                if (effectiveUserId) {
+                    const cacheKey = getCacheKey(effectiveUserId);
+                    globalFileCache.delete(cacheKey);
+                }
+            }
+        }
+        catch (error) {
+            handleFileError(error, t, 'deleteFile');
+            setError(((_c = (_b = error === null || error === void 0 ? void 0 : error.response) === null || _b === void 0 ? void 0 : _b.data) === null || _c === void 0 ? void 0 : _c.message) || t("Error deleting file"));
+        }
+    }), [effectiveUserId, t, getCacheKey]);
+    // Load files on mount and when dependencies change
+    (0, react_1.useEffect)(() => {
+        if (effectiveUserId) {
+            fetchFiles();
+        }
+    }, [effectiveUserId, fetchFiles]);
+    return {
+        files,
+        loading,
+        uploading,
+        error,
+        fetchFiles,
+        uploadFiles,
+        deleteFile
+    };
+}

package/dist/hooks/useProfile.d.ts

@@ -0,0 +1,13 @@
+import { OxyProfile } from '../types';
+export declare const useProfile: () => {
+    loading: boolean;
+    error: string | null;
+    getProfile: (id: string) => Promise<OxyProfile | null>;
+    updateProfile: (data: Partial<OxyProfile>) => Promise<OxyProfile | null>;
+    getFollowers: (userId: string) => Promise<OxyProfile[] | null>;
+    getFollowing: (userId: string) => Promise<OxyProfile[] | null>;
+    followUser: (userId: string) => Promise<boolean>;
+    unfollowUser: (userId: string) => Promise<boolean>;
+    getFollowingStatus: (userId: string) => Promise<boolean>;
+    getIdByUsername: (username: string) => Promise<string | null>;
+};