openwrangler 0.0.3 → 0.0.5

package/README.md

@@ -0,0 +1,144 @@
+# openwrangler
+
+A library that implements wrangler's remote functionality, allowing you to use Cloudflare bindings via direct REST API calls instead of local simulation.
+
+## Overview
+
+`openwrangler` provides the same binding interface as wrangler's `getPlatformProxy`, but instead of using local miniflare/workerd simulation, it directly calls the Cloudflare REST API. This enables you to work with remote Cloudflare resources during development.
+
+## Installation
+
+```bash
+npm install openwrangler
+# or
+pnpm add openwrangler
+```
+
+## Direct Usage
+
+You can use openwrangler directly in your Node.js applications:
+
+```typescript
+import { getBindings } from 'openwrangler'
+
+const bindings = getBindings({
+  accountId: 'your-account-id',
+  apiToken: 'your-api-token',
+})
+
+// Use bindings just like in Cloudflare Workers
+await bindings.r2.put('image.png', buffer)
+await bindings.kv.get('key')
+await bindings.d1.exec('SELECT * FROM users')
+```
+
+## Nitro Integration
+
+`openwrangler` can be seamlessly integrated with Nitro applications using `@bino0216/nitro-cloudflare-dev`.
+
+### Setup
+
+1. Install the Nitro integration package:
+
+```bash
+npm install npm:@bino0216/nitro-cloudflare-dev
+```
+
+2. Configure remote credentials in your Nitro config:
+
+```typescript
+// nitro.config.ts
+export default defineNitroConfig({
+  cloudflareDev: {
+    remoteCredentials: {
+      accountId: 'your-account-id',
+      apiToken: 'your-api-token',
+    }
+  }
+})
+```
+
+3. Mark bindings as remote in your `wrangler.toml` or `wrangler.json`:
+
+```toml
+# wrangler.toml
+[[r2_buckets]]
+binding = "MY_BUCKET"
+bucket_name = "my-bucket"
+remote = true
+
+[[kv_namespaces]]
+binding = "MY_KV"
+id = "your-kv-id"
+remote = true
+
+[[d1_databases]]
+binding = "MY_DB"
+database_name = "my-database"
+database_id = "your-db-id"
+remote = true
+```
+
+Or in JSON format:
+
+```json
+{
+  "r2_buckets": [
+    {
+      "binding": "MY_BUCKET",
+      "bucket_name": "my-bucket",
+      "remote": true
+    }
+  ],
+  "kv_namespaces": [
+    {
+      "binding": "MY_KV",
+      "id": "your-kv-id",
+      "remote": true
+    }
+  ],
+  "d1_databases": [
+    {
+      "binding": "MY_DB",
+      "database_name": "my-database",
+      "database_id": "your-db-id",
+      "remote": true
+    }
+  ]
+}
+```
+
+When bindings have `remote = true`, Nitro will use openwrangler's implementation to connect to your actual Cloudflare resources instead of local simulation.
+
+## Supported Bindings
+
+- **R2** (`R2Bucket`) - Object storage
+- **KV** (`KVNamespace`) - Key-value storage
+- **D1** (`D1Database`) - SQL database
+
+All types are imported from `@cloudflare/workers-types` to ensure compatibility with Cloudflare Workers.
+
+## Development
+
+```bash
+pnpm install
+pnpm dev      # Run playground
+pnpm build    # Build package
+```
+
+## Project Structure
+
+- `src/index.ts` - Package entry point, `getBindings()` function
+- `playground/` - Nuxt/Nitro v3 based test environment
+- `build.config.ts` - unbuild configuration
+
+## Use Cases
+
+- **Development against production data**: Work with real Cloudflare resources during development
+- **Testing**: Test against actual Cloudflare services without deployment
+- **CI/CD**: Run integration tests against remote Cloudflare resources
+- **Hybrid environments**: Mix local and remote bindings based on your needs
+
+## License
+
+MIT

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,45 +1,116 @@
-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;
+class D1PreparedStatementImpl {
+  constructor(query, client, databaseId) {
+    this.query = query;
+    this.client = client;
+    this.databaseId = databaseId;
   }
-  async get(endpoint, headers) {
-    return this.request("GET", endpoint, void 0, headers);
+  bindings = [];
+  bind(...values) {
+    this.bindings = values;
+    return this;
   }
-  async post(endpoint, body, headers) {
-    return this.request("POST", endpoint, body, headers);
+  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 put(endpoint, body, headers) {
-    return this.request("PUT", endpoint, body, headers);
+  async all() {
+    return this.run();
   }
-  async delete(endpoint, body, headers) {
-    return this.request("DELETE", endpoint, body, headers);
+  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;
   }
-  getAccountId() {
-    return this.accountId;
+  async raw(options) {
+    const result = await this.run();
+    if (!result.results || result.results.length === 0) {
+      return options?.columnNames ? [[], ...[]] : [];
+    }
+    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: true,
+        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");
+    }
+  };
+}
 
 function createKVBinding$1(client, namespaceId) {
   const baseEndpoint = `/accounts/${client.getAccountId()}/storage/kv/namespaces/${namespaceId}`;
@@ -53,7 +124,7 @@ function createKVBinding$1(client, namespaceId) {
       const response = await fetch(`https://api.cloudflare.com/client/v4${url}`, {
         method: "GET",
         headers: {
-          "Authorization": `Bearer ${client.apiToken}`,
+          Authorization: `Bearer ${client.apiToken}`,
           ...headers
         }
       });
@@ -87,7 +158,7 @@ function createKVBinding$1(client, namespaceId) {
       const response = await fetch(`https://api.cloudflare.com/client/v4${url}`, {
         method: "GET",
         headers: {
-          "Authorization": `Bearer ${client.apiToken}`
+          Authorization: `Bearer ${client.apiToken}`
         }
       });
       if (response.status === 404) {
@@ -142,7 +213,7 @@ function createKVBinding$1(client, namespaceId) {
     async put(key, value, options) {
       const url = `${baseEndpoint}/values/${encodeURIComponent(key)}`;
       const headers = {
-        "Authorization": `Bearer ${client.apiToken}`
+        Authorization: `Bearer ${client.apiToken}`
       };
       let body;
       if (typeof value === "string") {
@@ -156,7 +227,8 @@ function createKVBinding$1(client, namespaceId) {
         const chunks = [];
         while (true) {
           const { done, value: chunk } = await reader.read();
-          if (done) break;
+          if (done)
+            break;
           chunks.push(chunk);
         }
         const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
@@ -168,7 +240,7 @@ function createKVBinding$1(client, namespaceId) {
         }
         body = result.buffer;
       } else {
-        throw new Error("Unsupported value type");
+        throw new TypeError("Unsupported value type");
       }
       const queryParams = new URLSearchParams();
       if (options?.expiration) {
@@ -193,7 +265,7 @@ function createKVBinding$1(client, namespaceId) {
       const response = await fetch(`https://api.cloudflare.com/client/v4${url}`, {
         method: "DELETE",
         headers: {
-          "Authorization": `Bearer ${client.apiToken}`
+          Authorization: `Bearer ${client.apiToken}`
         }
       });
       if (!response.ok && response.status !== 404) {
@@ -269,122 +341,485 @@ function createKVBinding$1(client, namespaceId) {
   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 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
+  };
+  for (const [key, value] of Object.entries(headers)) {
+    canonicalHeaders[key.toLowerCase()] = value;
   }
-  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
+  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}
+`,
+    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);
       }
-    };
-  }
-  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;
+      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;
     }
-    return firstRow;
+    const signatureHeaders = await signRequest({
+      method,
+      url,
+      headers: options?.headers || {},
+      body,
+      accessKeyId: r2AccessKeyId,
+      secretAccessKey: r2SecretAccessKey
+    });
+    return fetch(url, {
+      method,
+      headers: {
+        ...options?.headers,
+        ...signatureHeaders
+      },
+      body
+    });
   }
-  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;
+  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
     });
-    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 fetch(url, {
+      method,
+      headers: {
+        ...options?.headers,
+        ...signatureHeaders
       }
-    }
-    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 r2Bucket = {
+    async get(key, options) {
+      const headers = {};
+      if (options?.range) {
+        if (typeof options.range === "object") {
+          const range = options.range;
+          if ("suffix" in range && range.suffix) {
+            headers.Range = `bytes=-${range.suffix}`;
+          } else if ("offset" in range && range.offset !== void 0) {
+            headers.Range = "length" in range && range.length ? `bytes=${range.offset}-${range.offset + range.length - 1}` : `bytes=${range.offset}-`;
+          }
+        }
+      }
+      if (options?.onlyIf) {
+        const onlyIf = options.onlyIf;
+        if (onlyIf.etagMatches) {
+          headers["If-Match"] = onlyIf.etagMatches;
+        }
+        if (onlyIf.etagDoesNotMatch) {
+          headers["If-None-Match"] = onlyIf.etagDoesNotMatch;
+        }
+        if (onlyIf.uploadedBefore) {
+          headers["If-Unmodified-Since"] = onlyIf.uploadedBefore.toUTCString();
+        }
+        if (onlyIf.uploadedAfter) {
+          headers["If-Modified-Since"] = 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 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
+      const r2Object = {
+        key,
+        version: response.headers.get("x-amz-version-id") || "",
+        size: Number.parseInt(response.headers.get("content-length") || "0", 10),
+        etag: response.headers.get("etag") || "",
+        httpEtag: response.headers.get("etag") || "",
+        checksums: {
+          toJSON: () => ({})
+        },
+        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,
+        storageClass: "Standard",
+        range: options?.range ? {
+          offset: 0,
+          length: Number.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(),
+        bytes: async () => new Uint8Array(await response.arrayBuffer()),
+        writeHttpMetadata: ((headers2) => {
+          const metadata = r2Object.httpMetadata;
+          if (metadata.contentType) {
+            headers2.set("content-type", metadata.contentType);
+          }
+          if (metadata.contentLanguage) {
+            headers2.set("content-language", metadata.contentLanguage);
+          }
+          if (metadata.contentDisposition) {
+            headers2.set("content-disposition", metadata.contentDisposition);
+          }
+          if (metadata.contentEncoding) {
+            headers2.set("content-encoding", metadata.contentEncoding);
+          }
+          if (metadata.cacheControl) {
+            headers2.set("cache-control", metadata.cacheControl);
+          }
+          if (metadata.cacheExpiry) {
+            headers2.set("expires", metadata.cacheExpiry.toUTCString());
+          }
+        })
+      };
+      return r2Object;
+    },
+    async put(key, value, options) {
+      const headers = {};
+      if (options?.httpMetadata) {
+        const metadata = options.httpMetadata;
+        if (metadata.contentType) {
+          headers["Content-Type"] = metadata.contentType;
         }
-      }));
+        if (metadata.contentLanguage) {
+          headers["Content-Language"] = metadata.contentLanguage;
+        }
+        if (metadata.contentDisposition) {
+          headers["Content-Disposition"] = metadata.contentDisposition;
+        }
+        if (metadata.contentEncoding) {
+          headers["Content-Encoding"] = metadata.contentEncoding;
+        }
+        if (metadata.cacheControl) {
+          headers["Cache-Control"] = metadata.cacheControl;
+        }
+        if (metadata.cacheExpiry) {
+          headers.Expires = metadata.cacheExpiry.toUTCString();
+        }
+      }
+      if (options?.customMetadata) {
+        for (const [key2, value2] of Object.entries(options.customMetadata)) {
+          headers[`x-amz-meta-${key2}`] = value2;
+        }
+      }
+      let body;
+      if (value === null) {
+        body = "";
+      } else if (value instanceof Blob) {
+        body = await value.arrayBuffer();
+      } else 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: {
+          toJSON: () => ({})
+        },
+        uploaded: /* @__PURE__ */ new Date(),
+        httpMetadata: options?.httpMetadata || {},
+        customMetadata: options?.customMetadata || {},
+        storageClass: "Standard",
+        writeHttpMetadata: () => {
+        }
+      };
     },
-    async exec(query) {
-      const endpoint = `/accounts/${client.getAccountId()}/d1/database/${databaseId}/query`;
-      const data = await client.post(endpoint, {
-        sql: query
+    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 {
-        count: data.length,
-        duration: data.reduce((acc, r) => acc + (r.meta.duration || 0), 0)
+        key,
+        version: response.headers.get("x-amz-version-id") || "",
+        size: Number.parseInt(response.headers.get("content-length") || "0", 10),
+        etag: response.headers.get("etag") || "",
+        httpEtag: response.headers.get("etag") || "",
+        checksums: {
+          toJSON: () => ({})
+        },
+        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,
+        storageClass: "Standard",
+        writeHttpMetadata: () => {
+        }
       };
     },
-    dump() {
-      throw new Error("D1 dump() is deprecated and not supported");
+    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 = Number.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: {
+            toJSON: () => ({})
+          },
+          uploaded: new Date(lastModified),
+          httpMetadata: {},
+          customMetadata: {},
+          storageClass: "Standard",
+          writeHttpMetadata: () => {
+          }
+        });
+      }
+      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;
+}
+
+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 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,11 +1,11 @@
 {
   "name": "openwrangler",
-  "version": "0.0.3",
   "type": "module",
+  "version": "0.0.5",
   "exports": {
     ".": {
-      "import": "./dist/index.mjs",
-      "types": "./dist/index.d.ts"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs"
     }
   },
   "main": "./dist/index.mjs",
@@ -14,15 +14,19 @@
     "dist"
   ],
   "devDependencies": {
+    "@antfu/eslint-config": "^6.7.3",
     "@cloudflare/workers-types": "^4.20251231.0",
+    "eslint": "^9.39.2",
     "nuxt": "^3.15.0",
     "typescript": "^5.7.2",
     "unbuild": "^3.3.1",
-    "wrangler": "^3.99.0",
-    "@binochoi/nitro-cloudflare-dev": "npm:@bino0216/nitro-cloudflare-dev@0.2.5"
+    "wrangler": "^4.54.0",
+    "@bino0216/nitro-cloudflare-dev": "0.2.7"
   },
   "scripts": {
-    "dev": "nuxi dev playground",
-    "build": "unbuild"
+    "dev": "cd ./playground && pnpm dev",
+    "build": "unbuild",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix"
   }
 }