rewrite

README.md

@@ -35,7 +35,7 @@ service = "<worker-name>"
 environment = "production"
 ```
 
-### Start proxy
+### Start proxy for dev
 
 Remote mode
 
@@ -83,10 +83,25 @@ export const handle = ({ event, resolve }) => {
 };
 ```
 
+## Using `wrangler-proxy` to expose workers API
+
+Init worker
+
+```
+npm create cloudflare@2 - .
+```
+
+```ts
+// file: src/index.ts
+import { createWorker } from 'wrangler-proxy';
+
+export default createWorker();
+```
+
 ## Roadmap
 
 - ❌ Not started
-- 🟡 Partially implemented
+- 🟡 Not tested
 - ✅ Complete
 
 ### D1Database
@@ -133,9 +148,9 @@ import { createKV } from 'wrangler-proxy';
 | ------------------- | ------ |
 | `put()`             | 🟡     |
 | `get()`             | 🟡     |
-| `getWithMetadata()` | ❌     |
-| `delete()`          | ❌     |
-| `list()`            | ❌     |
+| `getWithMetadata()` | 🟡     |
+| `delete()`          | 🟡     |
+| `list()`            | 🟡     |
 
 ### `waitUntil`
 

package.json

@@ -10,6 +10,7 @@
   },
   "devDependencies": {
     "@cloudflare/workers-types": "^4.20230814.0",
+    "@types/node": "^20.5.2",
     "esbuild": "^0.19.2",
     "typescript": "^5.1.6"
   },

src/data.ts

@@ -1,21 +1,15 @@
-interface Result {
-  status: 200 | 500;
-}
-
-interface SuccessResult<T> extends Result {
-  status: 200;
-  data: T;
-}
-
-interface ErrorResult extends Result {
-  status: 500;
-  error: Error;
-}
-
-interface PostData {
+export interface Params {
   proxyType: string;
   name: string;
-  payload: any;
+  metadata: any;
 }
 
-export type { ErrorResult, PostData, Result, SuccessResult };
+export type Data = ReadableStream<any> | null;
+
+export const jsonInit: ResponseInit = {
+  headers: { 'Content-Type': 'application/json' },
+};
+
+export const stringInit: ResponseInit = {
+  headers: { 'Content-Type': 'text/plain' },
+};

src/factory.ts

@@ -1,33 +1,45 @@
-import { PostData } from './data';
+import { Data, Params } from './data';
 import { D1DatabaseExecProxy } from './proxies/d1_database/exec/proxy';
 import { D1DatabasePreparedStatementAllProxy } from './proxies/d1_database/prepared_statement/all/proxy';
 import { D1DatabasePreparedStatementFirstProxy } from './proxies/d1_database/prepared_statement/first/proxy';
 import { D1DatabasePreparedStatementRawProxy } from './proxies/d1_database/prepared_statement/raw/proxy';
 import { D1DatabasePreparedStatementRunProxy } from './proxies/d1_database/prepared_statement/run/proxy';
 import { FetcherFetchProxy } from './proxies/fetcher/fetch/proxy';
+import { KVDeleteProxy } from './proxies/kv/delete/proxy';
 import { KVGetProxy } from './proxies/kv/get/proxy';
+import { KVGetWithMetadataProxy } from './proxies/kv/getWithMetadata/proxy';
+import { KVListProxy } from './proxies/kv/list/proxy';
 import { KVPutProxy } from './proxies/kv/put/proxy';
 
 class ProxyFactory {
-  public static getProxy(postData: PostData) {
-    const { proxyType, name, payload } = postData;
+  public static getProxy(params: Params, data: Data) {
+    const { proxyType, name, metadata } = params;
     switch (proxyType) {
-      case D1DatabasePreparedStatementAllProxy.proxyType:
-        return new D1DatabasePreparedStatementAllProxy({ name, payload });
       case D1DatabasePreparedStatementFirstProxy.proxyType:
-        return new D1DatabasePreparedStatementFirstProxy({ name, payload });
+        return new D1DatabasePreparedStatementFirstProxy({ name, metadata });
       case D1DatabasePreparedStatementRunProxy.proxyType:
-        return new D1DatabasePreparedStatementRunProxy({ name, payload });
+        return new D1DatabasePreparedStatementRunProxy({ name, metadata });
+      case D1DatabasePreparedStatementAllProxy.proxyType:
+        return new D1DatabasePreparedStatementAllProxy({
+          name,
+          metadata,
+        });
       case D1DatabasePreparedStatementRawProxy.proxyType:
-        return new D1DatabasePreparedStatementRawProxy({ name, payload });
+        return new D1DatabasePreparedStatementRawProxy({ name, metadata });
       case D1DatabaseExecProxy.proxyType:
-        return new D1DatabaseExecProxy({ name, payload });
+        return new D1DatabaseExecProxy({ name, metadata });
       case FetcherFetchProxy.proxyType:
-        return new FetcherFetchProxy({ name, payload });
-      case KVGetProxy.proxyType:
-        return new KVGetProxy({ name, payload });
+        return new FetcherFetchProxy({ name, metadata, data });
       case KVPutProxy.proxyType:
-        return new KVPutProxy({ name, payload });
+        return new KVPutProxy({ name, metadata, data });
+      case KVGetProxy.proxyType:
+        return new KVGetProxy({ name, metadata });
+      case KVGetWithMetadataProxy.proxyType:
+        return new KVGetWithMetadataProxy({ name, metadata });
+      case KVDeleteProxy.proxyType:
+        return new KVDeleteProxy({ name, metadata });
+      case KVListProxy.proxyType:
+        return new KVListProxy({ name, metadata });
       default:
         throw new Error('Unknown proxy type.');
     }

src/proxies/d1_database/exec/proxy.ts

@@ -1,28 +1,33 @@
+import { jsonInit } from '../../../data';
 import { Proxy } from '../../proxy';
 
-interface Payload {
+interface Metadata {
   query: string;
 }
 
-class D1DatabaseExecProxy extends Proxy<Payload> {
+class D1DatabaseExecProxy extends Proxy<Metadata> {
   static readonly proxyType = 'D1DatabaseExecProxy';
   constructor({
     host,
     name,
-    payload,
+    metadata,
   }: {
     host?: string;
     name: string;
-    payload: Payload;
+    metadata: Metadata;
   }) {
     const proxyType = D1DatabaseExecProxy.proxyType;
-    super({ proxyType, host, name, payload });
+    super({ proxyType, host, name, metadata, data: null });
   }
-  execute(env: any) {
-    const { name } = this,
-      { query } = this.payload,
-      d1 = env[name] as D1Database;
-    return d1.exec(query);
+  async execute(env: any) {
+    const { name, metadata } = this,
+      { query } = metadata,
+      d1 = env[name] as D1Database,
+      result = await d1.exec(query);
+    return new Response(JSON.stringify(result), jsonInit);
+  }
+  receive(response: Response): Promise<any> {
+    return response.json();
   }
 }
 

src/proxies/d1_database/prepared_statement/all/proxy.ts

@@ -1,32 +1,36 @@
+import { jsonInit } from '../../../../data';
 import { Proxy } from '../../../proxy';
 
-interface Payload {
+interface Metadata {
   query: string;
   values?: any[];
 }
 
-class D1DatabasePreparedStatementAllProxy extends Proxy<Payload> {
+class D1DatabasePreparedStatementAllProxy extends Proxy<Metadata> {
   static readonly proxyType = 'D1DatabasePreparedStatementAllProxy';
   constructor({
     host,
     name,
-    payload,
+    metadata,
   }: {
     host?: string;
     name: string;
-    payload: Payload;
+    metadata: Metadata;
   }) {
     const proxyType = D1DatabasePreparedStatementAllProxy.proxyType;
-    super({ proxyType, host, name, payload });
+    super({ proxyType, host, name, metadata, data: null });
   }
   async execute(env: any): Promise<any> {
     const d1 = env[this.name] as D1Database,
-      { query, values } = this.payload!,
+      { query, values } = this.metadata,
       result = await d1
         .prepare(query)
         .bind(...(values ?? []))
         .all();
-    return result;
+    return new Response(JSON.stringify(result), jsonInit);
+  }
+  receive(response: Response): Promise<any> {
+    return response.json();
   }
 }
 

src/proxies/d1_database/prepared_statement/first/proxy.ts

@@ -1,32 +1,36 @@
+import { jsonInit } from '../../../../data';
 import { Proxy } from '../../../proxy';
 
-interface Payload {
+interface Metadata {
   query: string;
   values?: any[];
   colName?: string;
 }
 
-class D1DatabasePreparedStatementFirstProxy extends Proxy<Payload> {
+class D1DatabasePreparedStatementFirstProxy extends Proxy<Metadata> {
   static readonly proxyType = 'D1DatabasePreparedStatementFirstProxy';
   constructor({
     host,
     name,
-    payload,
+    metadata,
   }: {
     host?: string;
     name: string;
-    payload: Payload;
+    metadata: Metadata;
   }) {
     const proxyType = D1DatabasePreparedStatementFirstProxy.proxyType;
-    super({ proxyType, host, name, payload });
+    super({ proxyType, host, name, metadata, data: null });
   }
   async execute(env: any): Promise<any> {
     const d1 = env[this.name] as D1Database,
-      { query, values, colName } = this.payload!,
+      { query, values, colName } = this.metadata!,
       statement1 = d1.prepare(query).bind(...(values ?? [])),
       statement2 = colName ? statement1.first(colName) : statement1.first(),
       result = await statement2;
-    return result;
+    return new Response(JSON.stringify(result), jsonInit);
+  }
+  receive(response: Response): Promise<any> {
+    return response.json();
   }
 }
 

src/proxies/d1_database/prepared_statement/proxy.ts

@@ -4,48 +4,62 @@ import { D1DatabasePreparedStatementFirstProxy } from './first/proxy';
 import { D1DatabasePreparedStatementRawProxy } from './raw/proxy';
 import { D1DatabasePreparedStatementRunProxy } from './run/proxy';
 
-interface Payload {
+interface Metadata {
   query: string;
   values?: any[];
 }
 
 class D1DatabasePreparedStatementProxy
-  extends ProxyHolder<Payload>
+  extends ProxyHolder<Metadata>
   implements D1PreparedStatement
 {
   bind(...values: any[]): D1DatabasePreparedStatementProxy {
-    const { host, name } = this,
-      { query } = this.payload!,
-      payload = { query, values };
-    return new D1DatabasePreparedStatementProxy({ host, name, payload });
+    const { host, name, metadata } = this,
+      { query } = metadata;
+    return new D1DatabasePreparedStatementProxy({
+      host,
+      name,
+      metadata: { query, values },
+      data: null,
+    });
   }
   async first<T = unknown>(colName?: string | undefined): Promise<T> {
-    const { host, name } = this,
-      { query, values } = this.payload,
+    const { host, name, metadata } = this,
+      { query, values } = metadata,
       proxy = new D1DatabasePreparedStatementFirstProxy({
         host,
         name,
-        payload: { query, values, colName },
+        metadata: { query, values, colName },
       });
-    return proxy.post<T>();
+    return proxy.post();
   }
   async run<T = unknown>(): Promise<D1Result<T>> {
-    const { host, name } = this,
-      payload = this.payload,
-      proxy = new D1DatabasePreparedStatementRunProxy({ host, name, payload });
-    return proxy.post<D1Result<T>>();
+    const { host, name, metadata } = this,
+      proxy = new D1DatabasePreparedStatementRunProxy({
+        host,
+        name,
+        metadata,
+      });
+    return proxy.post();
   }
   async all<T = unknown>(): Promise<D1Result<T>> {
-    const { host, name } = this,
-      payload = this.payload,
-      proxy = new D1DatabasePreparedStatementAllProxy({ host, name, payload });
-    return proxy.post<D1Result<T>>();
+    const { host, name, metadata } = this,
+      proxy = new D1DatabasePreparedStatementAllProxy({
+        host,
+        name,
+        metadata,
+      });
+    return proxy.post();
   }
-  raw<T = unknown>(): Promise<T[]> {
-    const { host, name } = this,
-      payload = this.payload,
-      proxy = new D1DatabasePreparedStatementRawProxy({ host, name, payload });
-    return proxy.post<T[]>();
+  async raw<T = unknown>(): Promise<T[]> {
+    const { host, metadata, name } = this,
+      { query } = metadata,
+      proxy = new D1DatabasePreparedStatementRawProxy({
+        host,
+        name,
+        metadata: { query },
+      });
+    return proxy.post();
   }
 }