@pelatform/storage 1.0.0

package/dist/s3.js

@@ -0,0 +1,799 @@
+import {
+  buildPublicUrl,
+  getMimeType
+} from "./chunk-KJMGBTTL.js";
+import {
+  loadS3Config
+} from "./chunk-ZTZZCC52.js";
+
+// src/providers/s3.ts
+import { S3Client } from "@aws-sdk/client-s3";
+
+// src/operations/file-operations.ts
+import {
+  CopyObjectCommand,
+  DeleteObjectCommand,
+  DeleteObjectsCommand,
+  GetObjectCommand,
+  HeadObjectCommand,
+  ListObjectsV2Command,
+  PutObjectCommand
+} from "@aws-sdk/client-s3";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+var FileOperations = class {
+  constructor(client, config) {
+    this.client = client;
+    this.config = config;
+  }
+  async upload(options) {
+    try {
+      const contentType = options.contentType || getMimeType(options.key);
+      const command = new PutObjectCommand({
+        Bucket: this.config.bucket,
+        Key: options.key,
+        Body: options.file,
+        ContentType: contentType,
+        Metadata: options.metadata,
+        CacheControl: options.cacheControl,
+        ContentDisposition: options.contentDisposition,
+        ACL: options.acl,
+        Expires: options.expires
+      });
+      const result = await this.client.send(command);
+      const publicUrl = this.getPublicUrl(options.key);
+      return {
+        success: true,
+        key: options.key,
+        url: publicUrl,
+        publicUrl,
+        etag: result.ETag?.replace(/"/g, ""),
+        size: typeof options.file === "string" ? Buffer.byteLength(options.file, "utf8") : options.file.length
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Upload failed"
+      };
+    }
+  }
+  async download(options) {
+    try {
+      const command = new GetObjectCommand({
+        Bucket: this.config.bucket,
+        Key: options.key,
+        Range: options.range
+      });
+      const result = await this.client.send(command);
+      if (!result.Body) {
+        return {
+          success: false,
+          error: "No data received"
+        };
+      }
+      const chunks = [];
+      const reader = result.Body.transformToWebStream().getReader();
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        chunks.push(value);
+      }
+      const data = Buffer.concat(chunks);
+      return {
+        success: true,
+        content: data,
+        // Main content field
+        data,
+        // Alias for backward compatibility
+        contentType: result.ContentType,
+        contentLength: result.ContentLength,
+        lastModified: result.LastModified,
+        etag: result.ETag?.replace(/"/g, ""),
+        metadata: result.Metadata
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Download failed"
+      };
+    }
+  }
+  async delete(options) {
+    try {
+      const command = new DeleteObjectCommand({
+        Bucket: this.config.bucket,
+        Key: options.key
+      });
+      await this.client.send(command);
+      return {
+        success: true
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Delete failed"
+      };
+    }
+  }
+  async batchDelete(options) {
+    try {
+      const command = new DeleteObjectsCommand({
+        Bucket: this.config.bucket,
+        Delete: {
+          Objects: options.keys.map((key) => ({ Key: key })),
+          Quiet: false
+        }
+      });
+      const result = await this.client.send(command);
+      const deleted = result.Deleted?.map((obj) => obj.Key).filter(Boolean);
+      const errors = result.Errors?.map((err) => ({
+        key: err.Key || "",
+        error: err.Message || "Unknown error"
+      })) || [];
+      return {
+        success: true,
+        deleted,
+        errors: errors.length > 0 ? errors : void 0
+      };
+    } catch (error) {
+      return {
+        success: false,
+        errors: options.keys.map((key) => ({
+          key,
+          error: error instanceof Error ? error.message : "Batch delete failed"
+        }))
+      };
+    }
+  }
+  async list(options = {}) {
+    try {
+      const command = new ListObjectsV2Command({
+        Bucket: this.config.bucket,
+        Prefix: options.prefix,
+        Delimiter: options.delimiter,
+        MaxKeys: options.maxKeys,
+        ContinuationToken: options.continuationToken
+      });
+      const result = await this.client.send(command);
+      const files = result.Contents?.map((obj) => ({
+        key: obj.Key,
+        size: obj.Size || 0,
+        lastModified: obj.LastModified || /* @__PURE__ */ new Date(),
+        etag: obj.ETag?.replace(/"/g, "") || "",
+        contentType: getMimeType(obj.Key)
+      })) || [];
+      return {
+        success: true,
+        files,
+        isTruncated: result.IsTruncated,
+        nextContinuationToken: result.NextContinuationToken,
+        commonPrefixes: result.CommonPrefixes?.map((cp) => cp.Prefix)
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "List failed"
+      };
+    }
+  }
+  async exists(key) {
+    try {
+      const command = new HeadObjectCommand({
+        Bucket: this.config.bucket,
+        Key: key
+      });
+      const result = await this.client.send(command);
+      return {
+        exists: true,
+        fileInfo: {
+          key,
+          size: result.ContentLength || 0,
+          lastModified: result.LastModified || /* @__PURE__ */ new Date(),
+          etag: result.ETag?.replace(/"/g, "") || "",
+          contentType: result.ContentType,
+          metadata: result.Metadata
+        }
+      };
+    } catch (error) {
+      if (error instanceof Error && error.name === "NotFound") {
+        return { exists: false };
+      }
+      return {
+        exists: false,
+        error: error instanceof Error ? error.message : "Check existence failed"
+      };
+    }
+  }
+  async copy(options) {
+    try {
+      const command = new CopyObjectCommand({
+        Bucket: this.config.bucket,
+        CopySource: `${this.config.bucket}/${options.sourceKey}`,
+        Key: options.destinationKey,
+        Metadata: options.metadata,
+        MetadataDirective: options.metadataDirective || "COPY"
+      });
+      const result = await this.client.send(command);
+      return {
+        success: true,
+        etag: result.CopyObjectResult?.ETag?.replace(/"/g, "")
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Copy failed"
+      };
+    }
+  }
+  async move(options) {
+    try {
+      const copyResult = await this.copy({
+        sourceKey: options.sourceKey,
+        destinationKey: options.destinationKey,
+        metadata: options.metadata,
+        metadataDirective: options.metadataDirective
+      });
+      if (!copyResult.success) {
+        return {
+          success: false,
+          error: copyResult.error || "Move failed during copy operation"
+        };
+      }
+      const deleteResult = await this.delete({ key: options.sourceKey });
+      if (!deleteResult.success) {
+        return {
+          success: false,
+          error: deleteResult.error || "Move failed during delete operation"
+        };
+      }
+      return {
+        success: true,
+        etag: copyResult.etag
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Move failed"
+      };
+    }
+  }
+  async duplicate(options) {
+    return this.copy(options);
+  }
+  async getPresignedUrl(options) {
+    try {
+      const expiresIn = options.expiresIn || 3600;
+      let command;
+      if (options.operation === "get") {
+        command = new GetObjectCommand({
+          Bucket: this.config.bucket,
+          Key: options.key
+        });
+      } else {
+        command = new PutObjectCommand({
+          Bucket: this.config.bucket,
+          Key: options.key,
+          ContentType: options.contentType
+        });
+      }
+      const url = await getSignedUrl(this.client, command, {
+        expiresIn
+      });
+      return {
+        success: true,
+        url,
+        expiresAt: new Date(Date.now() + expiresIn * 1e3)
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Presigned URL generation failed"
+      };
+    }
+  }
+  getPublicUrl(key) {
+    if (this.config.publicUrl) {
+      return buildPublicUrl(this.config.publicUrl, this.config.bucket, key);
+    }
+    if (this.config.endpoint) {
+      return buildPublicUrl(this.config.endpoint, this.config.bucket, key);
+    }
+    return `https://${this.config.bucket}.s3.${this.config.region}.amazonaws.com/${key}`;
+  }
+};
+
+// src/operations/folder-operations.ts
+import {
+  CopyObjectCommand as CopyObjectCommand2,
+  DeleteObjectsCommand as DeleteObjectsCommand2,
+  ListObjectsV2Command as ListObjectsV2Command2,
+  PutObjectCommand as PutObjectCommand2
+} from "@aws-sdk/client-s3";
+var FolderOperations = class {
+  constructor(client, config) {
+    this.client = client;
+    this.config = config;
+  }
+  async createFolder(options) {
+    try {
+      const folderPath = options.path.endsWith("/") ? options.path : `${options.path}/`;
+      const command = new PutObjectCommand2({
+        Bucket: this.config.bucket,
+        Key: folderPath,
+        Body: "",
+        ContentType: "application/x-directory"
+      });
+      await this.client.send(command);
+      return {
+        success: true,
+        path: folderPath
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Create folder failed"
+      };
+    }
+  }
+  async deleteFolder(options) {
+    try {
+      const folderPath = options.path.endsWith("/") ? options.path : `${options.path}/`;
+      if (options.recursive) {
+        const listCommand = new ListObjectsV2Command2({
+          Bucket: this.config.bucket,
+          Prefix: folderPath
+        });
+        const listResult = await this.client.send(listCommand);
+        if (!listResult.Contents || listResult.Contents.length === 0) {
+          return {
+            success: true,
+            deletedFiles: []
+          };
+        }
+        const deleteCommand = new DeleteObjectsCommand2({
+          Bucket: this.config.bucket,
+          Delete: {
+            Objects: listResult.Contents.map((obj) => ({ Key: obj.Key })),
+            Quiet: false
+          }
+        });
+        const deleteResult = await this.client.send(deleteCommand);
+        const deletedFiles = deleteResult.Deleted?.map((obj) => obj.Key).filter(Boolean) || [];
+        return {
+          success: true,
+          deletedFiles
+        };
+      } else {
+        const deleteCommand = new DeleteObjectsCommand2({
+          Bucket: this.config.bucket,
+          Delete: {
+            Objects: [{ Key: folderPath }],
+            Quiet: false
+          }
+        });
+        await this.client.send(deleteCommand);
+        return {
+          success: true,
+          deletedFiles: [folderPath]
+        };
+      }
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Delete folder failed"
+      };
+    }
+  }
+  async listFolders(options = {}) {
+    try {
+      const command = new ListObjectsV2Command2({
+        Bucket: this.config.bucket,
+        Prefix: options.prefix,
+        Delimiter: options.delimiter || "/",
+        MaxKeys: options.maxKeys,
+        ContinuationToken: options.continuationToken
+      });
+      const result = await this.client.send(command);
+      const folders = result.CommonPrefixes?.map((cp) => {
+        const path = cp.Prefix;
+        const name = path.split("/").filter(Boolean).pop() || "";
+        return {
+          name,
+          path,
+          size: 0,
+          // Will be calculated separately if needed
+          fileCount: 0,
+          // Will be calculated separately if needed
+          lastModified: /* @__PURE__ */ new Date()
+        };
+      }) || [];
+      const files = result.Contents?.map((obj) => ({
+        key: obj.Key,
+        size: obj.Size || 0,
+        lastModified: obj.LastModified || /* @__PURE__ */ new Date(),
+        etag: obj.ETag?.replace(/"/g, "") || "",
+        contentType: getMimeType(obj.Key)
+      })) || [];
+      return {
+        success: true,
+        folders,
+        files,
+        isTruncated: result.IsTruncated,
+        nextContinuationToken: result.NextContinuationToken
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "List folders failed"
+      };
+    }
+  }
+  async folderExists(path) {
+    try {
+      const folderPath = path.endsWith("/") ? path : `${path}/`;
+      const command = new ListObjectsV2Command2({
+        Bucket: this.config.bucket,
+        Prefix: folderPath,
+        MaxKeys: 1
+      });
+      const result = await this.client.send(command);
+      const exists = result.Contents && result.Contents.length > 0 || result.CommonPrefixes && result.CommonPrefixes.length > 0;
+      if (exists) {
+        const name = folderPath.split("/").filter(Boolean).pop() || "";
+        return {
+          exists: true,
+          folderInfo: {
+            name,
+            path: folderPath,
+            size: 0,
+            fileCount: 0,
+            lastModified: /* @__PURE__ */ new Date()
+          }
+        };
+      }
+      return { exists: false };
+    } catch (error) {
+      return {
+        exists: false,
+        error: error instanceof Error ? error.message : "Check folder existence failed"
+      };
+    }
+  }
+  async renameFolder(options) {
+    try {
+      const oldPath = options.oldPath.endsWith("/") ? options.oldPath : `${options.oldPath}/`;
+      const newPath = options.newPath.endsWith("/") ? options.newPath : `${options.newPath}/`;
+      const listCommand = new ListObjectsV2Command2({
+        Bucket: this.config.bucket,
+        Prefix: oldPath
+      });
+      const listResult = await this.client.send(listCommand);
+      if (!listResult.Contents || listResult.Contents.length === 0) {
+        return {
+          success: true,
+          movedFiles: []
+        };
+      }
+      const movedFiles = [];
+      for (const obj of listResult.Contents) {
+        const oldKey = obj.Key;
+        const newKey = oldKey.replace(oldPath, newPath);
+        const copyCommand = new CopyObjectCommand2({
+          Bucket: this.config.bucket,
+          Key: newKey,
+          CopySource: `${this.config.bucket}/${oldKey}`
+        });
+        await this.client.send(copyCommand);
+        movedFiles.push(newKey);
+      }
+      const deleteCommand = new DeleteObjectsCommand2({
+        Bucket: this.config.bucket,
+        Delete: {
+          Objects: listResult.Contents.map((obj) => ({ Key: obj.Key })),
+          Quiet: true
+        }
+      });
+      await this.client.send(deleteCommand);
+      return {
+        success: true,
+        movedFiles
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Rename folder failed"
+      };
+    }
+  }
+  async copyFolder(options) {
+    try {
+      const sourcePath = options.sourcePath.endsWith("/") ? options.sourcePath : `${options.sourcePath}/`;
+      const destPath = options.destinationPath.endsWith("/") ? options.destinationPath : `${options.destinationPath}/`;
+      const listCommand = new ListObjectsV2Command2({
+        Bucket: this.config.bucket,
+        Prefix: sourcePath
+      });
+      const listResult = await this.client.send(listCommand);
+      if (!listResult.Contents || listResult.Contents.length === 0) {
+        return {
+          success: true,
+          copiedFiles: []
+        };
+      }
+      const copiedFiles = [];
+      for (const obj of listResult.Contents) {
+        const sourceKey = obj.Key;
+        const destKey = sourceKey.replace(sourcePath, destPath);
+        const copyCommand = new CopyObjectCommand2({
+          Bucket: this.config.bucket,
+          Key: destKey,
+          CopySource: `${this.config.bucket}/${sourceKey}`
+        });
+        await this.client.send(copyCommand);
+        copiedFiles.push(destKey);
+      }
+      return {
+        success: true,
+        copiedFiles
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Copy folder failed"
+      };
+    }
+  }
+};
+
+// src/providers/s3.ts
+var S3Provider = class {
+  client;
+  config;
+  fileOps;
+  folderOps;
+  constructor(config) {
+    this.config = config;
+    this.client = new S3Client({
+      region: config.region,
+      credentials: {
+        accessKeyId: config.accessKeyId,
+        secretAccessKey: config.secretAccessKey
+      },
+      endpoint: config.endpoint,
+      forcePathStyle: config.forcePathStyle || false
+    });
+    this.fileOps = new FileOperations(this.client, this.config);
+    this.folderOps = new FolderOperations(this.client, this.config);
+  }
+  // File operations
+  async upload(options) {
+    return this.fileOps.upload(options);
+  }
+  async download(options) {
+    return this.fileOps.download(options);
+  }
+  async delete(options) {
+    return this.fileOps.delete(options);
+  }
+  async batchDelete(options) {
+    return this.fileOps.batchDelete(options);
+  }
+  async list(options) {
+    return this.fileOps.list(options);
+  }
+  async exists(key) {
+    return this.fileOps.exists(key);
+  }
+  async copy(options) {
+    return this.fileOps.copy(options);
+  }
+  async move(options) {
+    return this.fileOps.move(options);
+  }
+  async duplicate(options) {
+    return this.fileOps.duplicate(options);
+  }
+  async getPresignedUrl(options) {
+    return this.fileOps.getPresignedUrl(options);
+  }
+  getPublicUrl(key) {
+    return this.fileOps.getPublicUrl(key);
+  }
+  // Folder operations
+  async createFolder(options) {
+    return this.folderOps.createFolder(options);
+  }
+  async deleteFolder(options) {
+    return this.folderOps.deleteFolder(options);
+  }
+  async listFolders(options) {
+    return this.folderOps.listFolders(options);
+  }
+  async folderExists(path) {
+    return this.folderOps.folderExists(path);
+  }
+  async renameFolder(options) {
+    return this.folderOps.renameFolder(options);
+  }
+  async copyFolder(options) {
+    return this.folderOps.copyFolder(options);
+  }
+};
+
+// src/services/s3.ts
+var S3Service = class {
+  provider;
+  config;
+  constructor(config) {
+    this.config = config || loadS3Config();
+    this.provider = this.createProvider(this.config);
+  }
+  createProvider(config) {
+    switch (config.provider) {
+      case "aws":
+      case "cloudflare-r2":
+      case "minio":
+      case "digitalocean":
+      case "supabase":
+      case "custom":
+        return new S3Provider(config);
+      default:
+        throw new Error(`Unsupported S3 provider: ${config.provider}`);
+    }
+  }
+  // Utility methods
+  getConfig() {
+    return { ...this.config };
+  }
+  getBucket() {
+    return this.config.bucket;
+  }
+  getRegion() {
+    return this.config.region;
+  }
+  getProvider() {
+    return this.config.provider;
+  }
+  getPublicUrl(key) {
+    return this.provider.getPublicUrl(key);
+  }
+  // File operations
+  async upload(options) {
+    return this.provider.upload(options);
+  }
+  async download(options) {
+    return this.provider.download(options);
+  }
+  async delete(options) {
+    return this.provider.delete(options);
+  }
+  async batchDelete(options) {
+    return this.provider.batchDelete(options);
+  }
+  async list(options) {
+    return this.provider.list(options);
+  }
+  async exists(key) {
+    return this.provider.exists(key);
+  }
+  async copy(options) {
+    return this.provider.copy(options);
+  }
+  async move(options) {
+    return this.provider.move(options);
+  }
+  async duplicate(options) {
+    return this.provider.duplicate(options);
+  }
+  async getPresignedUrl(options) {
+    return this.provider.getPresignedUrl(options);
+  }
+  // Folder operations
+  async createFolder(options) {
+    return this.provider.createFolder(options);
+  }
+  async deleteFolder(options) {
+    return this.provider.deleteFolder(options);
+  }
+  async listFolders(options) {
+    return this.provider.listFolders(options);
+  }
+  async folderExists(path) {
+    return this.provider.folderExists(path);
+  }
+  async renameFolder(options) {
+    return this.provider.renameFolder(options);
+  }
+  async copyFolder(options) {
+    return this.provider.copyFolder(options);
+  }
+  // Convenience methods
+  async uploadFile(key, file, options) {
+    return this.upload({
+      key,
+      file,
+      ...options
+    });
+  }
+  async downloadFile(key) {
+    return this.download({ key });
+  }
+  async deleteFile(key) {
+    return this.delete({ key });
+  }
+  async deleteFiles(keys) {
+    return this.batchDelete({ keys });
+  }
+  async fileExists(key) {
+    const result = await this.exists(key);
+    return result.exists;
+  }
+  async copyFile(sourceKey, destinationKey, options) {
+    return this.copy({
+      sourceKey,
+      destinationKey,
+      ...options
+    });
+  }
+  async moveFile(sourceKey, destinationKey, options) {
+    return this.move({
+      sourceKey,
+      destinationKey,
+      ...options
+    });
+  }
+  async duplicateFile(sourceKey, destinationKey, options) {
+    return this.duplicate({
+      sourceKey,
+      destinationKey,
+      ...options
+    });
+  }
+  async renameFile(sourceKey, newKey, options) {
+    return this.moveFile(sourceKey, newKey, options);
+  }
+  async getDownloadUrl(key, expiresIn) {
+    return this.getPresignedUrl({
+      key,
+      operation: "get",
+      expiresIn
+    });
+  }
+  async getUploadUrl(key, contentType, expiresIn) {
+    return this.getPresignedUrl({
+      key,
+      operation: "put",
+      contentType,
+      expiresIn
+    });
+  }
+  // Folder convenience methods
+  async createFolderPath(path) {
+    return this.createFolder({ path });
+  }
+  async deleteFolderPath(path, recursive = false) {
+    return this.deleteFolder({ path, recursive });
+  }
+  async folderPathExists(path) {
+    const result = await this.folderExists(path);
+    return result.exists;
+  }
+  async renameFolderPath(oldPath, newPath) {
+    return this.renameFolder({ oldPath, newPath });
+  }
+  async copyFolderPath(sourcePath, destinationPath, recursive = true) {
+    return this.copyFolder({ sourcePath, destinationPath, recursive });
+  }
+};
+
+// src/s3.ts
+function createS3(config) {
+  if (config) {
+    return new S3Service(config);
+  }
+  const envConfig = loadS3Config();
+  return new S3Service(envConfig);
+}
+export {
+  S3Service,
+  createS3
+};