@parsrun/storage 0.1.0

package/dist/index.js

@@ -0,0 +1,1316 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// 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/memory.ts
+var memory_exports = {};
+__export(memory_exports, {
+  MemoryAdapter: () => MemoryAdapter,
+  createMemoryAdapter: () => createMemoryAdapter
+});
+function createMemoryAdapter(config) {
+  return new MemoryAdapter({ ...config, type: "memory" });
+}
+var MemoryAdapter;
+var init_memory = __esm({
+  "src/adapters/memory.ts"() {
+    "use strict";
+    init_types();
+    MemoryAdapter = class {
+      type = "memory";
+      bucket;
+      files = /* @__PURE__ */ new Map();
+      maxSize;
+      currentSize = 0;
+      basePath;
+      constructor(config) {
+        this.bucket = config.bucket;
+        this.maxSize = config.maxSize ?? Infinity;
+        this.basePath = config.basePath ?? "";
+      }
+      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
+          );
+        }
+      }
+      dataToUint8Array(data) {
+        if (data instanceof Uint8Array) {
+          return data;
+        }
+        if (typeof data === "string") {
+          return new TextEncoder().encode(data);
+        }
+        if (data instanceof Blob) {
+          return data.arrayBuffer().then((buffer) => new Uint8Array(buffer));
+        }
+        return this.streamToUint8Array(data);
+      }
+      async streamToUint8Array(stream) {
+        const reader = stream.getReader();
+        const chunks = [];
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          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;
+      }
+      async upload(key, data, options) {
+        this.validateKey(key);
+        const fullKey = this.getFullKey(key);
+        const uint8Data = await this.dataToUint8Array(data);
+        const existingFile = this.files.get(fullKey);
+        const sizeDiff = uint8Data.length - (existingFile?.data.length ?? 0);
+        if (this.currentSize + sizeDiff > this.maxSize) {
+          throw new StorageError(
+            "Storage quota exceeded",
+            StorageErrorCodes.QUOTA_EXCEEDED
+          );
+        }
+        const metadata = {
+          key: fullKey,
+          size: uint8Data.length,
+          contentType: options?.contentType ?? this.guessContentType(key),
+          lastModified: /* @__PURE__ */ new Date(),
+          etag: this.generateEtag(uint8Data),
+          metadata: options?.metadata ?? void 0
+        };
+        this.files.set(fullKey, { data: uint8Data, metadata });
+        this.currentSize += sizeDiff;
+        return metadata;
+      }
+      async download(key, _options) {
+        this.validateKey(key);
+        const fullKey = this.getFullKey(key);
+        const file = this.files.get(fullKey);
+        if (!file) {
+          throw new StorageError(
+            `File not found: ${key}`,
+            StorageErrorCodes.NOT_FOUND,
+            404
+          );
+        }
+        return file.data;
+      }
+      async downloadStream(key, _options) {
+        const data = await this.download(key);
+        return new ReadableStream({
+          start(controller) {
+            controller.enqueue(data);
+            controller.close();
+          }
+        });
+      }
+      async head(key) {
+        this.validateKey(key);
+        const fullKey = this.getFullKey(key);
+        const file = this.files.get(fullKey);
+        return file?.metadata ?? null;
+      }
+      async exists(key) {
+        this.validateKey(key);
+        const fullKey = this.getFullKey(key);
+        return this.files.has(fullKey);
+      }
+      async delete(key) {
+        this.validateKey(key);
+        const fullKey = this.getFullKey(key);
+        const file = this.files.get(fullKey);
+        if (file) {
+          this.currentSize -= file.data.length;
+          this.files.delete(fullKey);
+        }
+        return { success: true, key: fullKey };
+      }
+      async deleteMany(keys) {
+        const deleted = [];
+        const errors = [];
+        for (const key of keys) {
+          try {
+            await this.delete(key);
+            deleted.push(this.getFullKey(key));
+          } catch (err) {
+            errors.push({
+              key: this.getFullKey(key),
+              error: err instanceof Error ? err.message : "Unknown error"
+            });
+          }
+        }
+        return { deleted, errors };
+      }
+      async list(options) {
+        const prefix = options?.prefix ? this.getFullKey(options.prefix) : this.basePath;
+        const delimiter = options?.delimiter ?? "/";
+        const maxKeys = options?.maxKeys ?? 1e3;
+        const files = [];
+        const prefixSet = /* @__PURE__ */ new Set();
+        for (const [key, file] of this.files) {
+          if (prefix && !key.startsWith(prefix)) {
+            continue;
+          }
+          const relativePath = prefix ? key.slice(prefix.length) : key;
+          if (delimiter) {
+            const delimiterIndex = relativePath.indexOf(delimiter);
+            if (delimiterIndex !== -1) {
+              const commonPrefix = key.slice(0, prefix.length + delimiterIndex + 1);
+              prefixSet.add(commonPrefix);
+              continue;
+            }
+          }
+          files.push(file.metadata);
+          if (files.length >= maxKeys) {
+            break;
+          }
+        }
+        return {
+          files,
+          prefixes: Array.from(prefixSet),
+          isTruncated: files.length >= maxKeys,
+          continuationToken: void 0
+        };
+      }
+      async copy(sourceKey, destKey, options) {
+        this.validateKey(sourceKey);
+        this.validateKey(destKey);
+        const sourceFullKey = this.getFullKey(sourceKey);
+        const destFullKey = this.getFullKey(destKey);
+        const sourceFile = this.files.get(sourceFullKey);
+        if (!sourceFile) {
+          throw new StorageError(
+            `Source file not found: ${sourceKey}`,
+            StorageErrorCodes.NOT_FOUND,
+            404
+          );
+        }
+        const newMetadata = options?.metadataDirective === "REPLACE" ? {
+          key: destFullKey,
+          size: sourceFile.data.length,
+          contentType: options.contentType ?? sourceFile.metadata.contentType,
+          lastModified: /* @__PURE__ */ new Date(),
+          etag: sourceFile.metadata.etag,
+          metadata: options.metadata ?? void 0
+        } : {
+          ...sourceFile.metadata,
+          key: destFullKey,
+          lastModified: /* @__PURE__ */ new Date()
+        };
+        this.files.set(destFullKey, {
+          data: sourceFile.data,
+          metadata: newMetadata
+        });
+        this.currentSize += sourceFile.data.length;
+        return newMetadata;
+      }
+      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 expiresIn = options?.expiresIn ?? 3600;
+        const expires = Date.now() + expiresIn * 1e3;
+        return `memory://${this.bucket}/${fullKey}?expires=${expires}`;
+      }
+      async getUploadUrl(key, options) {
+        return this.getPresignedUrl(key, options);
+      }
+      /**
+       * Clear all files (useful for testing)
+       */
+      clear() {
+        this.files.clear();
+        this.currentSize = 0;
+      }
+      /**
+       * Get current storage size
+       */
+      getSize() {
+        return this.currentSize;
+      }
+      /**
+       * Get file count
+       */
+      getFileCount() {
+        return this.files.size;
+      }
+      guessContentType(key) {
+        const ext = key.split(".").pop()?.toLowerCase();
+        const contentTypes = {
+          txt: "text/plain",
+          html: "text/html",
+          css: "text/css",
+          js: "application/javascript",
+          json: "application/json",
+          xml: "application/xml",
+          pdf: "application/pdf",
+          zip: "application/zip",
+          png: "image/png",
+          jpg: "image/jpeg",
+          jpeg: "image/jpeg",
+          gif: "image/gif",
+          webp: "image/webp",
+          svg: "image/svg+xml",
+          mp3: "audio/mpeg",
+          mp4: "video/mp4",
+          webm: "video/webm"
+        };
+        return contentTypes[ext ?? ""] ?? "application/octet-stream";
+      }
+      generateEtag(data) {
+        let hash = 0;
+        for (const byte of data) {
+          hash = (hash << 5) - hash + byte | 0;
+        }
+        return `"${Math.abs(hash).toString(16)}"`;
+      }
+    };
+  }
+});
+
+// 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
+var r2_exports = {};
+__export(r2_exports, {
+  R2Adapter: () => R2Adapter,
+  createR2Adapter: () => createR2Adapter
+});
+function createR2Adapter(config) {
+  return new R2Adapter(config);
+}
+var R2Adapter;
+var init_r2 = __esm({
+  "src/adapters/r2.ts"() {
+    "use strict";
+    init_types();
+    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}`;
+      }
+    };
+  }
+});
+
+// src/index.ts
+init_types();
+init_memory();
+init_s3();
+init_r2();
+init_types();
+async function createStorage(config) {
+  switch (config.type) {
+    case "memory": {
+      const { MemoryAdapter: MemoryAdapter2 } = await Promise.resolve().then(() => (init_memory(), memory_exports));
+      return new MemoryAdapter2(config);
+    }
+    case "s3":
+    case "do-spaces": {
+      const { S3Adapter: S3Adapter2 } = await Promise.resolve().then(() => (init_s3(), s3_exports));
+      return new S3Adapter2(config);
+    }
+    case "r2": {
+      const { R2Adapter: R2Adapter2 } = await Promise.resolve().then(() => (init_r2(), r2_exports));
+      return new R2Adapter2(config);
+    }
+    default:
+      throw new StorageError(
+        `Unknown storage type: ${config.type}`,
+        StorageErrorCodes.INVALID_CONFIG
+      );
+  }
+}
+function createStorageSync(config) {
+  switch (config.type) {
+    case "memory": {
+      const { MemoryAdapter: MemoryAdapter2 } = (init_memory(), __toCommonJS(memory_exports));
+      return new MemoryAdapter2(config);
+    }
+    case "s3":
+    case "do-spaces": {
+      const { S3Adapter: S3Adapter2 } = (init_s3(), __toCommonJS(s3_exports));
+      return new S3Adapter2(config);
+    }
+    case "r2": {
+      const { R2Adapter: R2Adapter2 } = (init_r2(), __toCommonJS(r2_exports));
+      return new R2Adapter2(config);
+    }
+    default:
+      throw new StorageError(
+        `Unknown storage type: ${config.type}`,
+        StorageErrorCodes.INVALID_CONFIG
+      );
+  }
+}
+var StorageUtils = {
+  /**
+   * Get file extension from key
+   */
+  getExtension(key) {
+    const parts = key.split(".");
+    const lastPart = parts[parts.length - 1];
+    return parts.length > 1 && lastPart ? lastPart.toLowerCase() : "";
+  },
+  /**
+   * Get file name from key
+   */
+  getFileName(key) {
+    return key.split("/").pop() ?? key;
+  },
+  /**
+   * Get directory from key
+   */
+  getDirectory(key) {
+    const parts = key.split("/");
+    parts.pop();
+    return parts.join("/");
+  },
+  /**
+   * Join paths safely
+   */
+  joinPath(...parts) {
+    return parts.filter(Boolean).map((p) => p.replace(/^\/|\/$/g, "")).join("/");
+  },
+  /**
+   * Normalize key (remove leading slash, handle ..)
+   */
+  normalizeKey(key) {
+    return key.replace(/^\/+/, "").split("/").filter((p) => p !== ".." && p !== ".").join("/");
+  },
+  /**
+   * Generate a unique key with timestamp
+   */
+  generateUniqueKey(prefix, extension) {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).slice(2, 10);
+    const ext = extension ? `.${extension}` : "";
+    return `${prefix}/${timestamp}-${random}${ext}`;
+  },
+  /**
+   * Guess content type from file extension
+   */
+  guessContentType(key) {
+    const ext = StorageUtils.getExtension(key);
+    const contentTypes = {
+      // Text
+      txt: "text/plain",
+      html: "text/html",
+      htm: "text/html",
+      css: "text/css",
+      csv: "text/csv",
+      xml: "text/xml",
+      // Application
+      js: "application/javascript",
+      mjs: "application/javascript",
+      json: "application/json",
+      pdf: "application/pdf",
+      zip: "application/zip",
+      gzip: "application/gzip",
+      gz: "application/gzip",
+      tar: "application/x-tar",
+      doc: "application/msword",
+      docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+      xls: "application/vnd.ms-excel",
+      xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+      ppt: "application/vnd.ms-powerpoint",
+      pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+      // Images
+      png: "image/png",
+      jpg: "image/jpeg",
+      jpeg: "image/jpeg",
+      gif: "image/gif",
+      webp: "image/webp",
+      svg: "image/svg+xml",
+      ico: "image/x-icon",
+      bmp: "image/bmp",
+      tiff: "image/tiff",
+      tif: "image/tiff",
+      // Audio
+      mp3: "audio/mpeg",
+      wav: "audio/wav",
+      ogg: "audio/ogg",
+      flac: "audio/flac",
+      aac: "audio/aac",
+      // Video
+      mp4: "video/mp4",
+      webm: "video/webm",
+      avi: "video/x-msvideo",
+      mov: "video/quicktime",
+      mkv: "video/x-matroska",
+      // Fonts
+      woff: "font/woff",
+      woff2: "font/woff2",
+      ttf: "font/ttf",
+      otf: "font/otf",
+      eot: "application/vnd.ms-fontobject"
+    };
+    return contentTypes[ext] ?? "application/octet-stream";
+  },
+  /**
+   * Format file size to human readable string
+   */
+  formatSize(bytes) {
+    const units = ["B", "KB", "MB", "GB", "TB"];
+    let size = bytes;
+    let unitIndex = 0;
+    while (size >= 1024 && unitIndex < units.length - 1) {
+      size /= 1024;
+      unitIndex++;
+    }
+    return `${size.toFixed(unitIndex > 0 ? 2 : 0)} ${units[unitIndex]}`;
+  },
+  /**
+   * Parse file size string to bytes
+   */
+  parseSize(size) {
+    const units = {
+      b: 1,
+      kb: 1024,
+      mb: 1024 * 1024,
+      gb: 1024 * 1024 * 1024,
+      tb: 1024 * 1024 * 1024 * 1024
+    };
+    const match = size.toLowerCase().match(/^(\d+(?:\.\d+)?)\s*([a-z]+)?$/);
+    if (!match || !match[1]) return 0;
+    const value = parseFloat(match[1]);
+    const unit = match[2] ?? "b";
+    return Math.floor(value * (units[unit] ?? 1));
+  }
+};
+export {
+  MemoryAdapter,
+  R2Adapter,
+  S3Adapter,
+  StorageError,
+  StorageErrorCodes,
+  StorageUtils,
+  createDOSpacesAdapter,
+  createMemoryAdapter,
+  createR2Adapter,
+  createS3Adapter,
+  createStorage,
+  createStorageSync
+};
+//# sourceMappingURL=index.js.map