@oxyhq/services 5.10.15 → 5.11.1

package/src/core/OxyServices.ts

@@ -1,9 +1,17 @@
-import axios, { AxiosInstance, InternalAxiosRequestConfig } from 'axios';
+import axios, { type AxiosInstance, type InternalAxiosRequestConfig } from 'axios';
 import { jwtDecode } from 'jwt-decode';
-import { OxyConfig, ApiError, User, Notification } from '../models/interfaces';
-import { SessionLoginResponse } from '../models/session';
+import type { 
+  OxyConfig, 
+  ApiError, 
+  User, 
+  Notification, 
+  AssetInitResponse, 
+  AssetUrlResponse, 
+  AssetVariant 
+} from '../models/interfaces';
+import type { SessionLoginResponse } from '../models/session';
 import { handleHttpError } from '../utils/errorUtils';
-import { buildSearchParams, buildPaginationParams, PaginationParams } from '../utils/apiUtils';
+import { buildSearchParams, buildPaginationParams, type PaginationParams } from '../utils/apiUtils';
 
 interface JwtPayload {
   exp?: number;
@@ -20,7 +28,7 @@ export class OxyAuthenticationError extends Error {
   public readonly code: string;
   public readonly status: number;
 
-  constructor(message: string, code: string = 'AUTH_ERROR', status: number = 401) {
+  constructor(message: string, code = 'AUTH_ERROR', status = 401) {
     super(message);
     this.name = 'OxyAuthenticationError';
     this.code = code;
@@ -60,7 +68,7 @@ class TokenStore {
     return TokenStore.instance;
   }
 
-  setTokens(accessToken: string, refreshToken: string = ''): void {
+  setTokens(accessToken: string, refreshToken = ''): void {
     this.accessToken = accessToken;
     this.refreshToken = refreshToken;
   }
@@ -194,7 +202,7 @@ export class OxyServices {
   /**
    * Set authentication tokens
    */
-  public setTokens(accessToken: string, refreshToken: string = ''): void {
+  public setTokens(accessToken: string, refreshToken = ''): void {
     this.tokenStore.setTokens(accessToken, refreshToken);
   }
 
@@ -236,18 +244,25 @@ export class OxyServices {
     return this.tokenStore.hasAccessToken();
   }
 
+  /**
+   * Get the raw access token (for constructing anchor URLs when needed)
+   */
+  public getAccessToken(): string | null {
+    return this.tokenStore.getAccessToken();
+  }
+
   /**
    * Wait for authentication to be ready (public method)
    * Useful for apps that want to ensure authentication is complete before proceeding
    */
-  public async waitForAuth(timeoutMs: number = 5000): Promise<boolean> {
+  public async waitForAuth(timeoutMs = 5000): Promise<boolean> {
     return this.waitForAuthentication(timeoutMs);
   }
 
   /**
    * Wait for authentication to be ready with timeout
    */
-  private async waitForAuthentication(timeoutMs: number = 5000): Promise<boolean> {
+  private async waitForAuthentication(timeoutMs = 5000): Promise<boolean> {
     const startTime = Date.now();
     const checkInterval = 100; // Check every 100ms
 
@@ -940,7 +955,8 @@ export class OxyServices {
    */
   async deleteFile(fileId: string): Promise<any> {
     try {
-      const res = await this.client.delete(`/api/files/${fileId}`);
+      // Central Asset Service delete with force=true behavior controlled by caller via assetDelete
+      const res = await this.client.delete(`/api/assets/${encodeURIComponent(fileId)}`);
       return res.data;
     } catch (error) {
       throw this.handleError(error);
@@ -950,8 +966,16 @@ export class OxyServices {
   /**
    * Get file download URL
    */
-  getFileDownloadUrl(fileId: string): string {
-    return `${OXY_CLOUD_URL}/files/${fileId}/download`;
+  getFileDownloadUrl(fileId: string, variant?: string, expiresIn?: number): string {
+    // Default to streaming proxy to avoid ORB; attach token via query for <img src>
+    const base = this.getBaseURL();
+    const params = new URLSearchParams();
+  if (variant) params.set('variant', variant);
+  // Request a visible server-side placeholder if object is missing
+  params.set('fallback', 'placeholderVisible');
+    const token = this.tokenStore.getAccessToken();
+    if (token) params.set('token', token);
+    return `${base}/api/assets/${encodeURIComponent(fileId)}/stream${params.size ? `?${params.toString()}` : ''}`;
   }
 
   /**
@@ -964,37 +988,181 @@ export class OxyServices {
   /**
    * List user files
    */
-  async listUserFiles(
-    userId: string,
-    limit?: number,
-    offset?: number,
-    filters?: Record<string, any>
-  ): Promise<any> {
+  async listUserFiles(limit?: number, offset?: number): Promise<{ files: any[]; total: number; hasMore: boolean }> {
     try {
       const params = new URLSearchParams();
-      if (limit) params.append('limit', limit.toString());
-      if (offset) params.append('offset', offset.toString());
+      if (limit) params.append('limit', String(limit));
+      if (offset) params.append('offset', String(offset));
+      const res = await this.client.get(`/api/assets${params.size ? `?${params.toString()}` : ''}`);
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  // (removed legacy downloadFileContent; use getFileContentAsBlob/Text which resolve CAS URL first)
+
+  /**
+   * Get file content as text
+   */
+  async getFileContentAsText(fileId: string, variant?: string): Promise<string> {
+    try {
+      const urlRes = await this.client.get(`/api/assets/${encodeURIComponent(fileId)}/url${variant ? `?variant=${encodeURIComponent(variant)}` : ''}`);
+      const downloadUrl = urlRes.data?.url;
+      const response = await fetch(downloadUrl);
+      return await response.text();
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Get file content as blob
+   */
+  async getFileContentAsBlob(fileId: string, variant?: string): Promise<Blob> {
+    try {
+      const urlRes = await this.client.get(`/api/assets/${encodeURIComponent(fileId)}/url${variant ? `?variant=${encodeURIComponent(variant)}` : ''}`);
+      const downloadUrl = urlRes.data?.url;
+      const response = await fetch(downloadUrl);
+      return await response.blob();
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Upload raw file data
+   */
+  async uploadRawFile(file: File | Blob, metadata?: Record<string, any>): Promise<any> {
+    // Switch to Central Asset Service upload flow
+    return this.assetUpload(file as File, metadata);
+  }
+
+  // ============================================================================
+  // CENTRAL ASSET SERVICE METHODS
+  // ============================================================================
+
+  /**
+   * Calculate SHA256 hash of file content
+   */
+  async calculateSHA256(file: File | Blob): Promise<string> {
+    const buffer = await file.arrayBuffer();
+    const hashBuffer = await crypto.subtle.digest('SHA-256', buffer);
+    const hashArray = Array.from(new Uint8Array(hashBuffer));
+    return hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
+  }
+
+  /**
+   * Initialize asset upload - returns pre-signed URL and file ID
+   */
+  async assetInit(sha256: string, size: number, mime: string): Promise<AssetInitResponse> {
+    try {
+      const res = await this.client.post('/api/assets/init', {
+        sha256,
+        size,
+        mime
+      });
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Complete asset upload - commit metadata and trigger variant generation
+   */
+  async assetComplete(fileId: string, originalName: string, size: number, mime: string, metadata?: Record<string, any>): Promise<any> {
+    try {
+      const res = await this.client.post('/api/assets/complete', {
+        fileId,
+        originalName,
+        size,
+        mime,
+        metadata
+      });
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Upload file using Central Asset Service
+   */
+  async assetUpload(file: File, metadata?: Record<string, any>, onProgress?: (progress: number) => void): Promise<any> {
+    try {
+      // Calculate SHA256
+      const sha256 = await this.calculateSHA256(file);
       
-      if (filters) {
-        Object.entries(filters).forEach(([key, value]) => {
-          params.append(key, value.toString());
+      // Initialize upload
+      const initResponse = await this.assetInit(sha256, file.size, file.type);
+
+      // Try presigned URL first
+      try {
+        await this.uploadToPresignedUrl(initResponse.uploadUrl, file, onProgress);
+      } catch (e) {
+        // Fallback: direct upload via API to avoid CORS issues
+        const fd = new FormData();
+        fd.append('file', file);
+        await this.client.post(`/api/assets/${encodeURIComponent(initResponse.fileId)}/upload-direct`, fd, {
+          headers: { 'Content-Type': 'multipart/form-data' }
         });
       }
-      
-      const res = await this.client.get(`/api/files/list/${userId}?${params.toString()}`);
-      return res.data;
+
+      // Complete upload
+      return await this.assetComplete(
+        initResponse.fileId,
+        file.name,
+        file.size,
+        file.type,
+        metadata
+      );
     } catch (error) {
       throw this.handleError(error);
     }
   }
 
   /**
-   * Download file content
+   * Upload file to pre-signed URL
+   */
+  private async uploadToPresignedUrl(url: string, file: File, onProgress?: (progress: number) => void): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const xhr = new XMLHttpRequest();
+      
+      xhr.upload.addEventListener('progress', (event) => {
+        if (event.lengthComputable && onProgress) {
+          const progress = (event.loaded / event.total) * 100;
+          onProgress(progress);
+        }
+      });
+      
+      xhr.addEventListener('load', () => {
+        if (xhr.status >= 200 && xhr.status < 300) {
+          resolve();
+        } else {
+          reject(new Error(`Upload failed with status ${xhr.status}`));
+        }
+      });
+      
+      xhr.addEventListener('error', () => {
+        reject(new Error('Upload failed'));
+      });
+      
+      xhr.open('PUT', url);
+      xhr.setRequestHeader('Content-Type', file.type);
+      xhr.send(file);
+    });
+  }
+
+  /**
+   * Link asset to an entity
    */
-  async downloadFileContent(fileId: string): Promise<Response> {
+  async assetLink(fileId: string, app: string, entityType: string, entityId: string): Promise<any> {
     try {
-      const res = await this.client.get(`/api/files/${fileId}`, {
-        responseType: 'blob'
+      const res = await this.client.post(`/api/assets/${fileId}/links`, {
+        app,
+        entityType,
+        entityId
       });
       return res.data;
     } catch (error) {
@@ -1003,13 +1171,15 @@ export class OxyServices {
   }
 
   /**
-   * Get file content as text
+   * Unlink asset from an entity
    */
-  async getFileContentAsText(fileId: string): Promise<string> {
+  async assetUnlink(fileId: string, app: string, entityType: string, entityId: string): Promise<any> {
     try {
-      const res = await this.client.get(`/api/files/${fileId}`, {
-        headers: {
-          'Accept': 'text/plain'
+      const res = await this.client.delete(`/api/assets/${fileId}/links`, {
+        data: {
+          app,
+          entityType,
+          entityId
         }
       });
       return res.data;
@@ -1019,19 +1189,73 @@ export class OxyServices {
   }
 
   /**
-   * Get file content as blob
+   * Get asset metadata
    */
-  async getFileContentAsBlob(fileId: string): Promise<Blob> {
+  async assetGet(fileId: string): Promise<any> {
     try {
-      const res = await this.client.get(`/api/files/${fileId}`, {
-        responseType: 'blob'
-      });
+      const res = await this.client.get(`/api/assets/${fileId}`);
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Get asset URL (CDN or signed URL)
+   */
+  async assetGetUrl(fileId: string, variant?: string, expiresIn?: number): Promise<AssetUrlResponse> {
+    try {
+      const params = new URLSearchParams();
+      if (variant) params.set('variant', variant);
+      if (expiresIn) params.set('expiresIn', expiresIn.toString());
+      
+      const queryString = params.toString();
+      const url = `/api/assets/${fileId}/url${queryString ? `?${queryString}` : ''}`;
+      
+      const res = await this.client.get(url);
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Restore asset from trash
+   */
+  async assetRestore(fileId: string): Promise<any> {
+    try {
+      const res = await this.client.post(`/api/assets/${fileId}/restore`);
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Delete asset with optional force
+   */
+  async assetDelete(fileId: string, force: boolean = false): Promise<any> {
+    try {
+      const params = force ? '?force=true' : '';
+      const res = await this.client.delete(`/api/assets/${fileId}${params}`);
       return res.data;
     } catch (error) {
       throw this.handleError(error);
     }
   }
 
+  /**
+   * Get list of available variants for an asset
+   */
+  async assetGetVariants(fileId: string): Promise<AssetVariant[]> {
+    try {
+      const assetData = await this.assetGet(fileId);
+      return assetData.file?.variants || [];
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
   // ============================================================================
   // LOCATION METHODS
   // ============================================================================
@@ -1337,4 +1561,7 @@ export class OxyServices {
 }
 
 // Export the cloud URL constant
-export const OXY_CLOUD_URL = 'https://cloud.oxyhq.com';
+export const OXY_CLOUD_URL = 'https://cloud.oxyhq.com';
+
+// Pre-configured client instance for easy import
+export const oxyClient = new OxyServices({ baseURL: OXY_CLOUD_URL });

package/src/core/__tests__/OxyServices.test.ts

@@ -0,0 +1,180 @@
+import { OxyServices, OxyAuthenticationError, OxyAuthenticationTimeoutError } from '../OxyServices';
+import { OXY_CLOUD_URL } from '../index';
+
+// Mock axios for testing
+jest.mock('axios');
+
+describe('OxyServices', () => {
+  let oxyServices: OxyServices;
+
+  beforeEach(() => {
+    // Create a fresh instance for each test
+    oxyServices = new OxyServices({ baseURL: 'https://test.example.com' });
+    jest.clearAllMocks();
+  });
+
+  describe('Constructor and Configuration', () => {
+    it('should create an instance with the provided baseURL', () => {
+      const customURL = 'https://custom.example.com';
+      const service = new OxyServices({ baseURL: customURL });
+      expect(service.getBaseURL()).toBe(customURL);
+    });
+
+    it('should have a default cloud URL constant', () => {
+      expect(OXY_CLOUD_URL).toBe('https://cloud.oxyhq.com');
+    });
+  });
+
+  describe('Token Management', () => {
+    it('should set and retrieve tokens', () => {
+      const accessToken = 'test-access-token';
+      const refreshToken = 'test-refresh-token';
+
+      oxyServices.setTokens(accessToken, refreshToken);
+      expect(oxyServices.hasValidToken()).toBe(true);
+    });
+
+    it('should clear tokens', () => {
+      oxyServices.setTokens('test-token', 'refresh-token');
+      expect(oxyServices.hasValidToken()).toBe(true);
+
+      oxyServices.clearTokens();
+      expect(oxyServices.hasValidToken()).toBe(false);
+    });
+
+    it('should return null for user ID when no token is set', () => {
+      expect(oxyServices.getCurrentUserId()).toBeNull();
+    });
+  });
+
+  describe('Authentication Methods', () => {
+    it('should call signUp endpoint with correct parameters', async () => {
+      const mockAxios = require('axios');
+      const mockResponse = { data: { message: 'Success', token: 'test-token', user: { id: '1', username: 'test' } } };
+      mockAxios.create().post.mockResolvedValue(mockResponse);
+
+      const result = await oxyServices.signUp('testuser', 'test@example.com', 'password');
+
+      expect(mockAxios.create().post).toHaveBeenCalledWith('/api/auth/signup', {
+        username: 'testuser',
+        email: 'test@example.com',
+        password: 'password'
+      });
+      expect(result).toEqual(mockResponse.data);
+    });
+
+    it('should call signIn endpoint with correct parameters', async () => {
+      const mockAxios = require('axios');
+      const mockResponse = { data: { accessToken: 'test-token', user: { id: '1', username: 'test' } } };
+      mockAxios.create().post.mockResolvedValue(mockResponse);
+
+      const result = await oxyServices.signIn('testuser', 'password');
+
+      expect(mockAxios.create().post).toHaveBeenCalledWith('/api/auth/login', {
+        username: 'testuser',
+        password: 'password',
+        deviceName: undefined,
+        deviceFingerprint: undefined
+      });
+      expect(result).toEqual(mockResponse.data);
+    });
+  });
+
+  describe('Session Management', () => {
+    it('should get user by session ID', async () => {
+      const mockAxios = require('axios');
+      const mockUser = { id: '1', username: 'testuser' };
+      mockAxios.create().get.mockResolvedValue({ data: mockUser });
+
+      const result = await oxyServices.getUserBySession('test-session-id');
+
+      expect(mockAxios.create().get).toHaveBeenCalledWith('/api/session/user/test-session-id');
+      expect(result).toEqual(mockUser);
+    });
+
+    it('should get token by session ID and set it', async () => {
+      const mockAxios = require('axios');
+      const mockResponse = { data: { accessToken: 'new-token', expiresAt: '2024-01-01' } };
+      mockAxios.create().get.mockResolvedValue(mockResponse);
+
+      const result = await oxyServices.getTokenBySession('test-session-id');
+
+      expect(mockAxios.create().get).toHaveBeenCalledWith('/api/session/token/test-session-id');
+      expect(result).toEqual(mockResponse.data);
+      expect(oxyServices.hasValidToken()).toBe(true);
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle API errors correctly', async () => {
+      const mockAxios = require('axios');
+      const mockError = new Error('API Error');
+      mockAxios.create().post.mockRejectedValue(mockError);
+
+      await expect(oxyServices.signUp('test', 'test@example.com', 'pass')).rejects.toThrow();
+    });
+  });
+
+  describe('Custom Error Types', () => {
+    it('should create OxyAuthenticationError with correct properties', () => {
+      const error = new OxyAuthenticationError('Test error', 'TEST_CODE', 401);
+      expect(error.message).toBe('Test error');
+      expect(error.code).toBe('TEST_CODE');
+      expect(error.status).toBe(401);
+      expect(error.name).toBe('OxyAuthenticationError');
+    });
+
+    it('should create OxyAuthenticationTimeoutError with correct properties', () => {
+      const error = new OxyAuthenticationTimeoutError('testOperation', 5000);
+      expect(error.message).toContain('testOperation');
+      expect(error.message).toContain('5000ms');
+      expect(error.code).toBe('AUTH_TIMEOUT');
+      expect(error.status).toBe(408);
+      expect(error.name).toBe('OxyAuthenticationTimeoutError');
+    });
+  });
+
+  describe('Health Check', () => {
+    it('should call health check endpoint', async () => {
+      const mockAxios = require('axios');
+      const mockResponse = { data: { status: 'ok', timestamp: '2024-01-01' } };
+      mockAxios.create().get.mockResolvedValue(mockResponse);
+
+      const result = await oxyServices.healthCheck();
+
+      expect(mockAxios.create().get).toHaveBeenCalledWith('/health');
+      expect(result).toEqual(mockResponse.data);
+    });
+  });
+
+  describe('Validation Methods', () => {
+    it('should return false when no token is available for validation', async () => {
+      const result = await oxyServices.validate();
+      expect(result).toBe(false);
+    });
+
+    it('should validate token with server when token exists', async () => {
+      const mockAxios = require('axios');
+      oxyServices.setTokens('test-token');
+      mockAxios.create().get.mockResolvedValue({ data: { valid: true } });
+
+      const result = await oxyServices.validate();
+
+      expect(mockAxios.create().get).toHaveBeenCalledWith('/api/auth/validate');
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('Wait for Authentication', () => {
+    it('should resolve immediately if token is already available', async () => {
+      oxyServices.setTokens('test-token');
+      const result = await oxyServices.waitForAuth(1000);
+      expect(result).toBe(true);
+    });
+
+    it('should timeout if no token becomes available', async () => {
+      const result = await oxyServices.waitForAuth(100);
+      expect(result).toBe(false);
+    });
+  });
+});

package/src/core/index.ts

@@ -7,7 +7,7 @@
 
 // Main OxyServices class (unified)
 export { OxyServices, OxyAuthenticationError, OxyAuthenticationTimeoutError } from './OxyServices';
-export { OXY_CLOUD_URL } from './OxyServices';
+export { OXY_CLOUD_URL, oxyClient } from './OxyServices';
 
 // Re-export all models and types for convenience
 export * from '../models/interfaces';

package/src/index.ts

@@ -8,7 +8,7 @@
 
 // Core exports
 export { OxyServices, OxyAuthenticationError, OxyAuthenticationTimeoutError } from './core';
-export { OXY_CLOUD_URL } from './core';
+export { OXY_CLOUD_URL, oxyClient } from './core';
 
 // React context
 export { 
@@ -54,7 +54,19 @@ export type {
   DeviceSession,
   DeviceSessionsResponse,
   DeviceSessionLogoutResponse,
-  UpdateDeviceNameResponse
+  UpdateDeviceNameResponse,
+  // Central Asset Service types
+  AssetLink,
+  AssetVariant,
+  Asset,
+  AssetInitRequest,
+  AssetInitResponse,
+  AssetCompleteRequest,
+  AssetLinkRequest,
+  AssetUnlinkRequest,
+  AssetUrlResponse,
+  AssetDeleteSummary,
+  AssetUploadProgress
 } from './models/interfaces';
 
 export type {
@@ -65,7 +77,9 @@ export type {
 
 // UI components and hooks
 export { useAuthStore } from './ui/stores/authStore';
+export { useAssetStore, useAssets as useAssetsStore, useAsset, useUploadProgress, useAssetLoading, useAssetErrors, useAssetsByApp, useAssetsByEntity, useAssetUsageCount, useIsAssetLinked } from './ui/stores/assetStore';
 export { useSessionSocket } from './ui/hooks/useSessionSocket';
+export { useAssets, setOxyAssetInstance } from './ui/hooks/useAssets';
 
 // UI components
 export { OxySignInButton } from './ui/components/OxySignInButton';

package/src/lib/sonner-safe.ts

@@ -4,7 +4,10 @@
  * In backend: exports a no-op function
  */
 
-let toast: any;
+// Define a type for the toast function
+type ToastFunction = (message: string, options?: Record<string, unknown>) => void;
+
+let toast: ToastFunction;
 
 // Environment detection
 const isFrontend = typeof window !== 'undefined' || 

package/src/lib/sonner.ts

@@ -2,8 +2,25 @@ import { Platform } from 'react-native';
 import * as WebSonner from 'sonner';
 import * as NativeSonner from 'sonner-native';
 
-const { toast: webToast, Toaster: WebToaster } = WebSonner as any;
-const { toast: nativeToast, Toaster: NativeToaster } = NativeSonner as any;
+// Define proper types for the toast components
+interface ToastFunction {
+  (message: string, options?: Record<string, unknown>): void;
+  success: (message: string, options?: Record<string, unknown>) => void;
+  error: (message: string, options?: Record<string, unknown>) => void;
+  info: (message: string, options?: Record<string, unknown>) => void;
+  warning: (message: string, options?: Record<string, unknown>) => void;
+}
+
+type ToasterComponent = (props?: Record<string, unknown>) => React.ReactElement | null;
+
+const { toast: webToast, Toaster: WebToaster } = WebSonner as { 
+  toast: ToastFunction; 
+  Toaster: ToasterComponent; 
+};
+const { toast: nativeToast, Toaster: NativeToaster } = NativeSonner as { 
+  toast: ToastFunction; 
+  Toaster: ToasterComponent; 
+};
 
 export const toast = Platform.OS === 'web' ? webToast : nativeToast;
 export const Toaster = Platform.OS === 'web' ? WebToaster : NativeToaster;