@oxyhq/services 0.0.85 → 0.1.0

package/dist/utils/errorHandler.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Error Handler Utility
+ *
+ * This utility provides centralized error handling and logging for the OxyHQ services module.
+ * It standardizes error formats, provides consistent logging, and helps with error recovery.
+ */
+export declare enum ErrorType {
+    NETWORK = "network",
+    AUTHENTICATION = "authentication",
+    AUTHORIZATION = "authorization",
+    VALIDATION = "validation",
+    SERVER = "server",
+    CLIENT = "client",
+    UNKNOWN = "unknown"
+}
+export interface StandardError {
+    message: string;
+    type: ErrorType;
+    statusCode?: number;
+    details?: Record<string, any>;
+    originalError?: any;
+}
+/**
+ * Normalize an error into a standard format
+ */
+export declare const normalizeError: (error: any, context?: string) => StandardError;
+/**
+ * Handle an error with optional toast notification
+ */
+export declare const handleError: (error: any, options?: {
+    context?: string;
+    showToast?: boolean;
+    fallbackMessage?: string;
+    onAuthError?: () => void;
+}) => StandardError;
+/**
+ * Create a safe error handler for async functions
+ */
+export declare const createSafeHandler: <T>(asyncFn: (...args: any[]) => Promise<T>, options?: {
+    context?: string;
+    showToast?: boolean;
+    fallbackMessage?: string;
+    onAuthError?: () => void;
+    onError?: (error: StandardError) => void;
+}) => (...args: any[]) => Promise<[T | null, StandardError | null]>;
+/**
+ * Check if an error is an authentication error
+ */
+export declare const isAuthError: (error: any) => boolean;
+declare const _default: {
+    normalizeError: (error: any, context?: string) => StandardError;
+    handleError: (error: any, options?: {
+        context?: string;
+        showToast?: boolean;
+        fallbackMessage?: string;
+        onAuthError?: () => void;
+    }) => StandardError;
+    createSafeHandler: <T>(asyncFn: (...args: any[]) => Promise<T>, options?: {
+        context?: string;
+        showToast?: boolean;
+        fallbackMessage?: string;
+        onAuthError?: () => void;
+        onError?: (error: StandardError) => void;
+    }) => (...args: any[]) => Promise<[T | null, StandardError | null]>;
+    isAuthError: (error: any) => boolean;
+    ErrorType: typeof ErrorType;
+};
+export default _default;

package/dist/utils/errorHandler.js

@@ -0,0 +1,166 @@
+"use strict";
+/**
+ * Error Handler Utility
+ *
+ * This utility provides centralized error handling and logging for the OxyHQ services module.
+ * It standardizes error formats, provides consistent logging, and helps with error recovery.
+ */
+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.isAuthError = exports.createSafeHandler = exports.handleError = exports.normalizeError = exports.ErrorType = void 0;
+const sonner_1 = require("sonner");
+const axios_1 = __importDefault(require("axios"));
+// Error types
+var ErrorType;
+(function (ErrorType) {
+    ErrorType["NETWORK"] = "network";
+    ErrorType["AUTHENTICATION"] = "authentication";
+    ErrorType["AUTHORIZATION"] = "authorization";
+    ErrorType["VALIDATION"] = "validation";
+    ErrorType["SERVER"] = "server";
+    ErrorType["CLIENT"] = "client";
+    ErrorType["UNKNOWN"] = "unknown";
+})(ErrorType || (exports.ErrorType = ErrorType = {}));
+/**
+ * Normalize an error into a standard format
+ */
+const normalizeError = (error, context) => {
+    var _a, _b;
+    let message = 'An unknown error occurred';
+    let type = ErrorType.UNKNOWN;
+    let statusCode = undefined;
+    let details = undefined;
+    if (axios_1.default.isAxiosError(error)) {
+        const axiosError = error;
+        statusCode = (_a = axiosError.response) === null || _a === void 0 ? void 0 : _a.status;
+        // Extract error details from response
+        if ((_b = axiosError.response) === null || _b === void 0 ? void 0 : _b.data) {
+            const data = axiosError.response.data;
+            message = data.message || axiosError.message || 'API request failed';
+            details = data.details || data;
+        }
+        else {
+            message = axiosError.message;
+        }
+        // Determine error type based on status code
+        if (!axiosError.response) {
+            type = ErrorType.NETWORK;
+        }
+        else if (statusCode === 401) {
+            type = ErrorType.AUTHENTICATION;
+        }
+        else if (statusCode === 403) {
+            type = ErrorType.AUTHORIZATION;
+        }
+        else if (statusCode === 422 || statusCode === 400) {
+            type = ErrorType.VALIDATION;
+        }
+        else if (statusCode && statusCode >= 500) {
+            type = ErrorType.SERVER;
+        }
+        else if (statusCode && statusCode >= 400) {
+            type = ErrorType.CLIENT;
+        }
+    }
+    else if (error instanceof Error) {
+        message = error.message;
+        // Try to determine error type from message
+        if (message.toLowerCase().includes('network') ||
+            message.toLowerCase().includes('connection')) {
+            type = ErrorType.NETWORK;
+        }
+        else if (message.toLowerCase().includes('authentication') ||
+            message.toLowerCase().includes('login') ||
+            message.toLowerCase().includes('token')) {
+            type = ErrorType.AUTHENTICATION;
+        }
+    }
+    else if (typeof error === 'string') {
+        message = error;
+    }
+    // Log the error with context
+    const logPrefix = context ? `[${context}]` : '';
+    console.error(`${logPrefix} Error:`, {
+        message,
+        type,
+        statusCode,
+        details,
+        originalError: error
+    });
+    return {
+        message,
+        type,
+        statusCode,
+        details,
+        originalError: error
+    };
+};
+exports.normalizeError = normalizeError;
+/**
+ * Handle an error with optional toast notification
+ */
+const handleError = (error, options = {}) => {
+    const { context, showToast = true, fallbackMessage, onAuthError } = options;
+    const standardError = (0, exports.normalizeError)(error, context);
+    // Show toast notification if requested
+    if (showToast) {
+        sonner_1.toast.error(standardError.message || fallbackMessage || 'An error occurred');
+    }
+    // Call auth error handler if it's an authentication error
+    if (standardError.type === ErrorType.AUTHENTICATION && onAuthError) {
+        onAuthError();
+    }
+    return standardError;
+};
+exports.handleError = handleError;
+/**
+ * Create a safe error handler for async functions
+ */
+const createSafeHandler = (asyncFn, options = {}) => {
+    return (...args) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            const result = yield asyncFn(...args);
+            return [result, null];
+        }
+        catch (error) {
+            const standardError = (0, exports.handleError)(error, options);
+            if (options.onError) {
+                options.onError(standardError);
+            }
+            return [null, standardError];
+        }
+    });
+};
+exports.createSafeHandler = createSafeHandler;
+/**
+ * Check if an error is an authentication error
+ */
+const isAuthError = (error) => {
+    var _a;
+    if (axios_1.default.isAxiosError(error)) {
+        return ((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 401;
+    }
+    if (error && typeof error === 'object' && 'type' in error) {
+        return error.type === ErrorType.AUTHENTICATION;
+    }
+    return false;
+};
+exports.isAuthError = isAuthError;
+exports.default = {
+    normalizeError: exports.normalizeError,
+    handleError: exports.handleError,
+    createSafeHandler: exports.createSafeHandler,
+    isAuthError: exports.isAuthError,
+    ErrorType
+};

package/dist/utils/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * OxyHQ Services Utilities
+ *
+ * Helper functions and utilities for the OxyHQ services module.
+ */
+export * from './api';
+export * from './storage';
+export * from './socket';
+export * from './socketConfig';
+export { normalizeError, handleError, createSafeHandler, ErrorType } from './errorHandler';
+import errorHandler from './errorHandler';
+export { errorHandler };

package/dist/utils/index.js

@@ -0,0 +1,41 @@
+"use strict";
+/**
+ * OxyHQ Services Utilities
+ *
+ * Helper functions and utilities for the OxyHQ services module.
+ */
+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 __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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorHandler = exports.ErrorType = exports.createSafeHandler = exports.handleError = exports.normalizeError = void 0;
+// Export API utilities
+__exportStar(require("./api"), exports);
+// Export storage utilities
+__exportStar(require("./storage"), exports);
+// Export socket utilities
+__exportStar(require("./socket"), exports);
+__exportStar(require("./socketConfig"), exports);
+// Export error handling utilities
+var errorHandler_1 = require("./errorHandler");
+Object.defineProperty(exports, "normalizeError", { enumerable: true, get: function () { return errorHandler_1.normalizeError; } });
+Object.defineProperty(exports, "handleError", { enumerable: true, get: function () { return errorHandler_1.handleError; } });
+Object.defineProperty(exports, "createSafeHandler", { enumerable: true, get: function () { return errorHandler_1.createSafeHandler; } });
+Object.defineProperty(exports, "ErrorType", { enumerable: true, get: function () { return errorHandler_1.ErrorType; } });
+// Export default error handler
+const errorHandler_2 = __importDefault(require("./errorHandler"));
+exports.errorHandler = errorHandler_2.default;

package/dist/utils/logger.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Logger Utility
+ *
+ * A centralized logging system for the OxyHQ services module.
+ * Provides consistent logging with different log levels, context, and optional remote logging.
+ */
+export declare enum LogLevel {
+    DEBUG = "debug",
+    INFO = "info",
+    WARN = "warn",
+    ERROR = "error",
+    FATAL = "fatal"
+}
+declare class Logger {
+    private currentLogLevel;
+    private enableRemoteLogging;
+    private includeUserContext;
+    private redactSensitiveData;
+    constructor();
+    /**
+     * Log a debug message
+     */
+    debug(message: string, context?: string, data?: any): void;
+    /**
+     * Log an info message
+     */
+    info(message: string, context?: string, data?: any): void;
+    /**
+     * Log a warning message
+     */
+    warn(message: string, context?: string, data?: any): void;
+    /**
+     * Log an error message
+     */
+    error(message: string, context?: string, data?: any): void;
+    /**
+     * Log a fatal error message
+     */
+    fatal(message: string, context?: string, data?: any): void;
+    /**
+     * Log a message with the specified level
+     */
+    private log;
+    /**
+     * Check if the given log level should be processed
+     */
+    private shouldLog;
+    /**
+     * Output log entry to console
+     */
+    private consoleOutput;
+    /**
+     * Add user context to log entry
+     */
+    private addUserContext;
+    /**
+     * Queue log entry for remote logging
+     */
+    private queueForRemoteLogging;
+    /**
+     * Start processing the remote logging queue
+     */
+    private startQueueProcessing;
+    /**
+     * Process the remote logging queue
+     */
+    private processLogQueue;
+    /**
+     * Send logs to remote server
+     */
+    private sendLogsToRemoteServer;
+    /**
+     * Redact sensitive fields from log data
+     */
+    private redactSensitiveFields;
+    /**
+     * Set the current log level
+     */
+    setLogLevel(level: LogLevel): void;
+    /**
+     * Enable or disable remote logging
+     */
+    setRemoteLogging(enabled: boolean): void;
+    /**
+     * Log performance metrics
+     */
+    logPerformance(operation: string, startTime: number, context?: string): void;
+    /**
+     * Create a scoped logger with a fixed context
+     */
+    createScopedLogger(context: string): {
+        debug: (message: string, data?: any) => void;
+        info: (message: string, data?: any) => void;
+        warn: (message: string, data?: any) => void;
+        error: (message: string, data?: any) => void;
+        fatal: (message: string, data?: any) => void;
+    };
+}
+export declare const logger: Logger;
+export {};

package/dist/utils/logger.js

@@ -0,0 +1,298 @@
+"use strict";
+/**
+ * Logger Utility
+ *
+ * A centralized logging system for the OxyHQ services module.
+ * Provides consistent logging with different log levels, context, and optional remote logging.
+ */
+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.logger = exports.LogLevel = void 0;
+const config_1 = require("../config");
+const storage_1 = require("./storage");
+const constants_1 = require("../constants");
+// Log levels
+var LogLevel;
+(function (LogLevel) {
+    LogLevel["DEBUG"] = "debug";
+    LogLevel["INFO"] = "info";
+    LogLevel["WARN"] = "warn";
+    LogLevel["ERROR"] = "error";
+    LogLevel["FATAL"] = "fatal";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+// Log level priorities (higher number = higher priority)
+const LOG_LEVEL_PRIORITY = {
+    [LogLevel.DEBUG]: 0,
+    [LogLevel.INFO]: 1,
+    [LogLevel.WARN]: 2,
+    [LogLevel.ERROR]: 3,
+    [LogLevel.FATAL]: 4
+};
+// Remote logging queue
+const logQueue = [];
+let isProcessingQueue = false;
+const MAX_QUEUE_SIZE = 100;
+const QUEUE_PROCESSING_INTERVAL = 10000; // 10 seconds
+class Logger {
+    constructor() {
+        this.currentLogLevel = config_1.OXY_LOGGING_CONFIG.LEVEL || LogLevel.ERROR;
+        this.enableRemoteLogging = config_1.OXY_LOGGING_CONFIG.ENABLE_REMOTE_LOGGING;
+        this.includeUserContext = config_1.OXY_LOGGING_CONFIG.INCLUDE_USER_CONTEXT;
+        this.redactSensitiveData = config_1.OXY_LOGGING_CONFIG.REDACT_SENSITIVE_DATA;
+        // Start queue processing if remote logging is enabled
+        if (this.enableRemoteLogging) {
+            this.startQueueProcessing();
+        }
+    }
+    /**
+     * Log a debug message
+     */
+    debug(message, context, data) {
+        this.log(LogLevel.DEBUG, message, context, data);
+    }
+    /**
+     * Log an info message
+     */
+    info(message, context, data) {
+        this.log(LogLevel.INFO, message, context, data);
+    }
+    /**
+     * Log a warning message
+     */
+    warn(message, context, data) {
+        this.log(LogLevel.WARN, message, context, data);
+    }
+    /**
+     * Log an error message
+     */
+    error(message, context, data) {
+        this.log(LogLevel.ERROR, message, context, data);
+    }
+    /**
+     * Log a fatal error message
+     */
+    fatal(message, context, data) {
+        this.log(LogLevel.FATAL, message, context, data);
+    }
+    /**
+     * Log a message with the specified level
+     */
+    log(level, message, context, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Check if this log level should be processed
+            if (!this.shouldLog(level)) {
+                return;
+            }
+            // Create log entry
+            const logEntry = {
+                timestamp: new Date().toISOString(),
+                level,
+                message,
+                context,
+                data: this.redactSensitiveData ? this.redactSensitiveFields(data) : data
+            };
+            // Add user context if enabled
+            if (this.includeUserContext) {
+                yield this.addUserContext(logEntry);
+            }
+            // Console output
+            this.consoleOutput(logEntry);
+            // Queue for remote logging if enabled
+            if (this.enableRemoteLogging && level !== LogLevel.DEBUG) {
+                this.queueForRemoteLogging(logEntry);
+            }
+        });
+    }
+    /**
+     * Check if the given log level should be processed
+     */
+    shouldLog(level) {
+        return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[this.currentLogLevel];
+    }
+    /**
+     * Output log entry to console
+     */
+    consoleOutput(entry) {
+        const { level, message, context, data } = entry;
+        const timestamp = new Date(entry.timestamp).toLocaleTimeString();
+        const contextStr = context ? `[${context}]` : '';
+        const logMessage = `${timestamp} ${level.toUpperCase()} ${contextStr} ${message}`;
+        switch (level) {
+            case LogLevel.DEBUG:
+                console.debug(logMessage, data || '');
+                break;
+            case LogLevel.INFO:
+                console.info(logMessage, data || '');
+                break;
+            case LogLevel.WARN:
+                console.warn(logMessage, data || '');
+                break;
+            case LogLevel.ERROR:
+            case LogLevel.FATAL:
+                console.error(logMessage, data || '');
+                break;
+        }
+    }
+    /**
+     * Add user context to log entry
+     */
+    addUserContext(entry) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const userId = yield (0, storage_1.getData)(constants_1.STORAGE_KEYS.USER_ID);
+                if (userId) {
+                    entry.userId = userId;
+                }
+                // Add session ID if available
+                const sessionId = yield (0, storage_1.getData)('sessionId');
+                if (sessionId) {
+                    entry.sessionId = sessionId;
+                }
+            }
+            catch (error) {
+                // Silently fail if we can't get user context
+            }
+        });
+    }
+    /**
+     * Queue log entry for remote logging
+     */
+    queueForRemoteLogging(entry) {
+        // Add to queue, maintaining max size
+        logQueue.push(entry);
+        if (logQueue.length > MAX_QUEUE_SIZE) {
+            logQueue.shift();
+        }
+    }
+    /**
+     * Start processing the remote logging queue
+     */
+    startQueueProcessing() {
+        setInterval(() => {
+            this.processLogQueue();
+        }, QUEUE_PROCESSING_INTERVAL);
+    }
+    /**
+     * Process the remote logging queue
+     */
+    processLogQueue() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (isProcessingQueue || logQueue.length === 0) {
+                return;
+            }
+            isProcessingQueue = true;
+            try {
+                // Take a snapshot of the current queue
+                const logsToSend = [...logQueue];
+                logQueue.length = 0;
+                // Send logs to remote server
+                yield this.sendLogsToRemoteServer(logsToSend);
+            }
+            catch (error) {
+                // If sending fails, add logs back to the queue
+                console.error('Failed to send logs to remote server:', error);
+                // Only add back the most recent logs to avoid queue growing too large
+                const logsToRequeue = logQueue.length + MAX_QUEUE_SIZE > 2 * MAX_QUEUE_SIZE
+                    ? logQueue.slice(-MAX_QUEUE_SIZE)
+                    : logQueue;
+                logQueue.push(...logsToRequeue);
+            }
+            finally {
+                isProcessingQueue = false;
+            }
+        });
+    }
+    /**
+     * Send logs to remote server
+     */
+    sendLogsToRemoteServer(logs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Implementation would depend on your remote logging service
+            // This is a placeholder for the actual implementation
+            if (config_1.OXY_CONFIG.ENV.IS_DEV) {
+                console.log('Would send logs to remote server:', logs);
+                return;
+            }
+            // In production, you would send logs to your logging service
+            // Example:
+            // await fetch('https://logging.oxy.so/api/logs', {
+            //   method: 'POST',
+            //   headers: { 'Content-Type': 'application/json' },
+            //   body: JSON.stringify({ logs })
+            // });
+        });
+    }
+    /**
+     * Redact sensitive fields from log data
+     */
+    redactSensitiveFields(data) {
+        if (!data || typeof data !== 'object') {
+            return data;
+        }
+        const sensitiveFields = [
+            'password', 'token', 'accessToken', 'refreshToken', 'secret',
+            'apiKey', 'authorization', 'credential', 'pin', 'ssn', 'creditCard'
+        ];
+        const redacted = Object.assign({}, data);
+        for (const key in redacted) {
+            if (Object.prototype.hasOwnProperty.call(redacted, key)) {
+                // Check if this is a sensitive field
+                if (sensitiveFields.some(field => key.toLowerCase().includes(field.toLowerCase()))) {
+                    redacted[key] = '[REDACTED]';
+                }
+                else if (typeof redacted[key] === 'object' && redacted[key] !== null) {
+                    // Recursively redact nested objects
+                    redacted[key] = this.redactSensitiveFields(redacted[key]);
+                }
+            }
+        }
+        return redacted;
+    }
+    /**
+     * Set the current log level
+     */
+    setLogLevel(level) {
+        this.currentLogLevel = level;
+    }
+    /**
+     * Enable or disable remote logging
+     */
+    setRemoteLogging(enabled) {
+        this.enableRemoteLogging = enabled;
+        if (enabled && !isProcessingQueue) {
+            this.startQueueProcessing();
+        }
+    }
+    /**
+     * Log performance metrics
+     */
+    logPerformance(operation, startTime, context) {
+        if (!config_1.OXY_LOGGING_CONFIG.LOG_PERFORMANCE_METRICS) {
+            return;
+        }
+        const duration = Date.now() - startTime;
+        this.info(`Performance: ${operation} took ${duration}ms`, context || 'Performance', { duration });
+    }
+    /**
+     * Create a scoped logger with a fixed context
+     */
+    createScopedLogger(context) {
+        return {
+            debug: (message, data) => this.debug(message, context, data),
+            info: (message, data) => this.info(message, context, data),
+            warn: (message, data) => this.warn(message, context, data),
+            error: (message, data) => this.error(message, context, data),
+            fatal: (message, data) => this.fatal(message, context, data)
+        };
+    }
+}
+// Export singleton instance
+exports.logger = new Logger();

package/dist/utils/socket.d.ts

@@ -0,0 +1,6 @@
+import { Socket } from 'socket.io-client';
+export declare const getSocket: (namespace?: string) => Promise<Socket<import("@socket.io/component-emitter").DefaultEventsMap, import("@socket.io/component-emitter").DefaultEventsMap> | null>;
+export declare const disconnectSocket: () => void;
+export declare const joinRoom: (socket: Socket, room: string) => boolean;
+export declare const leaveRoom: (socket: Socket, room: string) => boolean;
+export declare const initializeChatSocket: () => Promise<Socket<import("@socket.io/component-emitter").DefaultEventsMap, import("@socket.io/component-emitter").DefaultEventsMap> | null>;