openwrangler 0.0.2 → 0.0.3

package/dist/index.mjs

@@ -1,11 +1,398 @@
+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");
+    }
+  };
+}
+
 function createR2Binding(config, bucketName) {
-  throw new Error("Not implemented");
+  throw new Error("R2 binding not yet implemented. Use KV or D1 instead.");
 }
 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.3",
   "type": "module",
   "exports": {
     ".": {
@@ -19,7 +19,7 @@
     "typescript": "^5.7.2",
     "unbuild": "^3.3.1",
     "wrangler": "^3.99.0",
-    "@binochoi/nitro-cloudflare-dev": "npm:@bino0216/nitro-cloudflare-dev@0.2.4"
+    "@binochoi/nitro-cloudflare-dev": "npm:@bino0216/nitro-cloudflare-dev@0.2.5"
   },
   "scripts": {
     "dev": "nuxi dev playground",