@oxyhq/services 0.1.0 → 0.1.1

package/dist/frontend/hooks/useWallet.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useWallet = void 0;
+const react_1 = require("react");
+const api_client_1 = require("../../shared/api-client");
+const OxyContext_1 = require("../context/OxyContext");
+const useWallet = (options) => {
+    const context = (0, OxyContext_1.useOxyContext)();
+    const apiUrl = (options === null || options === void 0 ? void 0 : options.apiUrl) || context.apiUrl;
+    const getToken = (options === null || options === void 0 ? void 0 : options.getToken) || context.getToken;
+    if (!apiUrl) {
+        throw new Error('API URL is required. Provide it either through options or OxyProvider.');
+    }
+    const [apiClient] = (0, react_1.useState)(() => new api_client_1.ApiClient({
+        apiUrl,
+    }));
+    // Get wallet information for the current user
+    const getWallet = (0, react_1.useCallback)(async (userId) => {
+        try {
+            if (!getToken) {
+                return {
+                    success: false,
+                    error: 'Authentication token is required'
+                };
+            }
+            return await apiClient.request({
+                method: 'GET',
+                url: `/wallet/${userId}`,
+                headers: {
+                    Authorization: `Bearer ${getToken() || ''}`
+                }
+            });
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message || 'Failed to get wallet information'
+            };
+        }
+    }, [apiClient, getToken]);
+    // Get transaction history
+    const getTransactionHistory = (0, react_1.useCallback)(async (userId, limit = 10, offset = 0) => {
+        try {
+            if (!getToken) {
+                return {
+                    success: false,
+                    error: 'Authentication token is required'
+                };
+            }
+            return await apiClient.request({
+                method: 'GET',
+                url: `/wallet/transactions/${userId}`,
+                params: { limit, offset },
+                headers: {
+                    Authorization: `Bearer ${getToken() || ''}`
+                }
+            });
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message || 'Failed to get transaction history'
+            };
+        }
+    }, [apiClient, getToken]);
+    // Transfer funds to another user
+    const transferFunds = (0, react_1.useCallback)(async (transferRequest) => {
+        try {
+            if (!getToken) {
+                return {
+                    success: false,
+                    error: 'Authentication token is required'
+                };
+            }
+            return await apiClient.request({
+                method: 'POST',
+                url: '/wallet/transfer',
+                data: transferRequest,
+                headers: {
+                    Authorization: `Bearer ${getToken() || ''}`
+                }
+            });
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message || 'Failed to transfer funds'
+            };
+        }
+    }, [apiClient, getToken]);
+    // Process a purchase
+    const processPurchase = (0, react_1.useCallback)(async (purchaseRequest) => {
+        try {
+            if (!getToken) {
+                return {
+                    success: false,
+                    error: 'Authentication token is required'
+                };
+            }
+            return await apiClient.request({
+                method: 'POST',
+                url: '/wallet/purchase',
+                data: purchaseRequest,
+                headers: {
+                    Authorization: `Bearer ${getToken() || ''}`
+                }
+            });
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message || 'Failed to process purchase'
+            };
+        }
+    }, [apiClient, getToken]);
+    // Request a withdrawal
+    const requestWithdrawal = (0, react_1.useCallback)(async (withdrawalRequest) => {
+        try {
+            if (!getToken) {
+                return {
+                    success: false,
+                    error: 'Authentication token is required'
+                };
+            }
+            return await apiClient.request({
+                method: 'POST',
+                url: '/wallet/withdraw',
+                data: withdrawalRequest,
+                headers: {
+                    Authorization: `Bearer ${getToken() || ''}`
+                }
+            });
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message || 'Failed to request withdrawal'
+            };
+        }
+    }, [apiClient, getToken]);
+    // Get a specific transaction
+    const getTransaction = (0, react_1.useCallback)(async (transactionId) => {
+        try {
+            if (!getToken) {
+                return {
+                    success: false,
+                    error: 'Authentication token is required'
+                };
+            }
+            return await apiClient.request({
+                method: 'GET',
+                url: `/wallet/transaction/${transactionId}`,
+                headers: {
+                    Authorization: `Bearer ${getToken() || ''}`
+                }
+            });
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message || 'Failed to get transaction'
+            };
+        }
+    }, [apiClient, getToken]);
+    return {
+        getWallet,
+        getTransactionHistory,
+        transferFunds,
+        processPurchase,
+        requestWithdrawal,
+        getTransaction
+    };
+};
+exports.useWallet = useWallet;

package/dist/frontend/index.d.ts

@@ -0,0 +1,6 @@
+import { useAuth } from './hooks/useAuth';
+import { useUser } from './hooks/useUser';
+import { useKarma } from './hooks/useKarma';
+import { useWallet } from './hooks/useWallet';
+import { OxyProvider, useOxyContext } from './context/OxyContext';
+export { useAuth, useUser, useKarma, useWallet, OxyProvider, useOxyContext };

package/dist/frontend/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useOxyContext = exports.OxyProvider = exports.useWallet = exports.useKarma = exports.useUser = exports.useAuth = void 0;
+const useAuth_1 = require("./hooks/useAuth");
+Object.defineProperty(exports, "useAuth", { enumerable: true, get: function () { return useAuth_1.useAuth; } });
+const useUser_1 = require("./hooks/useUser");
+Object.defineProperty(exports, "useUser", { enumerable: true, get: function () { return useUser_1.useUser; } });
+const useKarma_1 = require("./hooks/useKarma");
+Object.defineProperty(exports, "useKarma", { enumerable: true, get: function () { return useKarma_1.useKarma; } });
+const useWallet_1 = require("./hooks/useWallet");
+Object.defineProperty(exports, "useWallet", { enumerable: true, get: function () { return useWallet_1.useWallet; } });
+const OxyContext_1 = require("./context/OxyContext");
+Object.defineProperty(exports, "OxyProvider", { enumerable: true, get: function () { return OxyContext_1.OxyProvider; } });
+Object.defineProperty(exports, "useOxyContext", { enumerable: true, get: function () { return OxyContext_1.useOxyContext; } });

package/dist/index.d.ts

@@ -1,28 +1,3 @@
-/**
- * OxyHQ Services Module
- *
- * This module provides authentication, profile management, file handling, and other
- * services for interacting with the OxyHQ API.
- *
- * @module oxyhqservices
- */
-export * from './config';
-export * from './constants';
-export * from './services';
-export * from './hooks';
-export * from './types';
-export * from './utils';
-export * from './reducers';
-export * from './styles/shared';
-export * from './utils';
-/**
- * Initialize the OxyHQ services module
- * @param options Configuration options
- */
-export declare function initialize(options?: {
-    apiUrl?: string;
-    cloudUrl?: string;
-    enableLogging?: boolean;
-    logLevel?: string;
-    enableOfflineMode?: boolean;
-}): void;
+export * from './shared/types';
+export { OxyAuthBackend, OxyUsersBackend, OxyKarmaBackend, OxyWalletBackend } from './backend';
+export { useAuth, useUser, useKarma, useWallet, OxyProvider, useOxyContext } from './frontend';

package/dist/index.js

@@ -1,12 +1,4 @@
 "use strict";
-/**
- * OxyHQ Services Module
- *
- * This module provides authentication, profile management, file handling, and other
- * services for interacting with the OxyHQ API.
- *
- * @module oxyhqservices
- */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -22,61 +14,20 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.initialize = initialize;
-// Configuration
-__exportStar(require("./config"), exports);
-// Constants
-__exportStar(require("./constants"), exports);
-// Core Services
-__exportStar(require("./services"), exports);
-// Hooks
-__exportStar(require("./hooks"), exports);
-// Types
-__exportStar(require("./types"), exports);
-// Utils
-__exportStar(require("./utils"), exports);
-// Redux Reducers
-__exportStar(require("./reducers"), exports);
-// Shared styles
-__exportStar(require("./styles/shared"), exports);
-// Utilities
-__exportStar(require("./utils"), exports);
-// Import package version
-const package_json_1 = require("./package.json");
-/**
- * Initialize the OxyHQ services module
- * @param options Configuration options
- */
-function initialize(options) {
-    // Import configuration and services
-    const { OXY_CONFIG } = require('./config');
-    const { logger } = require('./utils/logger');
-    // Override configuration with provided options
-    if (options) {
-        if (options.apiUrl) {
-            OXY_CONFIG.API.BASE_URL = options.apiUrl;
-        }
-        if (options.cloudUrl) {
-            OXY_CONFIG.API.CLOUD_URL = options.cloudUrl;
-        }
-        if (options.enableLogging !== undefined) {
-            OXY_CONFIG.LOGGING.ENABLE_REMOTE_LOGGING = options.enableLogging;
-        }
-        if (options.logLevel) {
-            OXY_CONFIG.LOGGING.LEVEL = options.logLevel;
-            logger.setLogLevel(options.logLevel);
-        }
-        if (options.enableOfflineMode !== undefined) {
-            OXY_CONFIG.FEATURES.ENABLE_OFFLINE_MODE = options.enableOfflineMode;
-        }
-    }
-    // Log initialization
-    logger.info('OxyHQ Services initialized', 'Initialization', {
-        version: package_json_1.version,
-        config: {
-            apiUrl: OXY_CONFIG.API.BASE_URL,
-            cloudUrl: OXY_CONFIG.API.CLOUD_URL,
-            environment: OXY_CONFIG.ENV.IS_PROD ? 'production' : 'development'
-        }
-    });
-}
+exports.useOxyContext = exports.OxyProvider = exports.useWallet = exports.useKarma = exports.useUser = exports.useAuth = exports.OxyWalletBackend = exports.OxyKarmaBackend = exports.OxyUsersBackend = exports.OxyAuthBackend = void 0;
+// Export types
+__exportStar(require("./shared/types"), exports);
+// Export backend services
+var backend_1 = require("./backend");
+Object.defineProperty(exports, "OxyAuthBackend", { enumerable: true, get: function () { return backend_1.OxyAuthBackend; } });
+Object.defineProperty(exports, "OxyUsersBackend", { enumerable: true, get: function () { return backend_1.OxyUsersBackend; } });
+Object.defineProperty(exports, "OxyKarmaBackend", { enumerable: true, get: function () { return backend_1.OxyKarmaBackend; } });
+Object.defineProperty(exports, "OxyWalletBackend", { enumerable: true, get: function () { return backend_1.OxyWalletBackend; } });
+// Export frontend hooks and context
+var frontend_1 = require("./frontend");
+Object.defineProperty(exports, "useAuth", { enumerable: true, get: function () { return frontend_1.useAuth; } });
+Object.defineProperty(exports, "useUser", { enumerable: true, get: function () { return frontend_1.useUser; } });
+Object.defineProperty(exports, "useKarma", { enumerable: true, get: function () { return frontend_1.useKarma; } });
+Object.defineProperty(exports, "useWallet", { enumerable: true, get: function () { return frontend_1.useWallet; } });
+Object.defineProperty(exports, "OxyProvider", { enumerable: true, get: function () { return frontend_1.OxyProvider; } });
+Object.defineProperty(exports, "useOxyContext", { enumerable: true, get: function () { return frontend_1.useOxyContext; } });

package/dist/shared/api-client.d.ts

@@ -0,0 +1,15 @@
+import { AxiosRequestConfig } from 'axios';
+import { ApiResponse, AuthTokens, OxyAuthConfig } from './types';
+export declare class ApiClient {
+    private axiosInstance;
+    private config;
+    private tokenRefreshTimeout?;
+    constructor(config: OxyAuthConfig);
+    request<T>(config: AxiosRequestConfig): Promise<ApiResponse<T>>;
+    private getAccessToken;
+    private getRefreshToken;
+    storeTokens(tokens: AuthTokens): void;
+    clearTokens(): void;
+    private refreshToken;
+    private setupTokenRefresh;
+}

package/dist/shared/api-client.js

@@ -0,0 +1,197 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+class ApiClient {
+    constructor(config) {
+        this.config = config;
+        this.axiosInstance = axios_1.default.create({
+            baseURL: config.apiUrl,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+        // Add request interceptor to attach token
+        this.axiosInstance.interceptors.request.use((config) => {
+            const token = this.getAccessToken();
+            if (token) {
+                config.headers['Authorization'] = `Bearer ${token}`;
+            }
+            return config;
+        }, (error) => Promise.reject(error));
+        // Add response interceptor to handle token refresh
+        this.axiosInstance.interceptors.response.use((response) => response, async (error) => {
+            var _a;
+            const originalRequest = error.config;
+            // If error is 401 and we haven't tried to refresh the token yet
+            if (((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 401 && !originalRequest._retry) {
+                originalRequest._retry = true;
+                try {
+                    // Try to refresh the token
+                    const newTokens = await this.refreshToken();
+                    if (newTokens) {
+                        // Update the token in storage
+                        this.storeTokens(newTokens);
+                        // Update the Authorization header
+                        originalRequest.headers['Authorization'] = `Bearer ${newTokens.accessToken}`;
+                        // Retry the original request
+                        return this.axiosInstance(originalRequest);
+                    }
+                }
+                catch (refreshError) {
+                    // If refresh fails, clear tokens and reject
+                    this.clearTokens();
+                    return Promise.reject(refreshError);
+                }
+            }
+            return Promise.reject(error);
+        });
+        // Set up token refresh if configured
+        if (config.tokenRefreshInterval) {
+            this.setupTokenRefresh(config.tokenRefreshInterval);
+        }
+    }
+    // Generic request method with type support
+    async request(config) {
+        var _a;
+        try {
+            const response = await this.axiosInstance.request(config);
+            return response.data;
+        }
+        catch (error) {
+            if ((_a = error.response) === null || _a === void 0 ? void 0 : _a.data) {
+                return error.response.data;
+            }
+            return {
+                success: false,
+                error: error.message || 'Network error',
+            };
+        }
+    }
+    // Get the stored access token based on storage config
+    getAccessToken() {
+        if (typeof window === 'undefined' || this.config.storage === 'none') {
+            return null;
+        }
+        switch (this.config.storage) {
+            case 'local':
+                return localStorage.getItem('oxy_access_token');
+            case 'session':
+                return sessionStorage.getItem('oxy_access_token');
+            case 'cookie':
+                // Simple cookie parser (would implement more robust version in production)
+                const match = document.cookie.match(/(^|;)\s*oxy_access_token=([^;]+)/);
+                return match ? match[2] : null;
+            default:
+                return localStorage.getItem('oxy_access_token');
+        }
+    }
+    // Get the stored refresh token based on storage config
+    getRefreshToken() {
+        if (typeof window === 'undefined' || this.config.storage === 'none') {
+            return null;
+        }
+        switch (this.config.storage) {
+            case 'local':
+                return localStorage.getItem('oxy_refresh_token');
+            case 'session':
+                return sessionStorage.getItem('oxy_refresh_token');
+            case 'cookie':
+                const match = document.cookie.match(/(^|;)\s*oxy_refresh_token=([^;]+)/);
+                return match ? match[2] : null;
+            default:
+                return localStorage.getItem('oxy_refresh_token');
+        }
+    }
+    // Store tokens based on storage config
+    storeTokens(tokens) {
+        if (typeof window === 'undefined' || this.config.storage === 'none') {
+            return;
+        }
+        switch (this.config.storage) {
+            case 'local':
+                localStorage.setItem('oxy_access_token', tokens.accessToken);
+                localStorage.setItem('oxy_refresh_token', tokens.refreshToken);
+                break;
+            case 'session':
+                sessionStorage.setItem('oxy_access_token', tokens.accessToken);
+                sessionStorage.setItem('oxy_refresh_token', tokens.refreshToken);
+                break;
+            case 'cookie':
+                // Set cookies with HttpOnly and secure flags in production
+                document.cookie = `oxy_access_token=${tokens.accessToken}; path=/;`;
+                document.cookie = `oxy_refresh_token=${tokens.refreshToken}; path=/;`;
+                break;
+            default:
+                localStorage.setItem('oxy_access_token', tokens.accessToken);
+                localStorage.setItem('oxy_refresh_token', tokens.refreshToken);
+        }
+    }
+    // Clear stored tokens based on storage config
+    clearTokens() {
+        if (typeof window === 'undefined' || this.config.storage === 'none') {
+            return;
+        }
+        switch (this.config.storage) {
+            case 'local':
+                localStorage.removeItem('oxy_access_token');
+                localStorage.removeItem('oxy_refresh_token');
+                break;
+            case 'session':
+                sessionStorage.removeItem('oxy_access_token');
+                sessionStorage.removeItem('oxy_refresh_token');
+                break;
+            case 'cookie':
+                document.cookie = 'oxy_access_token=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/;';
+                document.cookie = 'oxy_refresh_token=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/;';
+                break;
+            default:
+                localStorage.removeItem('oxy_access_token');
+                localStorage.removeItem('oxy_refresh_token');
+        }
+        // Clear the token refresh timeout
+        if (this.tokenRefreshTimeout) {
+            clearTimeout(this.tokenRefreshTimeout);
+            this.tokenRefreshTimeout = undefined;
+        }
+    }
+    // Refresh the access token using the refresh token
+    async refreshToken() {
+        const refreshToken = this.getRefreshToken();
+        if (!refreshToken) {
+            return null;
+        }
+        try {
+            const response = await axios_1.default.post(`${this.config.apiUrl}/auth/refresh-token`, { refreshToken });
+            if (response.data.success && response.data.data) {
+                return response.data.data;
+            }
+            return null;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    // Set up automatic token refresh at the specified interval
+    setupTokenRefresh(interval) {
+        if (typeof window === 'undefined') {
+            return;
+        }
+        this.tokenRefreshTimeout = setTimeout(async () => {
+            try {
+                const newTokens = await this.refreshToken();
+                if (newTokens) {
+                    this.storeTokens(newTokens);
+                }
+            }
+            finally {
+                // Set up the next refresh regardless of success/failure
+                this.setupTokenRefresh(interval);
+            }
+        }, interval);
+    }
+}
+exports.ApiClient = ApiClient;

package/dist/shared/types.d.ts

@@ -0,0 +1,135 @@
+export interface UserCredentials {
+    email?: string;
+    username?: string;
+    password: string;
+}
+export interface UserRegistration {
+    username: string;
+    email: string;
+    password: string;
+}
+export interface AuthTokens {
+    accessToken: string;
+    refreshToken: string;
+}
+export interface UserProfile {
+    id: string;
+    username: string;
+    email: string;
+    name?: {
+        first?: string;
+        last?: string;
+    };
+    avatar?: string;
+    description?: string;
+    coverPhoto?: string;
+    location?: string;
+    website?: string;
+    stats?: {
+        followers: number;
+        following: number;
+        posts: number;
+        karma: number;
+    };
+    createdAt: string;
+}
+export interface PrivacySettings {
+    isPrivateAccount: boolean;
+    hideOnlineStatus: boolean;
+    hideLastSeen: boolean;
+    profileVisibility: boolean;
+    postVisibility: boolean;
+    twoFactorEnabled: boolean;
+    loginAlerts: boolean;
+    blockScreenshots: boolean;
+    secureLogin: boolean;
+    biometricLogin: boolean;
+    showActivity: boolean;
+    allowTagging: boolean;
+    allowMentions: boolean;
+    hideReadReceipts: boolean;
+    allowComments: boolean;
+    allowDirectMessages: boolean;
+    dataSharing: boolean;
+    locationSharing: boolean;
+    analyticsSharing: boolean;
+    sensitiveContent: boolean;
+    autoFilter: boolean;
+    muteKeywords: boolean;
+}
+export interface KarmaAction {
+    userId: string;
+    action: string;
+    points?: number;
+    description?: string;
+    targetContentId?: string;
+}
+export interface KarmaHistoryItem {
+    action: string;
+    points: number;
+    timestamp: string;
+    description?: string;
+    sourceUserId?: string;
+    targetContentId?: string;
+}
+export interface KarmaHistory {
+    userId: string;
+    actions: KarmaHistoryItem[];
+    totalKarma: number;
+}
+export interface KarmaRule {
+    action: string;
+    points: number;
+    description: string;
+    category: string;
+    cooldownInMinutes: number;
+}
+export interface WalletInfo {
+    userId: string;
+    balance: number;
+    address?: string;
+}
+export type TransactionType = 'deposit' | 'withdrawal' | 'transfer' | 'purchase';
+export type TransactionStatus = 'pending' | 'completed' | 'failed' | 'cancelled';
+export interface TransactionInfo {
+    id: string;
+    userId: string;
+    type: TransactionType;
+    amount: number;
+    status: TransactionStatus;
+    description?: string;
+    recipientId?: string;
+    itemId?: string;
+    itemType?: string;
+    timestamp: string;
+    completedAt?: string;
+}
+export interface TransferRequest {
+    fromUserId: string;
+    toUserId: string;
+    amount: number;
+    description?: string;
+}
+export interface PurchaseRequest {
+    userId: string;
+    amount: number;
+    itemId: string;
+    itemType: string;
+    description?: string;
+}
+export interface WithdrawalRequest {
+    userId: string;
+    amount: number;
+    address: string;
+}
+export interface ApiResponse<T> {
+    success: boolean;
+    data?: T;
+    error?: string;
+    message?: string;
+}
+export interface OxyAuthConfig {
+    apiUrl: string;
+    storage?: 'local' | 'session' | 'cookie' | 'none';
+    tokenRefreshInterval?: number;
+}