@oxyhq/services 5.16.43 → 5.17.0

package/src/adapters/expo/storage.ts

@@ -1,228 +0,0 @@
-/**
- * Expo 54 Storage Adapter
- * 
- * Handles storage for React Native (expo-secure-store + AsyncStorage) and Web (localStorage)
- */
-
-import { Platform } from 'react-native';
-import type { AsyncStorageStatic } from '@react-native-async-storage/async-storage';
-
-// Lazy imports
-let SecureStore: typeof import('expo-secure-store') | null = null;
-let AsyncStorage: AsyncStorageStatic | null = null;
-
-/**
- * Initialize expo-secure-store (React Native only)
- */
-async function initSecureStore(): Promise<typeof import('expo-secure-store')> {
-  if (!SecureStore) {
-    try {
-      SecureStore = await import('expo-secure-store');
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      throw new Error(`Failed to load expo-secure-store: ${errorMessage}`);
-    }
-  }
-  return SecureStore;
-}
-
-/**
- * Initialize AsyncStorage (React Native only)
- */
-async function initAsyncStorage(): Promise<AsyncStorageStatic> {
-  if (!AsyncStorage) {
-    try {
-      const module = await import('@react-native-async-storage/async-storage');
-      AsyncStorage = (module.default as unknown) as AsyncStorageStatic;
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      throw new Error(`Failed to load AsyncStorage: ${errorMessage}`);
-    }
-  }
-  return AsyncStorage;
-}
-
-/**
- * Check if we're on React Native (not Web)
- */
-function isReactNative(): boolean {
-  try {
-    return Platform.OS !== 'web';
-  } catch {
-    return typeof navigator !== 'undefined' && navigator.product === 'ReactNative';
-  }
-}
-
-/**
- * Check if we're on Web
- */
-function isWeb(): boolean {
-  try {
-    return Platform.OS === 'web';
-  } catch {
-    return typeof window !== 'undefined' && typeof navigator !== 'undefined' && navigator.product !== 'ReactNative';
-  }
-}
-
-/**
- * Storage Adapter Interface
- */
-export interface StorageAdapter {
-  // Secure storage (para claves privadas) - SOLO NATIVE
-  secureGet(key: string): Promise<string | null>;
-  secureSet(key: string, value: string): Promise<void>;
-  secureDelete(key: string): Promise<void>;
-  isSecureStorageAvailable(): boolean;
-  
-  // Regular storage (para sesiones, etc.) - Native + Web
-  get(key: string): Promise<string | null>;
-  set(key: string, value: string): Promise<void>;
-  remove(key: string): Promise<void>;
-  clear(): Promise<void>;
-}
-
-/**
- * Create Expo Storage Adapter
- */
-export async function createExpoStorageAdapter(): Promise<StorageAdapter> {
-  const isNative = isReactNative();
-  const isWebPlatform = isWeb();
-
-  if (isNative) {
-    // React Native: Use expo-secure-store + AsyncStorage
-    const secureStore = await initSecureStore();
-    const asyncStorage = await initAsyncStorage();
-
-    return {
-      // Secure storage (expo-secure-store)
-      async secureGet(key: string): Promise<string | null> {
-        try {
-          return await secureStore.getItemAsync(key);
-        } catch (error) {
-          console.warn('[ExpoStorage] Failed to get secure item:', error);
-          return null;
-        }
-      },
-
-      async secureSet(key: string, value: string): Promise<void> {
-        try {
-          await secureStore.setItemAsync(key, value, {
-            keychainAccessible: secureStore.WHEN_UNLOCKED_THIS_DEVICE_ONLY,
-          });
-        } catch (error) {
-          console.warn('[ExpoStorage] Failed to set secure item:', error);
-          throw error;
-        }
-      },
-
-      async secureDelete(key: string): Promise<void> {
-        try {
-          await secureStore.deleteItemAsync(key);
-        } catch (error) {
-          console.warn('[ExpoStorage] Failed to delete secure item:', error);
-        }
-      },
-
-      isSecureStorageAvailable(): boolean {
-        return true;
-      },
-
-      // Regular storage (AsyncStorage)
-      async get(key: string): Promise<string | null> {
-        try {
-          return await asyncStorage.getItem(key);
-        } catch (error) {
-          console.warn('[ExpoStorage] Failed to get item:', error);
-          return null;
-        }
-      },
-
-      async set(key: string, value: string): Promise<void> {
-        try {
-          await asyncStorage.setItem(key, value);
-        } catch (error) {
-          console.warn('[ExpoStorage] Failed to set item:', error);
-          throw error;
-        }
-      },
-
-      async remove(key: string): Promise<void> {
-        try {
-          await asyncStorage.removeItem(key);
-        } catch (error) {
-          console.warn('[ExpoStorage] Failed to remove item:', error);
-        }
-      },
-
-      async clear(): Promise<void> {
-        try {
-          await asyncStorage.clear();
-        } catch (error) {
-          console.warn('[ExpoStorage] Failed to clear storage:', error);
-        }
-      },
-    };
-  } else if (isWebPlatform) {
-    // Web: Use localStorage only (no secure storage)
-    if (typeof window === 'undefined' || typeof window.localStorage === 'undefined') {
-      throw new Error('localStorage is not available in this environment');
-    }
-
-    return {
-      // Secure storage not available on Web
-      async secureGet(_key: string): Promise<string | null> {
-        return null;
-      },
-
-      async secureSet(_key: string, _value: string): Promise<void> {
-        // No-op on Web
-      },
-
-      async secureDelete(_key: string): Promise<void> {
-        // No-op on Web
-      },
-
-      isSecureStorageAvailable(): boolean {
-        return false;
-      },
-
-      // Regular storage (localStorage)
-      async get(key: string): Promise<string | null> {
-        try {
-          return window.localStorage.getItem(key);
-        } catch (error) {
-          console.warn('[ExpoStorage] Failed to get item:', error);
-          return null;
-        }
-      },
-
-      async set(key: string, value: string): Promise<void> {
-        try {
-          window.localStorage.setItem(key, value);
-        } catch (error) {
-          console.warn('[ExpoStorage] Failed to set item:', error);
-          throw error;
-        }
-      },
-
-      async remove(key: string): Promise<void> {
-        try {
-          window.localStorage.removeItem(key);
-        } catch (error) {
-          console.warn('[ExpoStorage] Failed to remove item:', error);
-        }
-      },
-
-      async clear(): Promise<void> {
-        try {
-          window.localStorage.clear();
-        } catch (error) {
-          console.warn('[ExpoStorage] Failed to clear storage:', error);
-        }
-      },
-    };
-  } else {
-    throw new Error('Unknown platform for Expo storage adapter');
-  }
-}
-

package/src/adapters/index.ts

@@ -1,34 +0,0 @@
-/**
- * Platform Adapters
- * 
- * Factory function to create the appropriate platform adapter.
- * Supports Expo 54 (frontend) and Node.js (backend).
- */
-
-import { createExpoAdapter, type PlatformAdapter as ExpoPlatformAdapter } from './expo';
-import type { PlatformAdapter as NodePlatformAdapter } from './node';
-
-export type PlatformAdapter = ExpoPlatformAdapter | NodePlatformAdapter;
-
-/**
- * Detect platform and create appropriate adapter
- * 
- * Simple detection: Expo (frontend) or Node.js (backend)
- * Uses dynamic import with constructed path to avoid Metro static analysis
- */
-export async function createPlatformAdapter(): Promise<PlatformAdapter> {
-  // Detect React Native/Expo first (frontend)
-  // If we can import react-native, we're in Expo environment
-  try {
-    await import('react-native');
-    // Expo (React Native or Web)
-    return await createExpoAdapter();
-  } catch {
-    // Not Expo, must be Node.js (backend)
-    // Construct path dynamically to avoid Metro static analysis
-    const nodePath = './node' + '/index.js';
-    const { createNodeAdapter } = await import(nodePath);
-    return await createNodeAdapter();
-  }
-}
-

package/src/adapters/node/crypto.ts

@@ -1,39 +0,0 @@
-/**
- * Node.js Crypto Adapter
- * 
- * Uses Node's built-in crypto module
- */
-
-import * as crypto from 'crypto';
-
-/**
- * Crypto Adapter Interface
- */
-export interface CryptoAdapter {
-  getRandomBytes(length: number): Promise<Uint8Array>;
-  digestStringAsync(algorithm: 'SHA256' | 'SHA512', data: string): Promise<string>;
-}
-
-/**
- * Create Node Crypto Adapter
- */
-export async function createNodeCryptoAdapter(): Promise<CryptoAdapter> {
-  return {
-    /**
-     * Generate cryptographically secure random bytes
-     */
-    async getRandomBytes(length: number): Promise<Uint8Array> {
-      return new Uint8Array(crypto.randomBytes(length));
-    },
-
-    /**
-     * Hash a string using the specified algorithm
-     */
-    async digestStringAsync(algorithm: 'SHA256' | 'SHA512', data: string): Promise<string> {
-      const hash = crypto.createHash(algorithm.toLowerCase());
-      hash.update(data);
-      return hash.digest('hex');
-    },
-  };
-}
-

package/src/adapters/node/fetch.ts

@@ -1,59 +0,0 @@
-/**
- * Node.js Fetch Adapter
- * 
- * Uses node-fetch or native fetch (Node 18+)
- */
-
-// Lazy import
-let nodeFetch: { default: typeof fetch } | null = null;
-
-/**
- * Initialize node-fetch
- */
-async function initNodeFetch(): Promise<{ default: typeof fetch }> {
-  if (!nodeFetch) {
-    try {
-      // Try native fetch first (Node 18+)
-      if (typeof fetch !== 'undefined') {
-        // Use a wrapper to match the interface
-        nodeFetch = {
-          default: fetch,
-        };
-        return nodeFetch;
-      }
-      
-      // Fallback to node-fetch (dynamic import to avoid type errors if not installed)
-      // @ts-ignore - node-fetch may not be installed, handled at runtime
-      const nodeFetchModule = await import('node-fetch');
-      nodeFetch = {
-        default: (nodeFetchModule.default || nodeFetchModule) as unknown as typeof fetch,
-      };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      throw new Error(`Failed to load fetch: ${errorMessage}. Please use Node.js 18+ or install node-fetch`);
-    }
-  }
-  return nodeFetch;
-}
-
-/**
- * Fetch Adapter Interface
- */
-export interface FetchAdapter {
-  fetch(url: string, options?: RequestInit): Promise<Response>;
-}
-
-/**
- * Create Node Fetch Adapter
- */
-export async function createNodeFetchAdapter(): Promise<FetchAdapter> {
-  const fetchModule = await initNodeFetch();
-  const fetchFn = (fetchModule as any).default || fetchModule;
-
-  return {
-    fetch(url: string, options?: RequestInit): Promise<Response> {
-      return fetchFn(url, options);
-    },
-  };
-}
-

package/src/adapters/node/index.ts

@@ -1,37 +0,0 @@
-/**
- * Node.js Platform Adapter
- * 
- * Provides storage, crypto, and fetch adapters for Node.js
- */
-
-import { createNodeStorageAdapter, type StorageAdapter } from './storage';
-import { createNodeCryptoAdapter, type CryptoAdapter } from './crypto';
-import { createNodeFetchAdapter, type FetchAdapter } from './fetch';
-import type { Platform as PlatformType } from '../../core/identity-session/types';
-
-/**
- * Platform Adapter Interface
- */
-export interface PlatformAdapter {
-  storage: StorageAdapter;
-  crypto: CryptoAdapter;
-  fetch: FetchAdapter;
-  platform: PlatformType;
-}
-
-/**
- * Create Node Platform Adapter
- */
-export async function createNodeAdapter(): Promise<PlatformAdapter> {
-  const storage = await createNodeStorageAdapter();
-  const crypto = await createNodeCryptoAdapter();
-  const fetchAdapter = await createNodeFetchAdapter();
-
-  return {
-    storage,
-    crypto,
-    fetch: fetchAdapter,
-    platform: 'node',
-  };
-}
-

package/src/adapters/node/storage.ts

@@ -1,170 +0,0 @@
-/**
- * Node.js Storage Adapter
- * 
- * Uses filesystem for storage
- */
-
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import * as os from 'os';
-
-/**
- * Storage Adapter Interface
- */
-export interface StorageAdapter {
-  // Secure storage (for private keys)
-  secureGet(key: string): Promise<string | null>;
-  secureSet(key: string, value: string): Promise<void>;
-  secureDelete(key: string): Promise<void>;
-  isSecureStorageAvailable(): boolean;
-  
-  // Regular storage
-  get(key: string): Promise<string | null>;
-  set(key: string, value: string): Promise<void>;
-  remove(key: string): Promise<void>;
-  clear(): Promise<void>;
-}
-
-/**
- * Get storage directory
- */
-function getStorageDir(): string {
-  const homeDir = os.homedir();
-  return path.join(homeDir, '.oxy', 'storage');
-}
-
-/**
- * Get secure storage directory
- */
-function getSecureStorageDir(): string {
-  const homeDir = os.homedir();
-  return path.join(homeDir, '.oxy', 'secure');
-}
-
-/**
- * Ensure directory exists
- */
-async function ensureDir(dirPath: string): Promise<void> {
-  try {
-    await fs.mkdir(dirPath, { recursive: true });
-  } catch (error) {
-    // Ignore if already exists
-    if ((error as NodeJS.ErrnoException).code !== 'EEXIST') {
-      throw error;
-    }
-  }
-}
-
-/**
- * Get file path for a key
- */
-function getFilePath(key: string, secure: boolean = false): string {
-  const baseDir = secure ? getSecureStorageDir() : getStorageDir();
-  // Sanitize key to prevent directory traversal
-  const sanitizedKey = key.replace(/[^a-zA-Z0-9_-]/g, '_');
-  return path.join(baseDir, `${sanitizedKey}.json`);
-}
-
-/**
- * Create Node Storage Adapter
- */
-export async function createNodeStorageAdapter(): Promise<StorageAdapter> {
-  // Ensure directories exist
-  await ensureDir(getStorageDir());
-  await ensureDir(getSecureStorageDir());
-
-  return {
-    // Secure storage
-    async secureGet(key: string): Promise<string | null> {
-      try {
-        const filePath = getFilePath(key, true);
-        const data = await fs.readFile(filePath, 'utf-8');
-        const parsed = JSON.parse(data);
-        return parsed.value || null;
-      } catch (error) {
-        if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
-          return null;
-        }
-        console.warn('[NodeStorage] Failed to get secure item:', error);
-        return null;
-      }
-    },
-
-    async secureSet(key: string, value: string): Promise<void> {
-      try {
-        const filePath = getFilePath(key, true);
-        const data = JSON.stringify({ value, timestamp: Date.now() });
-        await fs.writeFile(filePath, data, { mode: 0o600 }); // Read/write for owner only
-      } catch (error) {
-        console.warn('[NodeStorage] Failed to set secure item:', error);
-        throw error;
-      }
-    },
-
-    async secureDelete(key: string): Promise<void> {
-      try {
-        const filePath = getFilePath(key, true);
-        await fs.unlink(filePath);
-      } catch (error) {
-        if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
-          console.warn('[NodeStorage] Failed to delete secure item:', error);
-        }
-      }
-    },
-
-    isSecureStorageAvailable(): boolean {
-      return true;
-    },
-
-    // Regular storage
-    async get(key: string): Promise<string | null> {
-      try {
-        const filePath = getFilePath(key, false);
-        const data = await fs.readFile(filePath, 'utf-8');
-        const parsed = JSON.parse(data);
-        return parsed.value || null;
-      } catch (error) {
-        if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
-          return null;
-        }
-        console.warn('[NodeStorage] Failed to get item:', error);
-        return null;
-      }
-    },
-
-    async set(key: string, value: string): Promise<void> {
-      try {
-        const filePath = getFilePath(key, false);
-        const data = JSON.stringify({ value, timestamp: Date.now() });
-        await fs.writeFile(filePath, data);
-      } catch (error) {
-        console.warn('[NodeStorage] Failed to set item:', error);
-        throw error;
-      }
-    },
-
-    async remove(key: string): Promise<void> {
-      try {
-        const filePath = getFilePath(key, false);
-        await fs.unlink(filePath);
-      } catch (error) {
-        if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
-          console.warn('[NodeStorage] Failed to remove item:', error);
-        }
-      }
-    },
-
-    async clear(): Promise<void> {
-      try {
-        const storageDir = getStorageDir();
-        const files = await fs.readdir(storageDir);
-        await Promise.all(
-          files.map(file => fs.unlink(path.join(storageDir, file)))
-        );
-      } catch (error) {
-        console.warn('[NodeStorage] Failed to clear storage:', error);
-      }
-    },
-  };
-}
-