@lenso/storage 0.0.0-stage → 0.1.0

package/dist/r2.js

@@ -0,0 +1,188 @@
+import {
+  StorageError2,
+  createStoragePlugin2,
+  validateKey2,
+  validateList2,
+  validateRange2,
+  unsupportedSigning2
+} from "./index-0fz1t930.js";
+import {
+  validateUpload,
+  checkedUpload
+} from "./index-fa6z0g4w.js";
+
+// src/r2.ts
+function metadata(object) {
+  return {
+    key: object.key,
+    size: object.size,
+    contentType: object.httpMetadata?.contentType ?? "application/octet-stream",
+    etag: object.httpEtag,
+    versionId: object.version,
+    lastModified: object.uploaded,
+    customMetadata: object.customMetadata
+  };
+}
+function failure(error, signal) {
+  if (error instanceof StorageError2)
+    return error;
+  if (signal?.aborted)
+    return new StorageError2("aborted", "Storage operation cancelled", { cause: error });
+  const value = error;
+  const status = value?.status ?? value?.statusCode ?? value?.code;
+  const code = status === 403 || status === 10003 || value?.name === "AccessDenied" ? "forbidden" : status === 404 || value?.name === "NoSuchKey" ? "not-found" : status === 409 || status === 412 ? "conflict" : "provider";
+  return new StorageError2(code, "R2 storage operation failed", { cause: error });
+}
+function checkSignal(signal) {
+  if (signal?.aborted)
+    throw new StorageError2("aborted", "Storage operation cancelled", { cause: signal.reason });
+}
+function createR2StoragePlugin(options) {
+  return createStoragePlugin2({
+    id: options.id,
+    setup() {
+      const binding = options.binding;
+      return {
+        capabilities: {
+          provider: "r2-binding",
+          signedUpload: false,
+          signedDownload: false,
+          rangeRead: true,
+          conditionalRead: true,
+          pagination: "opaque",
+          uploadCancellation: "stream-only",
+          uploadRequiresSize: true,
+          maxUploadBytes: 5 * 1024 ** 3
+        },
+        async put(input) {
+          validateKey2(input.key);
+          checkSignal(input.signal);
+          validateUpload(input);
+          if (input.size === undefined)
+            throw new StorageError2("invalid-input", "R2 binding uploads require size");
+          if (input.size > 5 * 1024 ** 3)
+            throw new StorageError2("too-large", "R2 binding single PUT cannot exceed 5 GiB");
+          const FixedLengthStream = globalThis.FixedLengthStream;
+          if (!FixedLengthStream)
+            throw new StorageError2("unsupported", "R2 uploads require the Workers FixedLengthStream runtime");
+          const fixed = new FixedLengthStream(input.size);
+          const upload = checkedUpload(input);
+          const controller = new AbortController;
+          const abort = () => controller.abort(input.signal?.reason);
+          input.signal?.addEventListener("abort", abort, { once: true });
+          if (input.signal?.aborted)
+            abort();
+          const pumping = upload.body.pipeTo(fixed.writable, { signal: controller.signal });
+          pumping.catch(() => {});
+          try {
+            const object = await binding.put(input.key, fixed.readable, {
+              onlyIf: new Headers({ "If-None-Match": "*" }),
+              httpMetadata: { contentType: input.contentType ?? "application/octet-stream" },
+              customMetadata: input.customMetadata
+            });
+            if (!object)
+              throw new StorageError2("conflict", "Object already exists");
+            await pumping;
+            return metadata(object);
+          } catch (error) {
+            controller.abort();
+            try {
+              await upload.cancel(error);
+            } catch (cleanupError) {
+              await pumping.catch(() => {});
+              throw new StorageError2("provider", "R2 upload failed and source cleanup failed", {
+                cause: new AggregateError([error, cleanupError], "Upload and cleanup failed")
+              });
+            }
+            const pumpError = await pumping.catch((value) => value);
+            if (pumpError instanceof StorageError2)
+              throw failure(pumpError, input.signal);
+            if (upload.size() > input.size) {
+              throw new StorageError2("invalid-input", "Upload size differs from declared size", {
+                cause: error
+              });
+            }
+            throw failure(error, input.signal);
+          } finally {
+            input.signal?.removeEventListener("abort", abort);
+          }
+        },
+        async get(key, input = {}) {
+          validateKey2(key);
+          validateRange2(input, true);
+          checkSignal(input.signal);
+          try {
+            const object = await binding.get(key, {
+              range: input.range,
+              onlyIf: input.ifMatch === undefined ? undefined : new Headers({ "If-Match": input.ifMatch })
+            });
+            if (!object)
+              throw new StorageError2("not-found", "Object not found");
+            if (!object.body)
+              throw new StorageError2("conflict", "Object condition failed");
+            return {
+              metadata: metadata(object),
+              body: object.body,
+              range: input.range ? {
+                offset: object.range?.offset ?? input.range.offset,
+                length: object.range?.length ?? Math.max(0, Math.min(input.range.length ?? object.size, object.size - input.range.offset))
+              } : undefined
+            };
+          } catch (error) {
+            throw failure(error, input.signal);
+          }
+        },
+        async head(key, input = {}) {
+          validateKey2(key);
+          checkSignal(input.signal);
+          try {
+            const object = await binding.head(key);
+            return object ? metadata(object) : null;
+          } catch (error) {
+            throw failure(error, input.signal);
+          }
+        },
+        async delete(key, input = {}) {
+          validateKey2(key);
+          checkSignal(input.signal);
+          try {
+            await binding.delete(key);
+            return { outcome: "absent-or-deleted" };
+          } catch (error) {
+            const mapped = failure(error, input.signal);
+            if (mapped.code === "not-found")
+              return { outcome: "not-found" };
+            throw mapped;
+          }
+        },
+        async list(input = {}) {
+          const limit = validateList2(input);
+          checkSignal(input.signal);
+          try {
+            const page = await binding.list({
+              prefix: input.prefix,
+              cursor: input.cursor,
+              limit,
+              include: ["httpMetadata", "customMetadata"]
+            });
+            return {
+              objects: page.objects.map(metadata),
+              cursor: page.truncated ? page.cursor : undefined
+            };
+          } catch (error) {
+            throw failure(error, input.signal);
+          }
+        },
+        async signUpload() {
+          return unsupportedSigning2();
+        },
+        async signDownload() {
+          return unsupportedSigning2();
+        }
+      };
+    }
+  });
+}
+export {
+  createR2StoragePlugin
+};

package/dist/s3.d.ts

@@ -0,0 +1,16 @@
+import { S3Client, type S3ClientConfig } from "@aws-sdk/client-s3";
+import { type ObjectStorage } from "./index";
+export interface S3StorageOptions {
+    id: string;
+    bucket: string;
+    client?: S3Client;
+    clientConfig?: S3ClientConfig;
+    /** Disable multipart for endpoints without conditional CompleteMultipartUpload. Requires size <= 5 GiB. */
+    multipart?: boolean;
+}
+/**
+ * Requires native If-None-Match on PutObject AND CompleteMultipartUpload.
+ * Compatible endpoints must enforce these conditions, not merely accept the headers.
+ * R2 documents conditional PutObject but not conditional multipart completion.
+ */
+export declare function createS3StoragePlugin(options: S3StorageOptions): import("@lenso/core/plugin").Plugin<ObjectStorage>;

package/dist/s3.js

@@ -0,0 +1,386 @@
+import {
+  StorageError2,
+  createStoragePlugin2,
+  validateKey2,
+  validateList2,
+  validateRange2,
+  validateExpiry2
+} from "./index-0fz1t930.js";
+import {
+  validateUpload,
+  checkedUpload
+} from "./index-fa6z0g4w.js";
+
+// src/s3.ts
+import {
+  AbortMultipartUploadCommand,
+  CompleteMultipartUploadCommand,
+  DeleteObjectCommand,
+  CreateMultipartUploadCommand,
+  GetObjectCommand,
+  HeadObjectCommand,
+  ListObjectsV2Command,
+  PutObjectCommand,
+  S3Client
+} from "@aws-sdk/client-s3";
+import { Readable } from "node:stream";
+import { finished } from "node:stream/promises";
+import { Upload } from "@aws-sdk/lib-storage";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+function failure(error, signal) {
+  if (error instanceof StorageError2)
+    return error;
+  if (signal?.aborted)
+    return new StorageError2("aborted", "Storage operation cancelled", { cause: error });
+  const value = error;
+  const status = value?.$metadata?.httpStatusCode;
+  const code = status === 403 || value?.name === "AccessDenied" ? "forbidden" : status === 404 || value?.name === "NoSuchKey" || value?.name === "NotFound" ? "not-found" : status === 409 || status === 412 ? "conflict" : value?.name === "AbortError" ? "aborted" : "provider";
+  return new StorageError2(code, "S3 storage operation failed", { cause: error });
+}
+function metadata(key, object) {
+  return {
+    key,
+    size: object.ContentLength ?? 0,
+    contentType: object.ContentType ?? "application/octet-stream",
+    etag: object.ETag,
+    versionId: object.VersionId,
+    lastModified: object.LastModified,
+    customMetadata: object.Metadata
+  };
+}
+function createS3StoragePlugin(options) {
+  return createStoragePlugin2({
+    id: options.id,
+    async setup(context) {
+      const client = options.client ?? new S3Client({ requestChecksumCalculation: "WHEN_REQUIRED", ...options.clientConfig });
+      if (!options.client)
+        context.onCleanup(() => client.destroy());
+      const active = new Map;
+      let stopped = false;
+      context.onCleanup(async () => {
+        stopped = true;
+        for (const controller of active.keys())
+          controller.abort();
+        await Promise.allSettled(active.values());
+      });
+      const endpoint = await client.config.endpoint?.();
+      const r2Endpoint = endpoint?.hostname.endsWith(".r2.cloudflarestorage.com") ?? false;
+      const multipart = !r2Endpoint && options.multipart !== false;
+      const maxUploadBytes = multipart ? 5 * 1024 ** 2 * 1e4 : 5 * 1024 ** 3;
+      const Bucket = options.bucket;
+      const service = {
+        capabilities: {
+          provider: "s3",
+          signedUpload: true,
+          signedDownload: true,
+          rangeRead: true,
+          conditionalRead: true,
+          pagination: "opaque",
+          uploadCancellation: "abort",
+          uploadRequiresSize: !multipart,
+          maxUploadBytes
+        },
+        async put(input) {
+          validateKey2(input.key);
+          if (stopped)
+            throw new StorageError2("aborted", "Storage plugin stopped");
+          try {
+            validateUpload(input);
+          } catch (error) {
+            throw failure(error, input.signal);
+          }
+          if (!multipart && input.size === undefined)
+            throw new StorageError2("invalid-input", "Single PUT uploads require size");
+          if (input.size !== undefined && input.size > maxUploadBytes)
+            throw new StorageError2("too-large", "Upload exceeds this adapter's size limit");
+          if (!multipart && await client.config.requestChecksumCalculation() !== "WHEN_REQUIRED") {
+            throw new StorageError2("unsupported", "Single PUT streaming requires requestChecksumCalculation WHEN_REQUIRED");
+          }
+          const controller = new AbortController;
+          const abort = () => controller.abort(input.signal?.reason);
+          input.signal?.addEventListener("abort", abort, { once: true });
+          if (input.signal?.aborted)
+            abort();
+          const upload = checkedUpload({
+            ...input,
+            signal: controller.signal,
+            maxBytes: Math.min(input.maxBytes ?? maxUploadBytes, maxUploadBytes)
+          });
+          let uploadId;
+          const uploadClient = new Proxy(client, {
+            get(target, property, receiver) {
+              if (property !== "send")
+                return Reflect.get(target, property, receiver);
+              return async (command, requestOptions) => {
+                if (command instanceof PutObjectCommand || command instanceof CompleteMultipartUploadCommand) {
+                  if (command.input.IfNoneMatch !== "*") {
+                    throw new StorageError2("unsupported", "SDK must preserve create-only upload conditions");
+                  }
+                  if (r2Endpoint && command instanceof CompleteMultipartUploadCommand) {
+                    throw new StorageError2("unsupported", "R2 S3 conditional multipart completion is not documented; use the R2 binding");
+                  }
+                }
+                const result = await Reflect.apply(target.send, target, [
+                  command,
+                  {
+                    ...requestOptions,
+                    ...command instanceof AbortMultipartUploadCommand ? {} : { abortSignal: controller.signal }
+                  }
+                ]);
+                if (command instanceof CreateMultipartUploadCommand)
+                  uploadId = result.UploadId;
+                if (command instanceof AbortMultipartUploadCommand || command instanceof CompleteMultipartUploadCommand)
+                  uploadId = undefined;
+                return result;
+              };
+            }
+          });
+          const task = (async () => {
+            let body;
+            try {
+              if (!multipart) {
+                body = Readable.from(async function* () {
+                  const reader = upload.body.getReader();
+                  try {
+                    while (true) {
+                      const chunk = await reader.read();
+                      if (chunk.done)
+                        break;
+                      yield chunk.value;
+                    }
+                  } finally {
+                    reader.releaseLock();
+                  }
+                }(), { objectMode: false });
+              }
+              const result = multipart ? await new Upload({
+                client: uploadClient,
+                params: {
+                  Bucket,
+                  Key: input.key,
+                  Body: upload.body,
+                  ContentType: input.contentType ?? "application/octet-stream",
+                  Metadata: input.customMetadata,
+                  IfNoneMatch: "*"
+                },
+                queueSize: 1,
+                partSize: 5 * 1024 * 1024,
+                leavePartsOnError: false
+              }).done() : await client.send(new PutObjectCommand({
+                Bucket,
+                Key: input.key,
+                Body: body,
+                ContentLength: input.size,
+                ContentType: input.contentType ?? "application/octet-stream",
+                Metadata: input.customMetadata,
+                IfNoneMatch: "*"
+              }), { abortSignal: controller.signal });
+              if (body)
+                await finished(body, { cleanup: true });
+              return {
+                key: input.key,
+                size: upload.size(),
+                contentType: input.contentType ?? "application/octet-stream",
+                etag: result.ETag,
+                versionId: result.VersionId,
+                customMetadata: input.customMetadata
+              };
+            } catch (error) {
+              body?.destroy();
+              const cleanupErrors = [];
+              try {
+                await upload.cancel(error);
+              } catch (cleanupError) {
+                cleanupErrors.push(cleanupError);
+              }
+              if (uploadId) {
+                try {
+                  await client.send(new AbortMultipartUploadCommand({ Bucket, Key: input.key, UploadId: uploadId }));
+                } catch (cleanupError) {
+                  cleanupErrors.push(cleanupError);
+                }
+              }
+              if (cleanupErrors.length)
+                throw new StorageError2("provider", "S3 upload failed and cleanup failed", {
+                  cause: new AggregateError([error, ...cleanupErrors], "Upload and cleanup failed")
+                });
+              throw failure(error, controller.signal);
+            } finally {
+              input.signal?.removeEventListener("abort", abort);
+              active.delete(controller);
+            }
+          })();
+          active.set(controller, task);
+          return task;
+        },
+        async head(key, input = {}) {
+          validateKey2(key);
+          try {
+            const result = await client.send(new HeadObjectCommand({ Bucket, Key: key }), {
+              abortSignal: input.signal
+            });
+            return metadata(key, result);
+          } catch (error) {
+            const mapped = failure(error, input.signal);
+            if (mapped.code === "not-found")
+              return null;
+            throw mapped;
+          }
+        },
+        async get(key, input = {}) {
+          validateKey2(key);
+          validateRange2(input, true);
+          let responseBody;
+          try {
+            const range = input.range;
+            const result = await client.send(new GetObjectCommand({
+              Bucket,
+              Key: key,
+              IfMatch: input.ifMatch,
+              Range: range ? `bytes=${range.offset}-${range.length === undefined ? "" : range.offset + range.length - 1}` : undefined
+            }), { abortSignal: input.signal });
+            if (!result.Body)
+              throw new StorageError2("provider", "S3 response has no body");
+            responseBody = result.Body.transformToWebStream();
+            const matched = result.ContentRange?.match(/^bytes (\d+)-(\d+)\/(\d+)$/);
+            if (range && (!matched || Number(matched[1]) !== range.offset)) {
+              throw new StorageError2("unsupported", "Provider did not honor the requested range");
+            }
+            if (input.ifMatch !== undefined && input.ifMatch !== "*" && result.ETag !== input.ifMatch) {
+              throw new StorageError2("conflict", "Provider returned an object outside the requested etag condition");
+            }
+            return {
+              metadata: metadata(key, {
+                ...result,
+                ContentLength: matched ? Number(matched[3]) : result.ContentLength
+              }),
+              body: responseBody,
+              range: matched ? {
+                offset: Number(matched[1]),
+                length: Number(matched[2]) - Number(matched[1]) + 1
+              } : undefined
+            };
+          } catch (error) {
+            try {
+              await responseBody?.cancel(error);
+            } catch (cleanupError) {
+              throw new StorageError2("provider", "S3 download failed and cleanup failed", {
+                cause: new AggregateError([error, cleanupError])
+              });
+            }
+            throw failure(error, input.signal);
+          }
+        },
+        async delete(key, input = {}) {
+          validateKey2(key);
+          try {
+            await client.send(new DeleteObjectCommand({ Bucket, Key: key }), {
+              abortSignal: input.signal
+            });
+            return { outcome: "absent-or-deleted" };
+          } catch (error) {
+            const mapped = failure(error, input.signal);
+            if (mapped.code === "not-found")
+              return { outcome: "not-found" };
+            throw mapped;
+          }
+        },
+        async list(input = {}) {
+          const limit = validateList2(input);
+          try {
+            const page = await client.send(new ListObjectsV2Command({
+              Bucket,
+              Prefix: input.prefix,
+              ContinuationToken: input.cursor,
+              MaxKeys: limit
+            }), { abortSignal: input.signal });
+            const objects = [];
+            for (const item of page.Contents ?? []) {
+              if (!item.Key)
+                continue;
+              const object = await service.head(item.Key, { signal: input.signal });
+              if (object)
+                objects.push(object);
+            }
+            return { objects, cursor: page.IsTruncated ? page.NextContinuationToken : undefined };
+          } catch (error) {
+            throw failure(error, input.signal);
+          }
+        },
+        async signUpload(input) {
+          validateKey2(input.key);
+          validateExpiry2(input.expiresIn);
+          validateUpload({
+            key: input.key,
+            body: new ReadableStream,
+            maxBytes: input.maxBytes,
+            contentType: input.contentType
+          });
+          try {
+            const signingClient = new Proxy(client, {
+              get(target, property, receiver) {
+                if (property === "config") {
+                  return {
+                    ...target.config,
+                    requestChecksumCalculation: async () => "WHEN_REQUIRED"
+                  };
+                }
+                return Reflect.get(target, property, receiver);
+              }
+            });
+            const url = await getSignedUrl(signingClient, new PutObjectCommand({
+              Bucket,
+              Key: input.key,
+              ContentType: input.contentType,
+              IfNoneMatch: "*"
+            }), {
+              expiresIn: input.expiresIn,
+              signableHeaders: new Set(["content-type", "if-none-match"])
+            });
+            return {
+              url,
+              method: "PUT",
+              headers: { "content-type": input.contentType, "if-none-match": "*" },
+              expiresAt: new Date(Date.now() + input.expiresIn * 1000),
+              conditions: {
+                contentType: input.contentType,
+                createOnly: true,
+                maxBytes: input.maxBytes,
+                sizeEnforcement: input.maxBytes === undefined ? "none" : "completion-check"
+              }
+            };
+          } catch (error) {
+            throw failure(error);
+          }
+        },
+        async signDownload(input) {
+          validateKey2(input.key);
+          validateExpiry2(input.expiresIn);
+          try {
+            const url = await getSignedUrl(client, new GetObjectCommand({
+              Bucket,
+              Key: input.key,
+              IfMatch: input.ifMatch
+            }), { expiresIn: input.expiresIn, signableHeaders: new Set(["if-match"]) });
+            const headers = {};
+            if (input.ifMatch !== undefined)
+              headers["if-match"] = input.ifMatch;
+            return {
+              url,
+              method: "GET",
+              headers,
+              expiresAt: new Date(Date.now() + input.expiresIn * 1000),
+              conditions: { ifMatch: input.ifMatch, sizeEnforcement: "none" }
+            };
+          } catch (error) {
+            throw failure(error);
+          }
+        }
+      };
+      return service;
+    }
+  });
+}
+export {
+  createS3StoragePlugin
+};