@parsrun/storage 0.1.0

package/dist/adapters/r2.js

@@ -0,0 +1,818 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/types.ts
+import {
+  type,
+  fileMetadata,
+  uploadOptions,
+  signedUrlOptions,
+  listFilesOptions,
+  listFilesResult,
+  localStorageConfig,
+  s3StorageConfig,
+  r2StorageConfig,
+  gcsStorageConfig,
+  storageProviderConfig
+} from "@parsrun/types";
+var StorageError, StorageErrorCodes;
+var init_types = __esm({
+  "src/types.ts"() {
+    "use strict";
+    StorageError = class extends Error {
+      constructor(message, code, statusCode, cause) {
+        super(message);
+        this.code = code;
+        this.statusCode = statusCode;
+        this.cause = cause;
+        this.name = "StorageError";
+      }
+    };
+    StorageErrorCodes = {
+      NOT_FOUND: "NOT_FOUND",
+      ACCESS_DENIED: "ACCESS_DENIED",
+      BUCKET_NOT_FOUND: "BUCKET_NOT_FOUND",
+      INVALID_KEY: "INVALID_KEY",
+      UPLOAD_FAILED: "UPLOAD_FAILED",
+      DOWNLOAD_FAILED: "DOWNLOAD_FAILED",
+      DELETE_FAILED: "DELETE_FAILED",
+      COPY_FAILED: "COPY_FAILED",
+      LIST_FAILED: "LIST_FAILED",
+      PRESIGN_FAILED: "PRESIGN_FAILED",
+      QUOTA_EXCEEDED: "QUOTA_EXCEEDED",
+      INVALID_CONFIG: "INVALID_CONFIG",
+      ADAPTER_NOT_AVAILABLE: "ADAPTER_NOT_AVAILABLE"
+    };
+  }
+});
+
+// src/adapters/s3.ts
+var s3_exports = {};
+__export(s3_exports, {
+  S3Adapter: () => S3Adapter,
+  createDOSpacesAdapter: () => createDOSpacesAdapter,
+  createS3Adapter: () => createS3Adapter
+});
+function createS3Adapter(config) {
+  return new S3Adapter(config);
+}
+function createDOSpacesAdapter(config) {
+  return new S3Adapter({
+    ...config,
+    type: "do-spaces",
+    endpoint: `https://${config.region}.digitaloceanspaces.com`,
+    bucket: config.spaceName ?? config.bucket
+  });
+}
+var S3Adapter;
+var init_s3 = __esm({
+  "src/adapters/s3.ts"() {
+    "use strict";
+    init_types();
+    S3Adapter = class {
+      type;
+      bucket;
+      client = null;
+      config;
+      basePath;
+      constructor(config) {
+        this.type = config.type;
+        this.bucket = config.bucket;
+        this.config = config;
+        this.basePath = config.basePath ?? "";
+      }
+      /**
+       * Lazy load S3 client
+       */
+      async getClient() {
+        if (this.client) return this.client;
+        try {
+          const { S3Client } = await import("@aws-sdk/client-s3");
+          const clientConfig = {
+            region: this.config.region,
+            credentials: {
+              accessKeyId: this.config.accessKeyId,
+              secretAccessKey: this.config.secretAccessKey
+            }
+          };
+          if (this.config.endpoint) {
+            clientConfig.endpoint = this.config.endpoint;
+          }
+          if (this.config.forcePathStyle !== void 0) {
+            clientConfig.forcePathStyle = this.config.forcePathStyle;
+          }
+          this.client = new S3Client(clientConfig);
+          return this.client;
+        } catch {
+          throw new StorageError(
+            "AWS SDK not installed. Run: npm install @aws-sdk/client-s3 @aws-sdk/s3-request-presigner",
+            StorageErrorCodes.ADAPTER_NOT_AVAILABLE
+          );
+        }
+      }
+      getFullKey(key) {
+        return this.basePath ? `${this.basePath}/${key}` : key;
+      }
+      validateKey(key) {
+        if (!key || key.includes("..") || key.startsWith("/")) {
+          throw new StorageError(
+            `Invalid key: ${key}`,
+            StorageErrorCodes.INVALID_KEY
+          );
+        }
+      }
+      async dataToBody(data) {
+        if (data instanceof Uint8Array || typeof data === "string") {
+          return data;
+        }
+        if (data instanceof Blob) {
+          const buffer = await data.arrayBuffer();
+          return new Uint8Array(buffer);
+        }
+        return data;
+      }
+      async upload(key, data, options) {
+        this.validateKey(key);
+        const fullKey = this.getFullKey(key);
+        const client = await this.getClient();
+        const { PutObjectCommand } = await import("@aws-sdk/client-s3");
+        const body = await this.dataToBody(data);
+        const params = {
+          Bucket: this.bucket,
+          Key: fullKey,
+          Body: body,
+          ContentType: options?.contentType,
+          ContentDisposition: options?.contentDisposition,
+          CacheControl: options?.cacheControl,
+          ContentEncoding: options?.contentEncoding,
+          Metadata: options?.metadata
+        };
+        if (options?.acl) {
+          params.ACL = options.acl;
+        }
+        try {
+          const result = await client.send(new PutObjectCommand(params));
+          let size = 0;
+          if (typeof body === "string") {
+            size = new TextEncoder().encode(body).length;
+          } else if (body instanceof Uint8Array) {
+            size = body.length;
+          }
+          return {
+            key: fullKey,
+            size,
+            contentType: options?.contentType ?? void 0,
+            lastModified: /* @__PURE__ */ new Date(),
+            etag: result.ETag ?? void 0,
+            metadata: options?.metadata ?? void 0
+          };
+        } catch (err) {
+          throw new StorageError(
+            `Upload failed: ${err instanceof Error ? err.message : "Unknown error"}`,
+            StorageErrorCodes.UPLOAD_FAILED,
+            void 0,
+            err
+          );
+        }
+      }
+      async download(key, options) {
+        this.validateKey(key);
+        const fullKey = this.getFullKey(key);
+        const client = await this.getClient();
+        const { GetObjectCommand } = await import("@aws-sdk/client-s3");
+        try {
+          const params = {
+            Bucket: this.bucket,
+            Key: fullKey
+          };
+          if (options?.rangeStart !== void 0 || options?.rangeEnd !== void 0) {
+            const start = options.rangeStart ?? 0;
+            const end = options.rangeEnd ?? "";
+            params.Range = `bytes=${start}-${end}`;
+          }
+          if (options?.ifNoneMatch) {
+            params.IfNoneMatch = options.ifNoneMatch;
+          }
+          if (options?.ifModifiedSince) {
+            params.IfModifiedSince = options.ifModifiedSince;
+          }
+          const result = await client.send(new GetObjectCommand(params));
+          if (!result.Body) {
+            throw new StorageError(
+              "Empty response body",
+              StorageErrorCodes.DOWNLOAD_FAILED
+            );
+          }
+          const stream = result.Body;
+          return this.streamToUint8Array(stream);
+        } catch (err) {
+          if (err instanceof Error && "name" in err && err.name === "NoSuchKey") {
+            throw new StorageError(
+              `File not found: ${key}`,
+              StorageErrorCodes.NOT_FOUND,
+              404
+            );
+          }
+          throw new StorageError(
+            `Download failed: ${err instanceof Error ? err.message : "Unknown error"}`,
+            StorageErrorCodes.DOWNLOAD_FAILED,
+            void 0,
+            err
+          );
+        }
+      }
+      async downloadStream(key, options) {
+        this.validateKey(key);
+        const fullKey = this.getFullKey(key);
+        const client = await this.getClient();
+        const { GetObjectCommand } = await import("@aws-sdk/client-s3");
+        try {
+          const params = {
+            Bucket: this.bucket,
+            Key: fullKey
+          };
+          if (options?.rangeStart !== void 0 || options?.rangeEnd !== void 0) {
+            const start = options.rangeStart ?? 0;
+            const end = options.rangeEnd ?? "";
+            params.Range = `bytes=${start}-${end}`;
+          }
+          const result = await client.send(new GetObjectCommand(params));
+          if (!result.Body) {
+            throw new StorageError(
+              "Empty response body",
+              StorageErrorCodes.DOWNLOAD_FAILED
+            );
+          }
+          return result.Body;
+        } catch (err) {
+          if (err instanceof Error && "name" in err && err.name === "NoSuchKey") {
+            throw new StorageError(
+              `File not found: ${key}`,
+              StorageErrorCodes.NOT_FOUND,
+              404
+            );
+          }
+          throw err;
+        }
+      }
+      async head(key) {
+        this.validateKey(key);
+        const fullKey = this.getFullKey(key);
+        const client = await this.getClient();
+        const { HeadObjectCommand } = await import("@aws-sdk/client-s3");
+        try {
+          const result = await client.send(
+            new HeadObjectCommand({
+              Bucket: this.bucket,
+              Key: fullKey
+            })
+          );
+          return {
+            key: fullKey,
+            size: result.ContentLength ?? 0,
+            contentType: result.ContentType ?? void 0,
+            lastModified: result.LastModified ?? void 0,
+            etag: result.ETag ?? void 0,
+            metadata: result.Metadata ?? void 0
+          };
+        } catch (err) {
+          if (err instanceof Error && "name" in err && (err.name === "NoSuchKey" || err.name === "NotFound")) {
+            return null;
+          }
+          throw err;
+        }
+      }
+      async exists(key) {
+        const metadata = await this.head(key);
+        return metadata !== null;
+      }
+      async delete(key) {
+        this.validateKey(key);
+        const fullKey = this.getFullKey(key);
+        const client = await this.getClient();
+        const { DeleteObjectCommand } = await import("@aws-sdk/client-s3");
+        try {
+          await client.send(
+            new DeleteObjectCommand({
+              Bucket: this.bucket,
+              Key: fullKey
+            })
+          );
+          return { success: true, key: fullKey };
+        } catch (err) {
+          throw new StorageError(
+            `Delete failed: ${err instanceof Error ? err.message : "Unknown error"}`,
+            StorageErrorCodes.DELETE_FAILED,
+            void 0,
+            err
+          );
+        }
+      }
+      async deleteMany(keys) {
+        const client = await this.getClient();
+        const { DeleteObjectsCommand } = await import("@aws-sdk/client-s3");
+        const objects = keys.map((key) => ({
+          Key: this.getFullKey(key)
+        }));
+        try {
+          const result = await client.send(
+            new DeleteObjectsCommand({
+              Bucket: this.bucket,
+              Delete: { Objects: objects }
+            })
+          );
+          const deleted = result.Deleted?.map((d) => d.Key ?? "") ?? [];
+          const errors = result.Errors?.map((e) => ({
+            key: e.Key ?? "",
+            error: e.Message ?? "Unknown error"
+          })) ?? [];
+          return { deleted, errors };
+        } catch (err) {
+          throw new StorageError(
+            `Batch delete failed: ${err instanceof Error ? err.message : "Unknown error"}`,
+            StorageErrorCodes.DELETE_FAILED,
+            void 0,
+            err
+          );
+        }
+      }
+      async list(options) {
+        const client = await this.getClient();
+        const { ListObjectsV2Command } = await import("@aws-sdk/client-s3");
+        const prefix = options?.prefix ? this.getFullKey(options.prefix) : this.basePath || void 0;
+        try {
+          const result = await client.send(
+            new ListObjectsV2Command({
+              Bucket: this.bucket,
+              Prefix: prefix,
+              Delimiter: options?.delimiter,
+              MaxKeys: options?.maxKeys,
+              ContinuationToken: options?.continuationToken
+            })
+          );
+          const files = result.Contents?.map((item) => ({
+            key: item.Key ?? "",
+            size: item.Size ?? 0,
+            contentType: void 0,
+            lastModified: item.LastModified ?? void 0,
+            etag: item.ETag ?? void 0,
+            metadata: void 0
+          })) ?? [];
+          const prefixes = result.CommonPrefixes?.map((p) => p.Prefix ?? "") ?? [];
+          return {
+            files,
+            prefixes,
+            isTruncated: result.IsTruncated ?? false,
+            continuationToken: result.NextContinuationToken ?? void 0
+          };
+        } catch (err) {
+          throw new StorageError(
+            `List failed: ${err instanceof Error ? err.message : "Unknown error"}`,
+            StorageErrorCodes.LIST_FAILED,
+            void 0,
+            err
+          );
+        }
+      }
+      async copy(sourceKey, destKey, options) {
+        this.validateKey(sourceKey);
+        this.validateKey(destKey);
+        const client = await this.getClient();
+        const { CopyObjectCommand } = await import("@aws-sdk/client-s3");
+        const sourceFullKey = this.getFullKey(sourceKey);
+        const destFullKey = this.getFullKey(destKey);
+        const sourceBucket = options?.sourceBucket ?? this.bucket;
+        try {
+          const result = await client.send(
+            new CopyObjectCommand({
+              Bucket: this.bucket,
+              Key: destFullKey,
+              CopySource: `${sourceBucket}/${sourceFullKey}`,
+              MetadataDirective: options?.metadataDirective,
+              ContentType: options?.contentType,
+              Metadata: options?.metadata
+            })
+          );
+          const metadata = await this.head(destKey);
+          return metadata ?? {
+            key: destFullKey,
+            size: 0,
+            contentType: options?.contentType ?? void 0,
+            lastModified: result.CopyObjectResult?.LastModified ?? /* @__PURE__ */ new Date(),
+            etag: result.CopyObjectResult?.ETag ?? void 0,
+            metadata: options?.metadata ?? void 0
+          };
+        } catch (err) {
+          throw new StorageError(
+            `Copy failed: ${err instanceof Error ? err.message : "Unknown error"}`,
+            StorageErrorCodes.COPY_FAILED,
+            void 0,
+            err
+          );
+        }
+      }
+      async move(sourceKey, destKey) {
+        const metadata = await this.copy(sourceKey, destKey);
+        await this.delete(sourceKey);
+        return metadata;
+      }
+      async getPresignedUrl(key, options) {
+        this.validateKey(key);
+        const fullKey = this.getFullKey(key);
+        const client = await this.getClient();
+        try {
+          const { getSignedUrl } = await import("@aws-sdk/s3-request-presigner");
+          const { GetObjectCommand } = await import("@aws-sdk/client-s3");
+          const command = new GetObjectCommand({
+            Bucket: this.bucket,
+            Key: fullKey,
+            ResponseCacheControl: options?.responseCacheControl,
+            ResponseContentType: options?.responseContentType,
+            ResponseContentDisposition: options?.contentDisposition
+          });
+          return getSignedUrl(client, command, {
+            expiresIn: options?.expiresIn ?? 3600
+          });
+        } catch (err) {
+          throw new StorageError(
+            `Presigned URL failed: ${err instanceof Error ? err.message : "Unknown error"}`,
+            StorageErrorCodes.PRESIGN_FAILED,
+            void 0,
+            err
+          );
+        }
+      }
+      async getUploadUrl(key, options) {
+        this.validateKey(key);
+        const fullKey = this.getFullKey(key);
+        const client = await this.getClient();
+        try {
+          const { getSignedUrl } = await import("@aws-sdk/s3-request-presigner");
+          const { PutObjectCommand } = await import("@aws-sdk/client-s3");
+          const command = new PutObjectCommand({
+            Bucket: this.bucket,
+            Key: fullKey,
+            ContentType: options?.contentType,
+            ContentDisposition: options?.contentDisposition
+          });
+          return getSignedUrl(client, command, {
+            expiresIn: options?.expiresIn ?? 3600
+          });
+        } catch (err) {
+          throw new StorageError(
+            `Upload URL failed: ${err instanceof Error ? err.message : "Unknown error"}`,
+            StorageErrorCodes.PRESIGN_FAILED,
+            void 0,
+            err
+          );
+        }
+      }
+      async streamToUint8Array(stream) {
+        const reader = stream.getReader();
+        const chunks = [];
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          if (value) chunks.push(value);
+        }
+        const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+        const result = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const chunk of chunks) {
+          result.set(chunk, offset);
+          offset += chunk.length;
+        }
+        return result;
+      }
+    };
+  }
+});
+
+// src/adapters/r2.ts
+init_types();
+var R2Adapter = class {
+  type = "r2";
+  bucket;
+  binding = null;
+  s3Adapter = null;
+  config;
+  basePath;
+  constructor(config) {
+    this.bucket = config.bucket;
+    this.config = config;
+    this.basePath = config.basePath ?? "";
+    this.binding = config.binding ?? null;
+  }
+  /**
+   * Get S3 adapter for fallback
+   */
+  async getS3Adapter() {
+    if (this.s3Adapter) return this.s3Adapter;
+    const { S3Adapter: S3Adapter2 } = await Promise.resolve().then(() => (init_s3(), s3_exports));
+    this.s3Adapter = new S3Adapter2({
+      type: "s3",
+      bucket: this.bucket,
+      region: "auto",
+      accessKeyId: this.config.accessKeyId,
+      secretAccessKey: this.config.secretAccessKey,
+      endpoint: `https://${this.config.accountId}.r2.cloudflarestorage.com`
+    });
+    return this.s3Adapter;
+  }
+  getFullKey(key) {
+    return this.basePath ? `${this.basePath}/${key}` : key;
+  }
+  validateKey(key) {
+    if (!key || key.includes("..") || key.startsWith("/")) {
+      throw new StorageError(
+        `Invalid key: ${key}`,
+        StorageErrorCodes.INVALID_KEY
+      );
+    }
+  }
+  async dataToBody(data) {
+    if (data instanceof Uint8Array) {
+      const buffer = new ArrayBuffer(data.length);
+      new Uint8Array(buffer).set(data);
+      return buffer;
+    }
+    return data;
+  }
+  async upload(key, data, options) {
+    this.validateKey(key);
+    const fullKey = this.getFullKey(key);
+    if (this.binding) {
+      const body = await this.dataToBody(data);
+      const httpMetadata = {};
+      if (options?.contentType) httpMetadata.contentType = options.contentType;
+      if (options?.contentDisposition) httpMetadata.contentDisposition = options.contentDisposition;
+      if (options?.cacheControl) httpMetadata.cacheControl = options.cacheControl;
+      if (options?.contentEncoding) httpMetadata.contentEncoding = options.contentEncoding;
+      const putOptions = {
+        httpMetadata
+      };
+      if (options?.metadata) {
+        putOptions.customMetadata = options.metadata;
+      }
+      try {
+        const result = await this.binding.put(fullKey, body, putOptions);
+        return {
+          key: fullKey,
+          size: result.size,
+          contentType: result.httpMetadata?.contentType ?? void 0,
+          lastModified: result.uploaded,
+          etag: result.etag,
+          metadata: result.customMetadata ?? void 0
+        };
+      } catch (err) {
+        throw new StorageError(
+          `Upload failed: ${err instanceof Error ? err.message : "Unknown error"}`,
+          StorageErrorCodes.UPLOAD_FAILED,
+          void 0,
+          err
+        );
+      }
+    }
+    const s3 = await this.getS3Adapter();
+    return s3.upload(key, data, options);
+  }
+  async download(key, options) {
+    this.validateKey(key);
+    const fullKey = this.getFullKey(key);
+    if (this.binding) {
+      try {
+        const getOptions = {};
+        if (options?.rangeStart !== void 0 || options?.rangeEnd !== void 0) {
+          const rangeOpts = {
+            offset: options.rangeStart ?? 0
+          };
+          if (options.rangeEnd !== void 0) {
+            rangeOpts.length = options.rangeEnd - (options.rangeStart ?? 0) + 1;
+          }
+          getOptions.range = rangeOpts;
+        }
+        if (options?.ifNoneMatch || options?.ifModifiedSince) {
+          const conditional = {};
+          if (options.ifNoneMatch) conditional.etagDoesNotMatch = options.ifNoneMatch;
+          if (options.ifModifiedSince) conditional.uploadedAfter = options.ifModifiedSince;
+          getOptions.onlyIf = conditional;
+        }
+        const result = await this.binding.get(fullKey, getOptions);
+        if (!result) {
+          throw new StorageError(
+            `File not found: ${key}`,
+            StorageErrorCodes.NOT_FOUND,
+            404
+          );
+        }
+        const buffer = await result.arrayBuffer();
+        return new Uint8Array(buffer);
+      } catch (err) {
+        if (err instanceof StorageError) throw err;
+        throw new StorageError(
+          `Download failed: ${err instanceof Error ? err.message : "Unknown error"}`,
+          StorageErrorCodes.DOWNLOAD_FAILED,
+          void 0,
+          err
+        );
+      }
+    }
+    const s3 = await this.getS3Adapter();
+    return s3.download(key, options);
+  }
+  async downloadStream(key, options) {
+    this.validateKey(key);
+    const fullKey = this.getFullKey(key);
+    if (this.binding) {
+      try {
+        const getOptions = {};
+        if (options?.rangeStart !== void 0 || options?.rangeEnd !== void 0) {
+          const rangeOpts = {
+            offset: options.rangeStart ?? 0
+          };
+          if (options.rangeEnd !== void 0) {
+            rangeOpts.length = options.rangeEnd - (options.rangeStart ?? 0) + 1;
+          }
+          getOptions.range = rangeOpts;
+        }
+        const result = await this.binding.get(fullKey, getOptions);
+        if (!result) {
+          throw new StorageError(
+            `File not found: ${key}`,
+            StorageErrorCodes.NOT_FOUND,
+            404
+          );
+        }
+        return result.body;
+      } catch (err) {
+        if (err instanceof StorageError) throw err;
+        throw new StorageError(
+          `Download failed: ${err instanceof Error ? err.message : "Unknown error"}`,
+          StorageErrorCodes.DOWNLOAD_FAILED,
+          void 0,
+          err
+        );
+      }
+    }
+    const s3 = await this.getS3Adapter();
+    return s3.downloadStream(key, options);
+  }
+  async head(key) {
+    this.validateKey(key);
+    const fullKey = this.getFullKey(key);
+    if (this.binding) {
+      try {
+        const result = await this.binding.head(fullKey);
+        if (!result) {
+          return null;
+        }
+        return {
+          key: fullKey,
+          size: result.size,
+          contentType: result.httpMetadata?.contentType ?? void 0,
+          lastModified: result.uploaded,
+          etag: result.etag,
+          metadata: result.customMetadata ?? void 0
+        };
+      } catch {
+        return null;
+      }
+    }
+    const s3 = await this.getS3Adapter();
+    return s3.head(key);
+  }
+  async exists(key) {
+    const metadata = await this.head(key);
+    return metadata !== null;
+  }
+  async delete(key) {
+    this.validateKey(key);
+    const fullKey = this.getFullKey(key);
+    if (this.binding) {
+      try {
+        await this.binding.delete(fullKey);
+        return { success: true, key: fullKey };
+      } catch (err) {
+        throw new StorageError(
+          `Delete failed: ${err instanceof Error ? err.message : "Unknown error"}`,
+          StorageErrorCodes.DELETE_FAILED,
+          void 0,
+          err
+        );
+      }
+    }
+    const s3 = await this.getS3Adapter();
+    return s3.delete(key);
+  }
+  async deleteMany(keys) {
+    if (this.binding) {
+      const fullKeys = keys.map((key) => this.getFullKey(key));
+      try {
+        await this.binding.delete(fullKeys);
+        return { deleted: fullKeys, errors: [] };
+      } catch (err) {
+        return {
+          deleted: [],
+          errors: fullKeys.map((key) => ({
+            key,
+            error: err instanceof Error ? err.message : "Unknown error"
+          }))
+        };
+      }
+    }
+    const s3 = await this.getS3Adapter();
+    return s3.deleteMany(keys);
+  }
+  async list(options) {
+    if (this.binding) {
+      try {
+        const listOpts = {
+          include: ["httpMetadata", "customMetadata"]
+        };
+        const prefix = options?.prefix ? this.getFullKey(options.prefix) : this.basePath || null;
+        if (prefix) listOpts.prefix = prefix;
+        if (options?.delimiter) listOpts.delimiter = options.delimiter;
+        if (options?.maxKeys) listOpts.limit = options.maxKeys;
+        if (options?.continuationToken) listOpts.cursor = options.continuationToken;
+        const result = await this.binding.list(listOpts);
+        const files = result.objects.map((obj) => ({
+          key: obj.key,
+          size: obj.size,
+          contentType: obj.httpMetadata?.contentType ?? void 0,
+          lastModified: obj.uploaded,
+          etag: obj.etag,
+          metadata: obj.customMetadata ?? void 0
+        }));
+        return {
+          files,
+          prefixes: result.delimitedPrefixes,
+          isTruncated: result.truncated,
+          continuationToken: result.cursor ?? void 0
+        };
+      } catch (err) {
+        throw new StorageError(
+          `List failed: ${err instanceof Error ? err.message : "Unknown error"}`,
+          StorageErrorCodes.LIST_FAILED,
+          void 0,
+          err
+        );
+      }
+    }
+    const s3 = await this.getS3Adapter();
+    return s3.list(options);
+  }
+  async copy(sourceKey, destKey, options) {
+    if (this.binding) {
+      const data = await this.download(sourceKey);
+      const sourceMetadata = await this.head(sourceKey);
+      const uploadOptions2 = options?.metadataDirective === "REPLACE" ? {
+        contentType: options.contentType,
+        metadata: options.metadata
+      } : {
+        contentType: sourceMetadata?.contentType,
+        metadata: sourceMetadata?.metadata
+      };
+      return this.upload(destKey, data, uploadOptions2);
+    }
+    const s3 = await this.getS3Adapter();
+    return s3.copy(sourceKey, destKey, options);
+  }
+  async move(sourceKey, destKey) {
+    const metadata = await this.copy(sourceKey, destKey);
+    await this.delete(sourceKey);
+    return metadata;
+  }
+  async getPresignedUrl(key, options) {
+    const s3 = await this.getS3Adapter();
+    return s3.getPresignedUrl(key, options);
+  }
+  async getUploadUrl(key, options) {
+    const s3 = await this.getS3Adapter();
+    return s3.getUploadUrl(key, options);
+  }
+  /**
+   * Get public URL for a file (if custom domain is configured)
+   */
+  getPublicUrl(key) {
+    if (!this.config.customDomain) {
+      return null;
+    }
+    const fullKey = this.getFullKey(key);
+    return `https://${this.config.customDomain}/${fullKey}`;
+  }
+};
+function createR2Adapter(config) {
+  return new R2Adapter(config);
+}
+export {
+  R2Adapter,
+  createR2Adapter
+};
+//# sourceMappingURL=r2.js.map