@lunora/storage 0.0.0 → 1.0.0-alpha.10

package/dist/packem_shared/createStorage-Bu6GJB25.mjs

@@ -0,0 +1,261 @@
+import { LunoraError } from '@lunora/errors';
+import { t as trimTrailingSlashes, a as toHex } from './internal-Dqk0MrAj.mjs';
+import { buildPresignedUrl } from './buildPresignedUrl-B5f1wvz6.mjs';
+import { buildSignedUrl } from './buildSignedUrl-rt-6azia.mjs';
+
+const MAX_KEY_LENGTH = 1024;
+const MAX_LIST_LIMIT = 1e3;
+const DEFAULT_LIST_LIMIT = 100;
+const toBase64 = (buffer) => {
+  const bytes = new Uint8Array(buffer);
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCodePoint(byte);
+  }
+  return btoa(binary);
+};
+const withSha256 = (object) => {
+  const raw = object.checksums?.sha256;
+  if (raw === void 0) {
+    return object;
+  }
+  const sha256 = toHex(raw);
+  const sha256Base64 = toBase64(raw);
+  return /* @__PURE__ */ new Proxy(object, {
+    get(target, property) {
+      if (property === "sha256") {
+        return sha256;
+      }
+      if (property === "sha256Base64") {
+        return sha256Base64;
+      }
+      const value = Reflect.get(target, property, target);
+      return typeof value === "function" ? value.bind(target) : value;
+    },
+    has(target, property) {
+      return property === "sha256" || property === "sha256Base64" || Reflect.has(target, property);
+    }
+  });
+};
+const toMetadata = (object) => {
+  const raw = object.checksums?.sha256;
+  return {
+    contentType: object.httpMetadata?.contentType,
+    customMetadata: object.customMetadata,
+    key: object.key,
+    sha256: raw === void 0 ? void 0 : toHex(raw),
+    size: object.size,
+    uploaded: object.uploaded === void 0 ? void 0 : object.uploaded.getTime()
+  };
+};
+const toListObject = (object) => {
+  const raw = object.checksums?.sha256;
+  return {
+    checksums: object.checksums,
+    customMetadata: object.customMetadata,
+    etag: object.etag,
+    httpEtag: object.httpEtag,
+    httpMetadata: object.httpMetadata,
+    key: object.key,
+    sha256: raw === void 0 ? void 0 : toHex(raw),
+    sha256Base64: raw === void 0 ? void 0 : toBase64(raw),
+    size: object.size,
+    uploaded: object.uploaded
+  };
+};
+const enforceStreamMaxSize = (stream, maxSize) => {
+  let seen = 0;
+  const byteLengthOf = (chunk) => {
+    if (chunk instanceof ArrayBuffer) {
+      return chunk.byteLength;
+    }
+    return ArrayBuffer.isView(chunk) ? chunk.byteLength : void 0;
+  };
+  const counter = new TransformStream({
+    transform(chunk, controller) {
+      const length = byteLengthOf(chunk);
+      if (length === void 0) {
+        controller.error(new Error("@lunora/storage: stream chunk is not a byte chunk; cannot enforce maxSize"));
+        return;
+      }
+      seen += length;
+      if (seen > maxSize) {
+        controller.error(new Error(`@lunora/storage: stream body exceeds maxSize (> ${String(maxSize)} bytes)`));
+        return;
+      }
+      controller.enqueue(chunk);
+    }
+  });
+  return stream.pipeThrough(counter);
+};
+const validateKey = (key) => {
+  if (typeof key !== "string" || key.length === 0) {
+    throw new LunoraError("VALIDATION_ERROR", "@lunora/storage: key must be a non-empty string");
+  }
+  if (key.length > MAX_KEY_LENGTH) {
+    throw new LunoraError("VALIDATION_ERROR", `@lunora/storage: key exceeds ${String(MAX_KEY_LENGTH)}-byte limit`);
+  }
+  if (key.includes("\0")) {
+    throw new LunoraError("VALIDATION_ERROR", "@lunora/storage: key contains NUL byte");
+  }
+  if (key.startsWith("/")) {
+    throw new LunoraError("VALIDATION_ERROR", "@lunora/storage: key must not start with `/`");
+  }
+  const segments = key.split("/");
+  for (const segment of segments) {
+    if (segment === "..") {
+      throw new LunoraError("VALIDATION_ERROR", "@lunora/storage: key contains a `..` path component");
+    }
+  }
+};
+const scopeKey = (prefix, key) => {
+  validateKey(prefix);
+  validateKey(key);
+  const trimmedPrefix = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
+  const composed = `${trimmedPrefix}/${key}`;
+  if (composed.length > MAX_KEY_LENGTH) {
+    throw new LunoraError("VALIDATION_ERROR", `@lunora/storage: scoped key exceeds ${String(MAX_KEY_LENGTH)}-byte limit`);
+  }
+  return composed;
+};
+const createStorage = (options) => {
+  if (!options.bucket) {
+    throw new LunoraError("INTERNAL", "@lunora/storage: `bucket` is required");
+  }
+  const upload = async (key, body, uploadOptions = {}) => {
+    validateKey(key);
+    if (uploadOptions.allowedContentTypes !== void 0) {
+      if (uploadOptions.contentType === void 0) {
+        throw new LunoraError("VALIDATION_ERROR", "@lunora/storage: contentType is required when allowedContentTypes is set");
+      }
+      if (!uploadOptions.allowedContentTypes.includes(uploadOptions.contentType)) {
+        throw new LunoraError("VALIDATION_ERROR", `@lunora/storage: contentType "${uploadOptions.contentType}" not in allowedContentTypes`);
+      }
+    }
+    let putBody = body;
+    if (typeof uploadOptions.maxSize === "number") {
+      let size;
+      if (body instanceof ArrayBuffer) {
+        size = body.byteLength;
+      } else if (body instanceof Blob) {
+        size = body.size;
+      }
+      if (size !== void 0 && size > uploadOptions.maxSize) {
+        throw new LunoraError("PAYLOAD_TOO_LARGE", `@lunora/storage: body exceeds maxSize (${String(size)} > ${String(uploadOptions.maxSize)})`);
+      }
+      if (body instanceof ReadableStream) {
+        putBody = enforceStreamMaxSize(body, uploadOptions.maxSize);
+      }
+    }
+    const object = await options.bucket.put(key, putBody, {
+      customMetadata: uploadOptions.customMetadata,
+      httpMetadata: uploadOptions.contentType ? { contentType: uploadOptions.contentType } : void 0
+    });
+    return { etag: object.etag, httpEtag: object.httpEtag ?? `"${object.etag}"`, key: object.key };
+  };
+  const download = async (key, downloadOptions = {}) => {
+    validateKey(key);
+    const object = await (downloadOptions.range ? options.bucket.get(key, { range: downloadOptions.range }) : options.bucket.get(key));
+    return object && withSha256(object);
+  };
+  const deleteObject = async (key) => {
+    validateKey(key);
+    await options.bucket.delete(key);
+  };
+  const getMetadata = async (key) => {
+    validateKey(key);
+    if (options.bucket.head) {
+      const head = await options.bucket.head(key);
+      return head && toMetadata(head);
+    }
+    const object = await options.bucket.get(key, { range: { length: 0 } });
+    return object && toMetadata(object);
+  };
+  const list = async (prefix, listOptions = {}) => {
+    if (prefix?.includes("\0")) {
+      throw new LunoraError("VALIDATION_ERROR", "@lunora/storage: prefix contains NUL byte");
+    }
+    const requested = listOptions.limit ?? DEFAULT_LIST_LIMIT;
+    const limit = Math.min(Math.max(1, Math.floor(requested)), MAX_LIST_LIMIT);
+    const result = await options.bucket.list({ cursor: listOptions.cursor, delimiter: listOptions.delimiter, limit, prefix });
+    return { cursor: result.cursor, objects: result.objects.map((object) => toListObject(object)), truncated: result.truncated };
+  };
+  const getUrl = (key) => {
+    if (!options.publicBaseUrl) {
+      throw new LunoraError("INTERNAL", "@lunora/storage: `publicBaseUrl` is required for getUrl()");
+    }
+    validateKey(key);
+    const safeKey = key.split("/").map((segment) => encodeURIComponent(segment)).join("/");
+    return `${trimTrailingSlashes(options.publicBaseUrl)}/${safeKey}`;
+  };
+  const getSignedUrl = async (key, signedOptions = {}) => {
+    if (!options.publicBaseUrl) {
+      throw new LunoraError("INTERNAL", "@lunora/storage: `publicBaseUrl` is required for getSignedUrl()");
+    }
+    if (!options.signingSecret) {
+      throw new LunoraError("INTERNAL", "@lunora/storage: `signingSecret` is required for getSignedUrl()");
+    }
+    validateKey(key);
+    return buildSignedUrl({
+      baseUrl: options.publicBaseUrl,
+      contentType: signedOptions.contentType,
+      expiresInSeconds: signedOptions.expiresInSeconds,
+      key,
+      method: signedOptions.method,
+      secret: options.signingSecret
+    });
+  };
+  const createMultipartUpload = async (key, multipartOptions = {}) => {
+    validateKey(key);
+    if (!options.bucket.createMultipartUpload) {
+      throw new LunoraError("INTERNAL", "@lunora/storage: bucket binding does not support multipart uploads (createMultipartUpload)");
+    }
+    return options.bucket.createMultipartUpload(key, {
+      customMetadata: multipartOptions.customMetadata,
+      httpMetadata: multipartOptions.contentType ? { contentType: multipartOptions.contentType } : void 0
+    });
+  };
+  const resumeMultipartUpload = (key, uploadId) => {
+    validateKey(key);
+    if (typeof uploadId !== "string" || uploadId.length === 0) {
+      throw new LunoraError("VALIDATION_ERROR", "@lunora/storage: resumeMultipartUpload requires a non-empty uploadId");
+    }
+    if (!options.bucket.resumeMultipartUpload) {
+      throw new LunoraError("INTERNAL", "@lunora/storage: bucket binding does not support multipart uploads (resumeMultipartUpload)");
+    }
+    return options.bucket.resumeMultipartUpload(key, uploadId);
+  };
+  const getPresignedUrl = async (key, presignedOptions = {}) => {
+    if (!options.s3) {
+      throw new LunoraError(
+        "INTERNAL",
+        "@lunora/storage: `s3` credentials are required for getPresignedUrl() — pass { accountId, accessKeyId, secretAccessKey, bucket }"
+      );
+    }
+    validateKey(key);
+    return buildPresignedUrl({
+      credentials: options.s3,
+      expiresInSeconds: presignedOptions.expiresInSeconds,
+      key,
+      method: presignedOptions.method
+    });
+  };
+  const generateUploadUrl = async (key, uploadUrlOptions = {}) => getSignedUrl(key, { contentType: uploadUrlOptions.contentType, expiresInSeconds: uploadUrlOptions.expiresInSeconds, method: "PUT" });
+  const store = async (key, body, storeOptions = {}) => upload(key, body, storeOptions);
+  return {
+    createMultipartUpload,
+    delete: deleteObject,
+    download,
+    generateUploadUrl,
+    getMetadata,
+    getPresignedUrl,
+    getSignedUrl,
+    getUrl,
+    list,
+    resumeMultipartUpload,
+    store,
+    upload
+  };
+};
+
+export { createStorage, scopeKey };

package/dist/packem_shared/internal-Dqk0MrAj.mjs

@@ -0,0 +1,17 @@
+const toHex = (buffer) => {
+  const bytes = new Uint8Array(buffer);
+  let out = "";
+  for (const byte of bytes) {
+    out += byte.toString(16).padStart(2, "0");
+  }
+  return out;
+};
+const trimTrailingSlashes = (value) => {
+  let end = value.length;
+  while (end > 0 && value[end - 1] === "/") {
+    end -= 1;
+  }
+  return value.slice(0, end);
+};
+
+export { toHex as a, trimTrailingSlashes as t };

package/package.json

@@ -1,31 +1,54 @@
 {
   "name": "@lunora/storage",
-  "version": "0.0.0",
+  "version": "1.0.0-alpha.10",
   "description": "R2-backed storage for Lunora: typed buckets and signed URLs",
-  "license": "FSL-1.1-Apache-2.0",
+  "keywords": [
+    "cloudflare",
+    "durable-objects",
+    "lunora",
+    "presigned-url",
+    "r2",
+    "signed-url",
+    "storage",
+    "workers"
+  ],
   "homepage": "https://lunora.sh",
+  "bugs": "https://github.com/anolilab/lunora/issues",
+  "license": "FSL-1.1-Apache-2.0",
+  "author": {
+    "name": "Daniel Bannert",
+    "email": "d.bannert@anolilab.de"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/anolilab/lunora.git",
     "directory": "packages/storage"
   },
-  "bugs": {
-    "url": "https://github.com/anolilab/lunora/issues"
-  },
-  "keywords": [
-    "lunora",
-    "cloudflare",
-    "workers",
-    "durable-objects",
-    "r2",
-    "storage",
-    "signed-url",
-    "presigned-url"
+  "files": [
+    "./dist",
+    "__assets__",
+    "README.md",
+    "LICENSE.md"
   ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
   "publishConfig": {
     "access": "public"
   },
-  "files": [
-    "README.md"
-  ]
+  "dependencies": {
+    "@lunora/errors": "1.0.0-alpha.6"
+  },
+  "engines": {
+    "node": "^22.15.0 || >=24.11.0"
+  }
 }