openwrangler 0.0.2 → 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

@@ -1,11 +1,802 @@
+class CloudflareAPIClient {
+  baseUrl = "https://api.cloudflare.com/client/v4";
+  accountId;
+  apiToken;
+  constructor(accountId, apiToken) {
+    this.accountId = accountId;
+    this.apiToken = apiToken;
+  }
+  async request(method, endpoint, body, headers) {
+    const url = `${this.baseUrl}${endpoint}`;
+    const response = await fetch(url, {
+      method,
+      headers: {
+        "Authorization": `Bearer ${this.apiToken}`,
+        "Content-Type": "application/json",
+        ...headers
+      },
+      body: body ? JSON.stringify(body) : void 0
+    });
+    const data = await response.json();
+    if (!response.ok || !data.success) {
+      const errorMessage = data.errors?.[0]?.message || `HTTP ${response.status}`;
+      throw new Error(`Cloudflare API Error: ${errorMessage}`);
+    }
+    return data.result;
+  }
+  async get(endpoint, headers) {
+    return this.request("GET", endpoint, void 0, headers);
+  }
+  async post(endpoint, body, headers) {
+    return this.request("POST", endpoint, body, headers);
+  }
+  async put(endpoint, body, headers) {
+    return this.request("PUT", endpoint, body, headers);
+  }
+  async delete(endpoint, body, headers) {
+    return this.request("DELETE", endpoint, body, headers);
+  }
+  getAccountId() {
+    return this.accountId;
+  }
+}
+
+function createKVBinding$1(client, namespaceId) {
+  const baseEndpoint = `/accounts/${client.getAccountId()}/storage/kv/namespaces/${namespaceId}`;
+  async function getValue(key, type, cacheTtl) {
+    try {
+      const url = `${baseEndpoint}/values/${encodeURIComponent(key)}`;
+      const headers = {};
+      if (cacheTtl !== void 0) {
+        headers["Cache-Control"] = `max-age=${cacheTtl}`;
+      }
+      const response = await fetch(`https://api.cloudflare.com/client/v4${url}`, {
+        method: "GET",
+        headers: {
+          "Authorization": `Bearer ${client.apiToken}`,
+          ...headers
+        }
+      });
+      if (response.status === 404) {
+        return null;
+      }
+      if (!response.ok) {
+        throw new Error(`KV GET failed: ${response.status}`);
+      }
+      switch (type) {
+        case "json":
+          return await response.json();
+        case "arrayBuffer":
+          return await response.arrayBuffer();
+        case "stream":
+          return response.body;
+        case "text":
+        default:
+          return await response.text();
+      }
+    } catch (error) {
+      if (error?.message?.includes("404")) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  async function getValueWithMetadata(key, type) {
+    try {
+      const url = `${baseEndpoint}/values/${encodeURIComponent(key)}`;
+      const response = await fetch(`https://api.cloudflare.com/client/v4${url}`, {
+        method: "GET",
+        headers: {
+          "Authorization": `Bearer ${client.apiToken}`
+        }
+      });
+      if (response.status === 404) {
+        return { value: null, metadata: null, cacheStatus: null };
+      }
+      if (!response.ok) {
+        throw new Error(`KV GET failed: ${response.status}`);
+      }
+      const metadata = response.headers.get("cf-kv-metadata");
+      const parsedMetadata = metadata ? JSON.parse(metadata) : null;
+      let value;
+      switch (type) {
+        case "json":
+          value = await response.json();
+          break;
+        case "arrayBuffer":
+          value = await response.arrayBuffer();
+          break;
+        case "stream":
+          value = response.body;
+          break;
+        case "text":
+        default:
+          value = await response.text();
+      }
+      return {
+        value,
+        metadata: parsedMetadata,
+        cacheStatus: response.headers.get("cf-cache-status")
+      };
+    } catch (error) {
+      if (error?.message?.includes("404")) {
+        return { value: null, metadata: null, cacheStatus: null };
+      }
+      throw error;
+    }
+  }
+  const kvNamespace = {
+    async get(key, options) {
+      if (Array.isArray(key)) {
+        const type2 = typeof options === "string" ? options : options?.type || "text";
+        const results = /* @__PURE__ */ new Map();
+        for (const k of key) {
+          const value = await getValue(k, type2, options?.cacheTtl);
+          results.set(k, value);
+        }
+        return results;
+      }
+      const type = typeof options === "string" ? options : options?.type;
+      return getValue(key, type, options?.cacheTtl);
+    },
+    async put(key, value, options) {
+      const url = `${baseEndpoint}/values/${encodeURIComponent(key)}`;
+      const headers = {
+        "Authorization": `Bearer ${client.apiToken}`
+      };
+      let body;
+      if (typeof value === "string") {
+        body = value;
+      } else if (value instanceof ArrayBuffer) {
+        body = value;
+      } else if (ArrayBuffer.isView(value)) {
+        body = value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength);
+      } else if (value instanceof ReadableStream) {
+        const reader = value.getReader();
+        const chunks = [];
+        while (true) {
+          const { done, value: chunk } = await reader.read();
+          if (done) break;
+          chunks.push(chunk);
+        }
+        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 {
+        throw new Error("Unsupported value type");
+      }
+      const queryParams = new URLSearchParams();
+      if (options?.expiration) {
+        queryParams.set("expiration", options.expiration.toString());
+      }
+      if (options?.expirationTtl) {
+        queryParams.set("expiration_ttl", options.expirationTtl.toString());
+      }
+      const queryString = queryParams.toString();
+      const fullUrl = queryString ? `${url}?${queryString}` : url;
+      const response = await fetch(`https://api.cloudflare.com/client/v4${fullUrl}`, {
+        method: "PUT",
+        headers,
+        body
+      });
+      if (!response.ok) {
+        throw new Error(`KV PUT failed: ${response.status}`);
+      }
+    },
+    async delete(key) {
+      const url = `${baseEndpoint}/values/${encodeURIComponent(key)}`;
+      const response = await fetch(`https://api.cloudflare.com/client/v4${url}`, {
+        method: "DELETE",
+        headers: {
+          "Authorization": `Bearer ${client.apiToken}`
+        }
+      });
+      if (!response.ok && response.status !== 404) {
+        throw new Error(`KV DELETE failed: ${response.status}`);
+      }
+    },
+    async deleteBulk(keys) {
+      const keyArray = Array.isArray(keys) ? keys : [keys];
+      const url = `${baseEndpoint}/bulk`;
+      const response = await fetch(`https://api.cloudflare.com/client/v4${url}`, {
+        method: "DELETE",
+        headers: {
+          "Authorization": `Bearer ${client.apiToken}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(keyArray)
+      });
+      if (!response.ok) {
+        throw new Error(`KV DELETE BULK failed: ${response.status}`);
+      }
+    },
+    async list(options) {
+      const queryParams = new URLSearchParams();
+      if (options?.limit) {
+        queryParams.set("limit", options.limit.toString());
+      }
+      if (options?.prefix) {
+        queryParams.set("prefix", options.prefix);
+      }
+      if (options?.cursor) {
+        queryParams.set("cursor", options.cursor);
+      }
+      const queryString = queryParams.toString();
+      const url = queryString ? `${baseEndpoint}/keys?${queryString}` : `${baseEndpoint}/keys`;
+      const data = await client.get(url);
+      if (data.list_complete) {
+        return {
+          list_complete: true,
+          keys: data.keys.map((k) => ({
+            name: k.name,
+            expiration: k.expiration,
+            metadata: k.metadata
+          })),
+          cacheStatus: null
+        };
+      } else {
+        return {
+          list_complete: false,
+          keys: data.keys.map((k) => ({
+            name: k.name,
+            expiration: k.expiration,
+            metadata: k.metadata
+          })),
+          cursor: data.cursor,
+          cacheStatus: null
+        };
+      }
+    },
+    async getWithMetadata(key, options) {
+      if (Array.isArray(key)) {
+        const type2 = typeof options === "string" ? options : options?.type || "text";
+        const results = /* @__PURE__ */ new Map();
+        for (const k of key) {
+          const result = await getValueWithMetadata(k, type2);
+          results.set(k, result);
+        }
+        return results;
+      }
+      const type = typeof options === "string" ? options : options?.type;
+      return getValueWithMetadata(key, type);
+    }
+  };
+  return kvNamespace;
+}
+
+class D1PreparedStatementImpl {
+  constructor(query, client, databaseId) {
+    this.query = query;
+    this.client = client;
+    this.databaseId = databaseId;
+  }
+  bindings = [];
+  bind(...values) {
+    this.bindings = values;
+    return this;
+  }
+  async run() {
+    const endpoint = `/accounts/${this.client.getAccountId()}/d1/database/${this.databaseId}/query`;
+    const data = await this.client.post(endpoint, {
+      sql: this.query,
+      params: this.bindings
+    });
+    const result = data[0];
+    return {
+      success: result.success,
+      results: result.results,
+      meta: {
+        served_by: result.meta.served_by || "",
+        duration: result.meta.duration || 0,
+        changes: result.meta.changes || 0,
+        last_row_id: result.meta.last_row_id || 0,
+        changed_db: result.meta.changed_db || false,
+        size_after: result.meta.size_after || 0,
+        rows_read: result.meta.rows_read || 0,
+        rows_written: result.meta.rows_written || 0
+      }
+    };
+  }
+  async all() {
+    return this.run();
+  }
+  async first(colName) {
+    const result = await this.run();
+    if (!result.results || result.results.length === 0) {
+      return null;
+    }
+    const firstRow = result.results[0];
+    if (colName && typeof firstRow === "object" && firstRow !== null) {
+      return firstRow[colName] ?? null;
+    }
+    return firstRow;
+  }
+  async raw(options) {
+    const result = await this.run();
+    if (!result.results || result.results.length === 0) {
+      return [];
+    }
+    const raw = result.results.map((row) => {
+      if (typeof row === "object" && row !== null) {
+        return Object.values(row);
+      }
+      return row;
+    });
+    if (options?.columnNames && result.results.length > 0) {
+      const firstRow = result.results[0];
+      if (typeof firstRow === "object" && firstRow !== null) {
+        const columnNames = Object.keys(firstRow);
+        return [columnNames, ...raw];
+      }
+    }
+    return raw;
+  }
+}
+function createD1Binding$1(client, databaseId) {
+  return {
+    prepare(query) {
+      return new D1PreparedStatementImpl(query, client, databaseId);
+    },
+    async batch(statements) {
+      const endpoint = `/accounts/${client.getAccountId()}/d1/database/${databaseId}/query`;
+      const queries = statements.map((stmt) => {
+        const impl = stmt;
+        return {
+          sql: impl.query,
+          params: impl.bindings
+        };
+      });
+      const data = await client.post(endpoint, queries);
+      return data.map((result) => ({
+        success: result.success,
+        results: result.results,
+        meta: {
+          served_by: result.meta.served_by || "",
+          duration: result.meta.duration || 0,
+          changes: result.meta.changes || 0,
+          last_row_id: result.meta.last_row_id || 0,
+          changed_db: result.meta.changed_db || false,
+          size_after: result.meta.size_after || 0,
+          rows_read: result.meta.rows_read || 0,
+          rows_written: result.meta.rows_written || 0
+        }
+      }));
+    },
+    async exec(query) {
+      const endpoint = `/accounts/${client.getAccountId()}/d1/database/${databaseId}/query`;
+      const data = await client.post(endpoint, {
+        sql: query
+      });
+      return {
+        count: data.length,
+        duration: data.reduce((acc, r) => acc + (r.meta.duration || 0), 0)
+      };
+    },
+    dump() {
+      throw new Error("D1 dump() is deprecated and not supported");
+    }
+  };
+}
+
+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("Not implemented");
+  return createR2Binding$1(config, bucketName);
 }
 function createKVBinding(config, namespaceId) {
-  throw new Error("Not implemented");
+  const client = new CloudflareAPIClient(config.accountId, config.apiToken);
+  return createKVBinding$1(client, namespaceId);
 }
 function createD1Binding(config, databaseId) {
-  throw new Error("Not implemented");
+  const client = new CloudflareAPIClient(config.accountId, config.apiToken);
+  return createD1Binding$1(client, databaseId);
 }
 
 export { createD1Binding, createKVBinding, createR2Binding };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openwrangler",
-  "version": "0.0.2",
+  "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.4"
+    "@bino0216/nitro-cloudflare-dev": "0.2.6"
   },
   "scripts": {
-    "dev": "nuxi dev playground",
+    "dev": "cd ./playground && pnpm dev",
     "build": "unbuild"
   }
 }