openwrangler 0.0.3 → 0.0.4

package/dist/index.d.mts

@@ -1,12 +1,19 @@
 import { R2Bucket, KVNamespace, D1Database } from '@cloudflare/workers-types/experimental';
 
+interface R2Config {
+    accountId: string;
+    r2AccessKeyId: string;
+    r2SecretAccessKey: string;
+}
+
 interface BindingsConfig {
     accountId: string;
     apiToken: string;
 }
-declare function createR2Binding(config: BindingsConfig, bucketName: string): R2Bucket;
+
+declare function createR2Binding(config: R2Config, bucketName: string): R2Bucket;
 declare function createKVBinding(config: BindingsConfig, namespaceId: string): KVNamespace;
 declare function createD1Binding(config: BindingsConfig, databaseId: string): D1Database;
 
 export { createD1Binding, createKVBinding, createR2Binding };
-export type { BindingsConfig };
+export type { BindingsConfig, R2Config };

package/dist/index.d.ts

@@ -1,12 +1,19 @@
 import { R2Bucket, KVNamespace, D1Database } from '@cloudflare/workers-types/experimental';
 
+interface R2Config {
+    accountId: string;
+    r2AccessKeyId: string;
+    r2SecretAccessKey: string;
+}
+
 interface BindingsConfig {
     accountId: string;
     apiToken: string;
 }
-declare function createR2Binding(config: BindingsConfig, bucketName: string): R2Bucket;
+
+declare function createR2Binding(config: R2Config, bucketName: string): R2Bucket;
 declare function createKVBinding(config: BindingsConfig, namespaceId: string): KVNamespace;
 declare function createD1Binding(config: BindingsConfig, databaseId: string): D1Database;
 
 export { createD1Binding, createKVBinding, createR2Binding };
-export type { BindingsConfig };
+export type { BindingsConfig, R2Config };

package/dist/index.mjs

@@ -383,8 +383,412 @@ function createD1Binding$1(client, databaseId) {
   };
 }
 
+async function sha256(data) {
+  const encoder = new TextEncoder();
+  const dataBuffer = typeof data === "string" ? encoder.encode(data) : data;
+  return await crypto.subtle.digest("SHA-256", dataBuffer);
+}
+function hex(buffer) {
+  return Array.from(new Uint8Array(buffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function hmac(key, data) {
+  const encoder = new TextEncoder();
+  const cryptoKey = await crypto.subtle.importKey(
+    "raw",
+    key,
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  return await crypto.subtle.sign("HMAC", cryptoKey, encoder.encode(data));
+}
+async function getSignatureKey(secretAccessKey, dateStamp, region, service) {
+  const encoder = new TextEncoder();
+  const kDate = await hmac(encoder.encode(`AWS4${secretAccessKey}`), dateStamp);
+  const kRegion = await hmac(kDate, region);
+  const kService = await hmac(kRegion, service);
+  const kSigning = await hmac(kService, "aws4_request");
+  return kSigning;
+}
+async function signRequest(params) {
+  const {
+    method,
+    url,
+    headers,
+    body,
+    accessKeyId,
+    secretAccessKey,
+    region = "auto",
+    service = "s3"
+  } = params;
+  const urlObj = new URL(url);
+  const host = urlObj.host;
+  const path = urlObj.pathname || "/";
+  const queryString = urlObj.search.slice(1);
+  const now = /* @__PURE__ */ new Date();
+  const amzDate = now.toISOString().replace(/[:-]|\.\d{3}/g, "");
+  const dateStamp = amzDate.slice(0, 8);
+  const canonicalHeaders = {
+    host,
+    "x-amz-date": amzDate,
+    ...headers
+  };
+  const signedHeaders = Object.keys(canonicalHeaders).sort().join(";");
+  const canonicalHeadersString = Object.keys(canonicalHeaders).sort().map((key) => `${key}:${canonicalHeaders[key]}`).join("\n");
+  const payloadHash = body ? hex(await sha256(body)) : hex(await sha256(""));
+  const canonicalRequest = [
+    method,
+    path,
+    queryString,
+    canonicalHeadersString + "\n",
+    signedHeaders,
+    payloadHash
+  ].join("\n");
+  const algorithm = "AWS4-HMAC-SHA256";
+  const credentialScope = `${dateStamp}/${region}/${service}/aws4_request`;
+  const stringToSign = [
+    algorithm,
+    amzDate,
+    credentialScope,
+    hex(await sha256(canonicalRequest))
+  ].join("\n");
+  const signingKey = await getSignatureKey(secretAccessKey, dateStamp, region, service);
+  const signature = hex(await hmac(signingKey, stringToSign));
+  const authorization = `${algorithm} Credential=${accessKeyId}/${credentialScope}, SignedHeaders=${signedHeaders}, Signature=${signature}`;
+  return {
+    "Authorization": authorization,
+    "x-amz-date": amzDate,
+    "x-amz-content-sha256": payloadHash
+  };
+}
+
+function createR2Binding$1(config, bucketName) {
+  const { accountId, r2AccessKeyId, r2SecretAccessKey } = config;
+  const baseUrl = `https://${accountId}.r2.cloudflarestorage.com/${bucketName}`;
+  async function signedFetch(method, key, options) {
+    const queryString = options?.queryParams ? "?" + new URLSearchParams(options.queryParams).toString() : "";
+    const url = `${baseUrl}/${encodeURIComponent(key)}${queryString}`;
+    let body;
+    if (options?.body instanceof ReadableStream) {
+      const reader = options.body.getReader();
+      const chunks = [];
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        chunks.push(value);
+      }
+      const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
+      const result = new Uint8Array(totalLength);
+      let offset = 0;
+      for (const chunk of chunks) {
+        result.set(chunk, offset);
+        offset += chunk.length;
+      }
+      body = result.buffer;
+    } else {
+      body = options?.body;
+    }
+    const signatureHeaders = await signRequest({
+      method,
+      url,
+      headers: options?.headers || {},
+      body,
+      accessKeyId: r2AccessKeyId,
+      secretAccessKey: r2SecretAccessKey
+    });
+    return fetch(url, {
+      method,
+      headers: {
+        ...options?.headers,
+        ...signatureHeaders
+      },
+      body
+    });
+  }
+  async function signedFetchBucket(method, options) {
+    const queryString = options?.queryParams ? "?" + new URLSearchParams(options.queryParams).toString() : "";
+    const url = `${baseUrl}${queryString}`;
+    const signatureHeaders = await signRequest({
+      method,
+      url,
+      headers: options?.headers || {},
+      accessKeyId: r2AccessKeyId,
+      secretAccessKey: r2SecretAccessKey
+    });
+    return fetch(url, {
+      method,
+      headers: {
+        ...options?.headers,
+        ...signatureHeaders
+      }
+    });
+  }
+  const r2Bucket = {
+    async get(key, options) {
+      const headers = {};
+      if (options?.range) {
+        if (typeof options.range === "object") {
+          const { offset, length, suffix } = options.range;
+          if (suffix) {
+            headers["Range"] = `bytes=-${suffix}`;
+          } else if (offset !== void 0) {
+            headers["Range"] = length ? `bytes=${offset}-${offset + length - 1}` : `bytes=${offset}-`;
+          }
+        }
+      }
+      if (options?.onlyIf) {
+        if (options.onlyIf.etagMatches) {
+          headers["If-Match"] = options.onlyIf.etagMatches;
+        }
+        if (options.onlyIf.etagDoesNotMatch) {
+          headers["If-None-Match"] = options.onlyIf.etagDoesNotMatch;
+        }
+        if (options.onlyIf.uploadedBefore) {
+          headers["If-Unmodified-Since"] = options.onlyIf.uploadedBefore.toUTCString();
+        }
+        if (options.onlyIf.uploadedAfter) {
+          headers["If-Modified-Since"] = options.onlyIf.uploadedAfter.toUTCString();
+        }
+      }
+      const response = await signedFetch("GET", key, { headers });
+      if (response.status === 404) {
+        return null;
+      }
+      if (!response.ok) {
+        throw new Error(`R2 GET failed: ${response.status}`);
+      }
+      const customMetadata = {};
+      response.headers.forEach((value, key2) => {
+        if (key2.toLowerCase().startsWith("x-amz-meta-")) {
+          const metaKey = key2.slice("x-amz-meta-".length);
+          customMetadata[metaKey] = value;
+        }
+      });
+      const r2Object = {
+        key,
+        version: response.headers.get("x-amz-version-id") || "",
+        size: parseInt(response.headers.get("content-length") || "0", 10),
+        etag: response.headers.get("etag") || "",
+        httpEtag: response.headers.get("etag") || "",
+        checksums: {},
+        uploaded: new Date(response.headers.get("last-modified") || Date.now()),
+        httpMetadata: {
+          contentType: response.headers.get("content-type") || void 0,
+          contentLanguage: response.headers.get("content-language") || void 0,
+          contentDisposition: response.headers.get("content-disposition") || void 0,
+          contentEncoding: response.headers.get("content-encoding") || void 0,
+          cacheControl: response.headers.get("cache-control") || void 0,
+          cacheExpiry: response.headers.get("expires") ? new Date(response.headers.get("expires")) : void 0
+        },
+        customMetadata,
+        range: options?.range ? {
+          offset: 0,
+          length: parseInt(response.headers.get("content-length") || "0", 10)
+        } : void 0,
+        body: response.body,
+        bodyUsed: false,
+        arrayBuffer: () => response.arrayBuffer(),
+        text: () => response.text(),
+        json: () => response.json(),
+        blob: () => response.blob(),
+        writeHttpMetadata: (headers2) => {
+          if (r2Object.httpMetadata.contentType) {
+            headers2.set("content-type", r2Object.httpMetadata.contentType);
+          }
+          if (r2Object.httpMetadata.contentLanguage) {
+            headers2.set("content-language", r2Object.httpMetadata.contentLanguage);
+          }
+          if (r2Object.httpMetadata.contentDisposition) {
+            headers2.set("content-disposition", r2Object.httpMetadata.contentDisposition);
+          }
+          if (r2Object.httpMetadata.contentEncoding) {
+            headers2.set("content-encoding", r2Object.httpMetadata.contentEncoding);
+          }
+          if (r2Object.httpMetadata.cacheControl) {
+            headers2.set("cache-control", r2Object.httpMetadata.cacheControl);
+          }
+          if (r2Object.httpMetadata.cacheExpiry) {
+            headers2.set("expires", r2Object.httpMetadata.cacheExpiry.toUTCString());
+          }
+        }
+      };
+      return r2Object;
+    },
+    async put(key, value, options) {
+      const headers = {};
+      if (options?.httpMetadata) {
+        if (options.httpMetadata.contentType) {
+          headers["Content-Type"] = options.httpMetadata.contentType;
+        }
+        if (options.httpMetadata.contentLanguage) {
+          headers["Content-Language"] = options.httpMetadata.contentLanguage;
+        }
+        if (options.httpMetadata.contentDisposition) {
+          headers["Content-Disposition"] = options.httpMetadata.contentDisposition;
+        }
+        if (options.httpMetadata.contentEncoding) {
+          headers["Content-Encoding"] = options.httpMetadata.contentEncoding;
+        }
+        if (options.httpMetadata.cacheControl) {
+          headers["Cache-Control"] = options.httpMetadata.cacheControl;
+        }
+        if (options.httpMetadata.cacheExpiry) {
+          headers["Expires"] = options.httpMetadata.cacheExpiry.toUTCString();
+        }
+      }
+      if (options?.customMetadata) {
+        for (const [key2, value2] of Object.entries(options.customMetadata)) {
+          headers[`x-amz-meta-${key2}`] = value2;
+        }
+      }
+      let body;
+      if (ArrayBuffer.isView(value)) {
+        body = value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength);
+      } else {
+        body = value;
+      }
+      const response = await signedFetch("PUT", key, { headers, body });
+      if (!response.ok) {
+        throw new Error(`R2 PUT failed: ${response.status}`);
+      }
+      return {
+        key,
+        version: response.headers.get("x-amz-version-id") || "",
+        size: typeof value === "string" ? value.length : 0,
+        etag: response.headers.get("etag") || "",
+        httpEtag: response.headers.get("etag") || "",
+        checksums: {},
+        uploaded: /* @__PURE__ */ new Date(),
+        httpMetadata: options?.httpMetadata || {},
+        customMetadata: options?.customMetadata || {}
+      };
+    },
+    async delete(keys) {
+      const keyArray = Array.isArray(keys) ? keys : [keys];
+      if (keyArray.length === 1) {
+        const response = await signedFetch("DELETE", keyArray[0]);
+        if (!response.ok && response.status !== 404) {
+          throw new Error(`R2 DELETE failed: ${response.status}`);
+        }
+      } else {
+        `<?xml version="1.0" encoding="UTF-8"?>
+<Delete>
+  ${keyArray.map((key) => `<Object><Key>${key}</Key></Object>`).join("")}
+</Delete>`;
+        const response = await signedFetchBucket("POST", {
+          queryParams: { delete: "" },
+          headers: { "Content-Type": "application/xml" }
+        });
+        if (!response.ok) {
+          throw new Error(`R2 DELETE BULK failed: ${response.status}`);
+        }
+      }
+    },
+    async head(key) {
+      const response = await signedFetch("HEAD", key);
+      if (response.status === 404) {
+        return null;
+      }
+      if (!response.ok) {
+        throw new Error(`R2 HEAD failed: ${response.status}`);
+      }
+      const customMetadata = {};
+      response.headers.forEach((value, key2) => {
+        if (key2.toLowerCase().startsWith("x-amz-meta-")) {
+          const metaKey = key2.slice("x-amz-meta-".length);
+          customMetadata[metaKey] = value;
+        }
+      });
+      return {
+        key,
+        version: response.headers.get("x-amz-version-id") || "",
+        size: parseInt(response.headers.get("content-length") || "0", 10),
+        etag: response.headers.get("etag") || "",
+        httpEtag: response.headers.get("etag") || "",
+        checksums: {},
+        uploaded: new Date(response.headers.get("last-modified") || Date.now()),
+        httpMetadata: {
+          contentType: response.headers.get("content-type") || void 0,
+          contentLanguage: response.headers.get("content-language") || void 0,
+          contentDisposition: response.headers.get("content-disposition") || void 0,
+          contentEncoding: response.headers.get("content-encoding") || void 0,
+          cacheControl: response.headers.get("cache-control") || void 0,
+          cacheExpiry: response.headers.get("expires") ? new Date(response.headers.get("expires")) : void 0
+        },
+        customMetadata
+      };
+    },
+    async list(options) {
+      const queryParams = {
+        "list-type": "2"
+      };
+      if (options?.limit) {
+        queryParams["max-keys"] = options.limit.toString();
+      }
+      if (options?.prefix) {
+        queryParams["prefix"] = options.prefix;
+      }
+      if (options?.cursor) {
+        queryParams["continuation-token"] = options.cursor;
+      }
+      if (options?.delimiter) {
+        queryParams["delimiter"] = options.delimiter;
+      }
+      if (options?.startAfter) {
+        queryParams["start-after"] = options.startAfter;
+      }
+      const response = await signedFetchBucket("GET", { queryParams });
+      if (!response.ok) {
+        throw new Error(`R2 LIST failed: ${response.status}`);
+      }
+      const xml = await response.text();
+      const objects = [];
+      const delimitedPrefixes = [];
+      const contentsRegex = /<Contents>(.*?)<\/Contents>/gs;
+      let match;
+      while ((match = contentsRegex.exec(xml)) !== null) {
+        const content = match[1];
+        const key = content.match(/<Key>(.*?)<\/Key>/)?.[1] || "";
+        const size = parseInt(content.match(/<Size>(.*?)<\/Size>/)?.[1] || "0", 10);
+        const etag = content.match(/<ETag>(.*?)<\/ETag>/)?.[1] || "";
+        const lastModified = content.match(/<LastModified>(.*?)<\/LastModified>/)?.[1] || "";
+        objects.push({
+          key,
+          version: "",
+          size,
+          etag,
+          httpEtag: etag,
+          checksums: {},
+          uploaded: new Date(lastModified),
+          httpMetadata: {},
+          customMetadata: {}
+        });
+      }
+      const prefixRegex = /<CommonPrefixes>.*?<Prefix>(.*?)<\/Prefix>.*?<\/CommonPrefixes>/gs;
+      while ((match = prefixRegex.exec(xml)) !== null) {
+        delimitedPrefixes.push(match[1]);
+      }
+      const isTruncated = xml.includes("<IsTruncated>true</IsTruncated>");
+      const nextContinuationToken = xml.match(/<NextContinuationToken>(.*?)<\/NextContinuationToken>/)?.[1];
+      return {
+        objects,
+        truncated: isTruncated,
+        cursor: nextContinuationToken,
+        delimitedPrefixes
+      };
+    },
+    createMultipartUpload(key, options) {
+      throw new Error("R2 multipart upload not yet implemented");
+    },
+    resumeMultipartUpload(key, uploadId) {
+      throw new Error("R2 multipart upload not yet implemented");
+    }
+  };
+  return r2Bucket;
+}
+
 function createR2Binding(config, bucketName) {
-  throw new Error("R2 binding not yet implemented. Use KV or D1 instead.");
+  return createR2Binding$1(config, bucketName);
 }
 function createKVBinding(config, namespaceId) {
   const client = new CloudflareAPIClient(config.accountId, config.apiToken);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openwrangler",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "type": "module",
   "exports": {
     ".": {
@@ -17,12 +17,12 @@
     "@cloudflare/workers-types": "^4.20251231.0",
     "nuxt": "^3.15.0",
     "typescript": "^5.7.2",
+    "wrangler": "^4.54.0",
     "unbuild": "^3.3.1",
-    "wrangler": "^3.99.0",
-    "@binochoi/nitro-cloudflare-dev": "npm:@bino0216/nitro-cloudflare-dev@0.2.5"
+    "@bino0216/nitro-cloudflare-dev": "0.2.6"
   },
   "scripts": {
-    "dev": "nuxi dev playground",
+    "dev": "cd ./playground && pnpm dev",
     "build": "unbuild"
   }
 }