@oxyhq/services 5.10.4 → 5.10.6

package/src/core/index.ts

@@ -1,28 +1,13 @@
 /**
- * OxyServices Core Module - Modular Architecture
+ * OxyServices Core Module - Unified Architecture
  * 
- * This module exports the main OxyServices class and all individual service modules
- * for a clean, maintainable, and focused architecture.
+ * This module exports the unified OxyServices class that provides all API functionality
+ * in one simple, easy-to-use interface.
  */
 
-// Main OxyServices class (backward compatible)
-export { OxyServicesMain as OxyServices } from './OxyServicesMain';
-
-// Individual service classes for focused usage
-export { AuthService } from './auth/AuthService';
-export { UserService } from './users/UserService';
-export { PaymentService } from './payments/PaymentService';
-export { KarmaService } from './karma/KarmaService';
-export { FileService } from './files/FileService';
-export { LocationService } from './locations/LocationService';
-export { AnalyticsService } from './analytics/AnalyticsService';
-export { DeviceService } from './devices/DeviceService';
-
-// Base class for custom service extensions
-export { OxyServices as BaseOxyServices } from './OxyServices';
-
-// Constants
-export { OXY_CLOUD_URL } from './files/FileService';
+// Main OxyServices class (unified)
+export { OxyServices } from './OxyServices';
+export { OXY_CLOUD_URL } from './OxyServices';
 
 // Re-export all models and types for convenience
 export * from '../models/interfaces';
@@ -32,8 +17,8 @@ export * from '../models/session';
 export { DeviceManager } from '../utils/deviceManager';
 export type { DeviceFingerprint, StoredDeviceInfo } from '../utils/deviceManager';
 
-// Import the main class for default export
-import { OxyServicesMain } from './OxyServicesMain';
+// Import for default export
+import { OxyServices } from './OxyServices';
 
 // Default export for backward compatibility
-export default OxyServicesMain;
+export default OxyServices;

package/src/index.ts

@@ -94,4 +94,20 @@ export {
   logPerformance
 } from './utils/loggerUtils';
 export * from './utils/asyncUtils';
-export * from './utils/hookUtils';
+export * from './utils/hookUtils';
+
+// S3 File Management exports
+export { 
+  S3FileManager, 
+  createS3FileManager
+} from './utils/s3FileManager';
+export { 
+  S3FileManagerRN, 
+  createS3FileManagerRN 
+} from './utils/s3FileManagerRN';
+export type { 
+  S3Config, 
+  UploadOptions, 
+  FileInfo
+} from './utils/s3FileManager';
+export type { RNFile } from './utils/s3FileManagerRN';

package/src/ui/screens/FileManagementScreen.tsx

@@ -118,7 +118,7 @@ const FileManagementScreen: React.FC<FileManagementScreenProps> = ({
                 setLoading(true);
             }
 
-            const response = await oxyServices.files.listUserFiles(targetUserId);
+            const response = await oxyServices.listUserFiles(targetUserId);
             setFiles(response.files || []);
         } catch (error: any) {
             console.error('Failed to load files:', error);
@@ -172,7 +172,7 @@ const FileManagementScreen: React.FC<FileManagementScreenProps> = ({
             await Promise.all(
                 photosToLoad.map(async (photo) => {
                     try {
-                        const downloadUrl = oxyServices.files.getFileDownloadUrl(photo.id);
+                        const downloadUrl = oxyServices.getFileDownloadUrl(photo.id);
 
                         if (Platform.OS === 'web') {
                             const img = new (window as any).Image();
@@ -340,7 +340,7 @@ const FileManagementScreen: React.FC<FileManagementScreenProps> = ({
             console.log('Current user ID:', user?.id);
             setDeleting(fileId);
 
-            const result = await oxyServices.files.deleteFile(fileId);
+            const result = await oxyServices.deleteFile(fileId);
             console.log('Delete result:', result);
 
             toast.success('File deleted successfully');
@@ -408,7 +408,7 @@ const FileManagementScreen: React.FC<FileManagementScreenProps> = ({
                 console.log('Downloading file:', { fileId, filename });
 
                 // Use the public download URL method
-                const downloadUrl = oxyServices.files.getFileDownloadUrl(fileId);
+                const downloadUrl = oxyServices.getFileDownloadUrl(fileId);
                 console.log('Download URL:', downloadUrl);
 
                 try {
@@ -426,7 +426,7 @@ const FileManagementScreen: React.FC<FileManagementScreenProps> = ({
                     console.warn('Link download failed, trying fetch method:', linkError);
 
                     // Method 2: Fallback to authenticated download
-                    const blob = await oxyServices.files.getFileContentAsBlob(fileId);
+                    const blob = await oxyServices.getFileContentAsBlob(fileId);
                     const url = window.URL.createObjectURL(blob);
 
                     const link = document.createElement('a');
@@ -491,11 +491,11 @@ const FileManagementScreen: React.FC<FileManagementScreenProps> = ({
                         file.contentType.startsWith('video/') ||
                         file.contentType.startsWith('audio/')) {
                         // For images, PDFs, videos, and audio, we'll use the URL directly
-                        const downloadUrl = oxyServices.files.getFileDownloadUrl(file.id);
+                        const downloadUrl = oxyServices.getFileDownloadUrl(file.id);
                         setFileContent(downloadUrl);
                     } else {
                         // For text files, get the content using authenticated request
-                        const content = await oxyServices.files.getFileContentAsText(file.id);
+                        const content = await oxyServices.getFileContentAsText(file.id);
                         setFileContent(content);
                     }
                 } catch (error: any) {
@@ -532,7 +532,7 @@ const FileManagementScreen: React.FC<FileManagementScreenProps> = ({
     };
 
     const renderSimplePhotoItem = useCallback((photo: FileMetadata, index: number) => {
-        const downloadUrl = oxyServices.files.getFileDownloadUrl(photo.id);
+        const downloadUrl = oxyServices.getFileDownloadUrl(photo.id);
 
         // Calculate photo item width based on actual container size from bottom sheet
         let itemsPerRow = 3; // Default for mobile
@@ -598,7 +598,7 @@ const FileManagementScreen: React.FC<FileManagementScreenProps> = ({
     }, [oxyServices, containerWidth]);
 
     const renderJustifiedPhotoItem = useCallback((photo: FileMetadata, width: number, height: number, isLast: boolean) => {
-        const downloadUrl = oxyServices.files.getFileDownloadUrl(photo.id);
+        const downloadUrl = oxyServices.getFileDownloadUrl(photo.id);
 
         return (
             <TouchableOpacity
@@ -689,7 +689,7 @@ const FileManagementScreen: React.FC<FileManagementScreenProps> = ({
                                 {isImage && (
                                     Platform.OS === 'web' ? (
                                         <img
-                                            src={oxyServices.files.getFileDownloadUrl(file.id)}
+                                            src={oxyServices.getFileDownloadUrl(file.id)}
                                             style={{
                                                 width: '100%',
                                                 height: '100%',
@@ -709,7 +709,7 @@ const FileManagementScreen: React.FC<FileManagementScreenProps> = ({
                                         />
                                     ) : (
                                         <Image
-                                            source={{ uri: oxyServices.files.getFileDownloadUrl(file.id) }}
+                                            source={{ uri: oxyServices.getFileDownloadUrl(file.id) }}
                                             style={styles.previewImage}
                                             resizeMode="cover"
                                             onError={() => {
@@ -817,7 +817,7 @@ const FileManagementScreen: React.FC<FileManagementScreenProps> = ({
     };
 
     const renderPhotoItem = (photo: FileMetadata, index: number) => {
-        const downloadUrl = oxyServices.files.getFileDownloadUrl(photo.id);
+        const downloadUrl = oxyServices.getFileDownloadUrl(photo.id);
 
         // Calculate photo item width based on actual container size from bottom sheet
         let itemsPerRow = 3; // Default for mobile

package/src/ui/screens/ProfileScreen.tsx

@@ -61,7 +61,7 @@ const ProfileScreen: React.FC<ProfileScreenProps> = ({ userId, username, theme,
 
         // Load user profile and karma total
         Promise.all([
-            oxyServices.users.getUserById(userId).catch((err: any) => {
+            oxyServices.getUserById(userId).catch((err: any) => {
                 console.error('getUserById error:', err);
                 // If this is the current user and the API call fails, use current user data as fallback
                 if (currentUser && currentUser.id === userId) {
@@ -70,8 +70,8 @@ const ProfileScreen: React.FC<ProfileScreenProps> = ({ userId, username, theme,
                 }
                 throw err;
             }),
-            oxyServices.karma.getUserKarmaTotal ?
-                oxyServices.karma.getUserKarmaTotal(userId).catch((err: any) => {
+            oxyServices.getUserKarmaTotal ?
+                oxyServices.getUserKarmaTotal(userId).catch((err: any) => {
                     console.warn('getUserKarmaTotal error:', err);
                     return { total: undefined };
                 }) :

package/src/ui/screens/SignInScreen.tsx

@@ -136,7 +136,7 @@ const SignInScreen: React.FC<BaseScreenProps> = ({
 
         try {
             // First check if username exists by trying to get profile
-            const profile = await oxyServices.users.getProfileByUsername(usernameToValidate);
+            const profile = await oxyServices.getProfileByUsername(usernameToValidate);
 
             if (profile) {
                 const profileData = {

package/src/ui/screens/karma/KarmaCenterScreen.tsx

@@ -38,8 +38,8 @@ const KarmaCenterScreen: React.FC<BaseScreenProps> = ({
         setIsLoading(true);
         setError(null);
         Promise.all([
-            oxyServices.karma.getUserKarmaTotal(user.id),
-            oxyServices.karma.getUserKarmaHistory(user.id, 20, 0),
+            oxyServices.getUserKarmaTotal(user.id),
+            oxyServices.getUserKarmaHistory(user.id, 20, 0),
         ])
             .then(([totalRes, historyRes]) => {
                 setKarmaTotal(totalRes.total);

package/src/ui/screens/karma/KarmaLeaderboardScreen.tsx

@@ -19,7 +19,7 @@ const KarmaLeaderboardScreen: React.FC<BaseScreenProps> = ({ goBack, theme, navi
     useEffect(() => {
         setIsLoading(true);
         setError(null);
-        oxyServices.karma.getKarmaLeaderboard()
+        oxyServices.getKarmaLeaderboard()
             .then((data: any) => setLeaderboard(Array.isArray(data) ? data : []))
             .catch((err: any) => setError(err.message || 'Failed to load leaderboard'))
             .finally(() => setIsLoading(false));

package/src/ui/screens/karma/KarmaRulesScreen.tsx

@@ -18,7 +18,7 @@ const KarmaRulesScreen: React.FC<BaseScreenProps> = ({ goBack, theme }) => {
     useEffect(() => {
         setIsLoading(true);
         setError(null);
-        oxyServices.karma.getKarmaRules()
+        oxyServices.getKarmaRules()
             .then((data: any) => setRules(Array.isArray(data) ? data : []))
             .catch((err: any) => setError(err.message || 'Failed to load rules'))
             .finally(() => setIsLoading(false));

package/src/ui/stores/followStore.ts

@@ -53,7 +53,7 @@ export const useFollowStore = create<FollowState>((set: any, get: any) => ({
       errors: { ...state.errors, [userId]: null },
     }));
     try {
-      const response = await oxyServices.users.getFollowStatus(userId);
+      const response = await oxyServices.getFollowStatus(userId);
       set((state: FollowState) => ({
         followingUsers: { ...state.followingUsers, [userId]: response.isFollowing },
         fetchingUsers: { ...state.fetchingUsers, [userId]: false },
@@ -75,10 +75,10 @@ export const useFollowStore = create<FollowState>((set: any, get: any) => ({
       let response: any;
       let newFollowState;
       if (isCurrentlyFollowing) {
-        response = await oxyServices.users.unfollowUser(userId);
+        response = await oxyServices.unfollowUser(userId);
         newFollowState = false;
       } else {
-        response = await oxyServices.users.followUser(userId);
+        response = await oxyServices.followUser(userId);
         newFollowState = true;
       }
       
@@ -158,7 +158,7 @@ export const useFollowStore = create<FollowState>((set: any, get: any) => ({
       loadingCounts: { ...state.loadingCounts, [userId]: true },
     }));
     try {
-      const user = await oxyServices.users.getUserById(userId);
+      const user = await oxyServices.getUserById(userId);
       if (user && user._count) {
         set((state: FollowState) => ({
           followerCounts: { 

package/src/utils/s3FileManager.ts

@@ -0,0 +1,281 @@
+import { S3Client, PutObjectCommand, GetObjectCommand, DeleteObjectCommand, ListObjectsV2Command } from '@aws-sdk/client-s3';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+
+export interface S3Config {
+  region: string;
+  accessKeyId: string;
+  secretAccessKey: string;
+  bucketName: string;
+}
+
+export interface UploadOptions {
+  contentType?: string;
+  metadata?: Record<string, string>;
+  publicRead?: boolean;
+}
+
+export interface FileInfo {
+  key: string;
+  size: number;
+  lastModified: Date;
+  contentType?: string;
+  metadata?: Record<string, string>;
+}
+
+export class S3FileManager {
+  private s3Client: S3Client;
+  private bucketName: string;
+
+  constructor(config: S3Config) {
+    this.s3Client = new S3Client({
+      region: config.region,
+      credentials: {
+        accessKeyId: config.accessKeyId,
+        secretAccessKey: config.secretAccessKey,
+      },
+    });
+    this.bucketName = config.bucketName;
+  }
+
+  /**
+   * Upload a file to S3
+   */
+  async uploadFile(
+    key: string,
+    file: File | Buffer | string,
+    options: UploadOptions = {}
+  ): Promise<string> {
+    let body: Buffer | string;
+    let contentType = options.contentType;
+
+    if (file instanceof File) {
+      body = await this.fileToBuffer(file);
+      contentType = contentType || file.type;
+    } else if (typeof file === 'string') {
+      body = file;
+      contentType = contentType || 'text/plain';
+    } else {
+      body = file;
+      contentType = contentType || 'application/octet-stream';
+    }
+
+    const command = new PutObjectCommand({
+      Bucket: this.bucketName,
+      Key: key,
+      Body: body,
+      ContentType: contentType,
+      Metadata: options.metadata,
+      ACL: options.publicRead ? 'public-read' : 'private',
+    });
+
+    await this.s3Client.send(command);
+    return `https://${this.bucketName}.s3.amazonaws.com/${key}`;
+  }
+
+  /**
+   * Download a file from S3
+   */
+  async downloadFile(key: string): Promise<Buffer> {
+    const command = new GetObjectCommand({
+      Bucket: this.bucketName,
+      Key: key,
+    });
+
+    const response = await this.s3Client.send(command);
+    
+    if (!response.Body) {
+      throw new Error('File not found or empty');
+    }
+
+    // Convert stream to buffer
+    const chunks: Uint8Array[] = [];
+    const reader = response.Body.transformToWebStream().getReader();
+    
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      chunks.push(value);
+    }
+
+    return Buffer.concat(chunks);
+  }
+
+  /**
+   * Delete a file from S3
+   */
+  async deleteFile(key: string): Promise<void> {
+    const command = new DeleteObjectCommand({
+      Bucket: this.bucketName,
+      Key: key,
+    });
+
+    await this.s3Client.send(command);
+  }
+
+  /**
+   * Generate a presigned URL for file upload
+   */
+  async getPresignedUploadUrl(
+    key: string,
+    contentType: string,
+    expiresIn: number = 3600
+  ): Promise<string> {
+    const command = new PutObjectCommand({
+      Bucket: this.bucketName,
+      Key: key,
+      ContentType: contentType,
+    });
+
+    return getSignedUrl(this.s3Client, command, { expiresIn });
+  }
+
+  /**
+   * Generate a presigned URL for file download
+   */
+  async getPresignedDownloadUrl(
+    key: string,
+    expiresIn: number = 3600
+  ): Promise<string> {
+    const command = new GetObjectCommand({
+      Bucket: this.bucketName,
+      Key: key,
+    });
+
+    return getSignedUrl(this.s3Client, command, { expiresIn });
+  }
+
+  /**
+   * List files in a directory
+   */
+  async listFiles(prefix: string = '', maxKeys: number = 1000): Promise<FileInfo[]> {
+    const command = new ListObjectsV2Command({
+      Bucket: this.bucketName,
+      Prefix: prefix,
+      MaxKeys: maxKeys,
+    });
+
+    const response = await this.s3Client.send(command);
+    
+    if (!response.Contents) {
+      return [];
+    }
+
+    return response.Contents.map((item) => ({
+      key: item.Key!,
+      size: item.Size || 0,
+      lastModified: item.LastModified!,
+    }));
+  }
+
+  /**
+   * Check if a file exists
+   */
+  async fileExists(key: string): Promise<boolean> {
+    try {
+      const command = new GetObjectCommand({
+        Bucket: this.bucketName,
+        Key: key,
+      });
+
+      await this.s3Client.send(command);
+      return true;
+    } catch (error: any) {
+      if (error.name === 'NoSuchKey') {
+        return false;
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Get file metadata
+   */
+  async getFileMetadata(key: string): Promise<FileInfo | null> {
+    try {
+      const command = new GetObjectCommand({
+        Bucket: this.bucketName,
+        Key: key,
+      });
+
+      const response = await this.s3Client.send(command);
+      
+      return {
+        key,
+        size: parseInt(response.ContentLength?.toString() || '0'),
+        lastModified: response.LastModified!,
+        contentType: response.ContentType,
+        metadata: response.Metadata,
+      };
+    } catch (error: any) {
+      if (error.name === 'NoSuchKey') {
+        return null;
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Convert File object to Buffer (for React Native compatibility)
+   */
+  private async fileToBuffer(file: File): Promise<Buffer> {
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onload = () => {
+        if (reader.result instanceof ArrayBuffer) {
+          resolve(Buffer.from(reader.result));
+        } else {
+          reject(new Error('Failed to read file'));
+        }
+      };
+      reader.onerror = () => reject(reader.error);
+      reader.readAsArrayBuffer(file);
+    });
+  }
+
+  /**
+   * Upload multiple files
+   */
+  async uploadMultipleFiles(
+    files: Array<{ key: string; file: File | Buffer | string; options?: UploadOptions }>
+  ): Promise<string[]> {
+    const uploadPromises = files.map(({ key, file, options }) =>
+      this.uploadFile(key, file, options)
+    );
+
+    return Promise.all(uploadPromises);
+  }
+
+  /**
+   * Delete multiple files
+   */
+  async deleteMultipleFiles(keys: string[]): Promise<void> {
+    const deletePromises = keys.map(key => this.deleteFile(key));
+    await Promise.all(deletePromises);
+  }
+
+  /**
+   * Copy file from one key to another
+   */
+  async copyFile(sourceKey: string, destinationKey: string): Promise<void> {
+    const command = new PutObjectCommand({
+      Bucket: this.bucketName,
+      Key: destinationKey,
+      Body: await this.downloadFile(sourceKey),
+    });
+
+    await this.s3Client.send(command);
+  }
+
+  /**
+   * Move file (copy + delete)
+   */
+  async moveFile(sourceKey: string, destinationKey: string): Promise<void> {
+    await this.copyFile(sourceKey, destinationKey);
+    await this.deleteFile(sourceKey);
+  }
+}
+
+// Export a factory function for easier configuration
+export function createS3FileManager(config: S3Config): S3FileManager {
+  return new S3FileManager(config);
+}