AWS S3

// AWS S3 JavaScript Integration
const AWS = require('aws-sdk');

class S3Service {
  constructor(accessKeyId, secretAccessKey, region = 'us-east-1') {
    // Configure AWS
    AWS.config.update({
      accessKeyId: accessKeyId,
      secretAccessKey: secretAccessKey,
      region: region
    });
    
    this.s3 = new AWS.S3();
    this.region = region;
  }

  // Upload file to S3
  async uploadFile(bucketName, key, fileData, options = {}) {
    try {
      const params = {
        Bucket: bucketName,
        Key: key,
        Body: fileData,
        ContentType: options.contentType || 'application/octet-stream',
        ...options
      };

      const result = await this.s3.upload(params).promise();
      
      return {
        success: true,
        location: result.Location,
        etag: result.ETag,
        key: result.Key
      };
    } catch (error) {
      console.error('S3 Upload Error:', error);
      return {
        success: false,
        error: error.message
      };
    }
  }

  // Download file from S3
  async downloadFile(bucketName, key) {
    try {
      const params = {
        Bucket: bucketName,
        Key: key
      };

      const result = await this.s3.getObject(params).promise();
      
      return {
        success: true,
        data: result.Body,
        contentType: result.ContentType,
        lastModified: result.LastModified,
        etag: result.ETag
      };
    } catch (error) {
      console.error('S3 Download Error:', error);
      return {
        success: false,
        error: error.message
      };
    }
  }

  // Generate presigned URL for upload
  getPresignedUploadUrl(bucketName, key, expiresIn = 300, contentType = null) {
    try {
      const params = {
        Bucket: bucketName,
        Key: key,
        Expires: expiresIn
      };

      if (contentType) {
        params.ContentType = contentType;
      }

      const url = this.s3.getSignedUrl('putObject', params);
      
      return {
        success: true,
        url: url,
        expiresIn: expiresIn
      };
    } catch (error) {
      console.error('Presigned URL Error:', error);
      return {
        success: false,
        error: error.message
      };
    }
  }

  // Generate presigned URL for download
  getPresignedDownloadUrl(bucketName, key, expiresIn = 300) {
    try {
      const params = {
        Bucket: bucketName,
        Key: key,
        Expires: expiresIn
      };

      const url = this.s3.getSignedUrl('getObject', params);
      
      return {
        success: true,
        url: url,
        expiresIn: expiresIn
      };
    } catch (error) {
      console.error('Presigned URL Error:', error);
      return {
        success: false,
        error: error.message
      };
    }
  }

  // List objects in bucket
  async listObjects(bucketName, prefix = '', maxKeys = 1000) {
    try {
      const params = {
        Bucket: bucketName,
        Prefix: prefix,
        MaxKeys: maxKeys
      };

      const result = await this.s3.listObjectsV2(params).promise();
      
      return {
        success: true,
        objects: result.Contents.map(obj => ({
          key: obj.Key,
          size: obj.Size,
          lastModified: obj.LastModified,
          etag: obj.ETag
        })),
        totalCount: result.KeyCount,
        isTruncated: result.IsTruncated,
        nextContinuationToken: result.NextContinuationToken
      };
    } catch (error) {
      console.error('S3 List Error:', error);
      return {
        success: false,
        error: error.message
      };
    }
  }

  // Delete object from S3
  async deleteFile(bucketName, key) {
    try {
      const params = {
        Bucket: bucketName,
        Key: key
      };

      await this.s3.deleteObject(params).promise();
      
      return {
        success: true,
        message: 'Object deleted successfully'
      };
    } catch (error) {
      console.error('S3 Delete Error:', error);
      return {
        success: false,
        error: error.message
      };
    }
  }

  // Delete multiple objects
  async deleteFiles(bucketName, keys) {
    try {
      const params = {
        Bucket: bucketName,
        Delete: {
          Objects: keys.map(key => ({ Key: key })),
          Quiet: false
        }
      };

      const result = await this.s3.deleteObjects(params).promise();
      
      return {
        success: true,
        deleted: result.Deleted,
        errors: result.Errors
      };
    } catch (error) {
      console.error('S3 Bulk Delete Error:', error);
      return {
        success: false,
        error: error.message
      };
    }
  }

  // Copy object within S3
  async copyFile(sourceBucket, sourceKey, destBucket, destKey) {
    try {
      const params = {
        CopySource: `${sourceBucket}/${sourceKey}`,
        Bucket: destBucket,
        Key: destKey
      };

      const result = await this.s3.copyObject(params).promise();
      
      return {
        success: true,
        etag: result.ETag,
        lastModified: result.LastModified
      };
    } catch (error) {
      console.error('S3 Copy Error:', error);
      return {
        success: false,
        error: error.message
      };
    }
  }

  // Get object metadata
  async getObjectMetadata(bucketName, key) {
    try {
      const params = {
        Bucket: bucketName,
        Key: key
      };

      const result = await this.s3.headObject(params).promise();
      
      return {
        success: true,
        metadata: {
          contentType: result.ContentType,
          contentLength: result.ContentLength,
          lastModified: result.LastModified,
          etag: result.ETag,
          storageClass: result.StorageClass,
          metadata: result.Metadata
        }
      };
    } catch (error) {
      console.error('S3 Metadata Error:', error);
      return {
        success: false,
        error: error.message
      };
    }
  }

  // Create multipart upload
  async createMultipartUpload(bucketName, key, contentType) {
    try {
      const params = {
        Bucket: bucketName,
        Key: key,
        ContentType: contentType
      };

      const result = await this.s3.createMultipartUpload(params).promise();
      
      return {
        success: true,
        uploadId: result.UploadId
      };
    } catch (error) {
      console.error('Multipart Upload Creation Error:', error);
      return {
        success: false,
        error: error.message
      };
    }
  }
}

// Usage examples
const s3 = new S3Service(
  'your-access-key-id',
  'your-secret-access-key',
  'us-east-1'
);

// Upload a file
async function uploadExample() {
  const fileData = Buffer.from('Hello, S3!');
  const result = await s3.uploadFile('my-bucket', 'hello.txt', fileData, {
    contentType: 'text/plain'
  });
  
  if (result.success) {
    console.log('File uploaded:', result.location);
  } else {
    console.error('Upload failed:', result.error);
  }
}

// Generate presigned URL
async function presignedUrlExample() {
  const result = s3.getPresignedUploadUrl('my-bucket', 'upload.jpg', 300, 'image/jpeg');
  
  if (result.success) {
    console.log('Presigned URL:', result.url);
    // Use this URL to upload directly from browser
  }
}

// List objects
async function listExample() {
  const result = await s3.listObjects('my-bucket', 'uploads/');
  
  if (result.success) {
    console.log('Objects:', result.objects);
  }
}

uploadExample();