@pelatform/storage 1.0.0

package/dist/s3.cjs

@@ -0,0 +1,799 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+var _chunkGV7GMZP2cjs = require('./chunk-GV7GMZP2.cjs');
+
+
+var _chunkI3ME6WAGcjs = require('./chunk-I3ME6WAG.cjs');
+
+// src/providers/s3.ts
+var _clients3 = require('@aws-sdk/client-s3');
+
+// src/operations/file-operations.ts
+
+
+
+
+
+
+
+
+
+var _s3requestpresigner = require('@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 || _chunkGV7GMZP2cjs.getMimeType.call(void 0, options.key);
+      const command = new (0, _clients3.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: _optionalChain([result, 'access', _ => _.ETag, 'optionalAccess', _2 => _2.replace, 'call', _3 => _3(/"/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 (0, _clients3.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: _optionalChain([result, 'access', _4 => _4.ETag, 'optionalAccess', _5 => _5.replace, 'call', _6 => _6(/"/g, "")]),
+        metadata: result.Metadata
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Download failed"
+      };
+    }
+  }
+  async delete(options) {
+    try {
+      const command = new (0, _clients3.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 (0, _clients3.DeleteObjectsCommand)({
+        Bucket: this.config.bucket,
+        Delete: {
+          Objects: options.keys.map((key) => ({ Key: key })),
+          Quiet: false
+        }
+      });
+      const result = await this.client.send(command);
+      const deleted = _optionalChain([result, 'access', _7 => _7.Deleted, 'optionalAccess', _8 => _8.map, 'call', _9 => _9((obj) => obj.Key), 'access', _10 => _10.filter, 'call', _11 => _11(Boolean)]);
+      const errors = _optionalChain([result, 'access', _12 => _12.Errors, 'optionalAccess', _13 => _13.map, 'call', _14 => _14((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 (0, _clients3.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 = _optionalChain([result, 'access', _15 => _15.Contents, 'optionalAccess', _16 => _16.map, 'call', _17 => _17((obj) => ({
+        key: obj.Key,
+        size: obj.Size || 0,
+        lastModified: obj.LastModified || /* @__PURE__ */ new Date(),
+        etag: _optionalChain([obj, 'access', _18 => _18.ETag, 'optionalAccess', _19 => _19.replace, 'call', _20 => _20(/"/g, "")]) || "",
+        contentType: _chunkGV7GMZP2cjs.getMimeType.call(void 0, obj.Key)
+      }))]) || [];
+      return {
+        success: true,
+        files,
+        isTruncated: result.IsTruncated,
+        nextContinuationToken: result.NextContinuationToken,
+        commonPrefixes: _optionalChain([result, 'access', _21 => _21.CommonPrefixes, 'optionalAccess', _22 => _22.map, 'call', _23 => _23((cp) => cp.Prefix)])
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "List failed"
+      };
+    }
+  }
+  async exists(key) {
+    try {
+      const command = new (0, _clients3.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: _optionalChain([result, 'access', _24 => _24.ETag, 'optionalAccess', _25 => _25.replace, 'call', _26 => _26(/"/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 (0, _clients3.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: _optionalChain([result, 'access', _27 => _27.CopyObjectResult, 'optionalAccess', _28 => _28.ETag, 'optionalAccess', _29 => _29.replace, 'call', _30 => _30(/"/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 (0, _clients3.GetObjectCommand)({
+          Bucket: this.config.bucket,
+          Key: options.key
+        });
+      } else {
+        command = new (0, _clients3.PutObjectCommand)({
+          Bucket: this.config.bucket,
+          Key: options.key,
+          ContentType: options.contentType
+        });
+      }
+      const url = await _s3requestpresigner.getSignedUrl.call(void 0, 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 _chunkGV7GMZP2cjs.buildPublicUrl.call(void 0, this.config.publicUrl, this.config.bucket, key);
+    }
+    if (this.config.endpoint) {
+      return _chunkGV7GMZP2cjs.buildPublicUrl.call(void 0, this.config.endpoint, this.config.bucket, key);
+    }
+    return `https://${this.config.bucket}.s3.${this.config.region}.amazonaws.com/${key}`;
+  }
+};
+
+// src/operations/folder-operations.ts
+
+
+
+
+
+
+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 (0, _clients3.PutObjectCommand)({
+        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 (0, _clients3.ListObjectsV2Command)({
+          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 (0, _clients3.DeleteObjectsCommand)({
+          Bucket: this.config.bucket,
+          Delete: {
+            Objects: listResult.Contents.map((obj) => ({ Key: obj.Key })),
+            Quiet: false
+          }
+        });
+        const deleteResult = await this.client.send(deleteCommand);
+        const deletedFiles = _optionalChain([deleteResult, 'access', _31 => _31.Deleted, 'optionalAccess', _32 => _32.map, 'call', _33 => _33((obj) => obj.Key), 'access', _34 => _34.filter, 'call', _35 => _35(Boolean)]) || [];
+        return {
+          success: true,
+          deletedFiles
+        };
+      } else {
+        const deleteCommand = new (0, _clients3.DeleteObjectsCommand)({
+          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 (0, _clients3.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 folders = _optionalChain([result, 'access', _36 => _36.CommonPrefixes, 'optionalAccess', _37 => _37.map, 'call', _38 => _38((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 = _optionalChain([result, 'access', _39 => _39.Contents, 'optionalAccess', _40 => _40.map, 'call', _41 => _41((obj) => ({
+        key: obj.Key,
+        size: obj.Size || 0,
+        lastModified: obj.LastModified || /* @__PURE__ */ new Date(),
+        etag: _optionalChain([obj, 'access', _42 => _42.ETag, 'optionalAccess', _43 => _43.replace, 'call', _44 => _44(/"/g, "")]) || "",
+        contentType: _chunkGV7GMZP2cjs.getMimeType.call(void 0, 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 (0, _clients3.ListObjectsV2Command)({
+        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 (0, _clients3.ListObjectsV2Command)({
+        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 (0, _clients3.CopyObjectCommand)({
+          Bucket: this.config.bucket,
+          Key: newKey,
+          CopySource: `${this.config.bucket}/${oldKey}`
+        });
+        await this.client.send(copyCommand);
+        movedFiles.push(newKey);
+      }
+      const deleteCommand = new (0, _clients3.DeleteObjectsCommand)({
+        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 (0, _clients3.ListObjectsV2Command)({
+        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 (0, _clients3.CopyObjectCommand)({
+          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 {
+  
+  
+  
+  
+  constructor(config) {
+    this.config = config;
+    this.client = new (0, _clients3.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 {
+  
+  
+  constructor(config) {
+    this.config = config || _chunkI3ME6WAGcjs.loadS3Config.call(void 0, );
+    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 = _chunkI3ME6WAGcjs.loadS3Config.call(void 0, );
+  return new S3Service(envConfig);
+}
+
+
+
+exports.S3Service = S3Service; exports.createS3 = createS3;