@oxyhq/services 5.10.5 → 5.10.6

package/src/utils/s3FileManagerRN.ts

@@ -0,0 +1,322 @@
+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 interface RNFile {
+  uri: string;
+  name: string;
+  type?: string;
+  size?: number;
+}
+
+export class S3FileManagerRN {
+  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 from React Native
+   */
+  async uploadFile(
+    key: string,
+    file: RNFile | Buffer | string,
+    options: UploadOptions = {}
+  ): Promise<string> {
+    let body: Buffer | string;
+    let contentType = options.contentType;
+
+    if (this.isRNFile(file)) {
+      body = await this.rnFileToBuffer(file);
+      contentType = contentType || file.type || 'application/octet-stream';
+    } 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 to React Native
+   */
+  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 React Native file to Buffer
+   */
+  private async rnFileToBuffer(file: RNFile): Promise<Buffer> {
+    try {
+      // For React Native, we need to fetch the file from the URI
+      const response = await fetch(file.uri);
+      const arrayBuffer = await response.arrayBuffer();
+      return Buffer.from(arrayBuffer);
+    } catch (error) {
+      throw new Error(`Failed to read React Native file: ${error}`);
+    }
+  }
+
+  /**
+   * Type guard to check if object is RNFile
+   */
+  private isRNFile(file: any): file is RNFile {
+    return file && typeof file === 'object' && 'uri' in file && 'name' in file;
+  }
+
+  /**
+   * Upload multiple files
+   */
+  async uploadMultipleFiles(
+    files: Array<{ key: string; file: RNFile | 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);
+  }
+
+  /**
+   * Upload image with automatic resizing (placeholder for future implementation)
+   */
+  async uploadImage(
+    key: string,
+    file: RNFile,
+    options: UploadOptions & { resize?: { width?: number; height?: number } } = {}
+  ): Promise<string> {
+    // For now, just upload as regular file
+    // In the future, this could integrate with image processing libraries
+    return this.uploadFile(key, file, options);
+  }
+
+  /**
+   * Get file size from React Native file
+   */
+  async getFileSize(file: RNFile): Promise<number> {
+    if (file.size) {
+      return file.size;
+    }
+
+    try {
+      const response = await fetch(file.uri, { method: 'HEAD' });
+      const contentLength = response.headers.get('content-length');
+      return contentLength ? parseInt(contentLength, 10) : 0;
+    } catch (error) {
+      console.warn('Could not determine file size:', error);
+      return 0;
+    }
+  }
+}
+
+// Export a factory function for easier configuration
+export function createS3FileManagerRN(config: S3Config): S3FileManagerRN {
+  return new S3FileManagerRN(config);
+}