Errors

Author: penalosa

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "worker-functions",
-  "version": "0.5.0",
+  "version": "0.5.7",
   "description": "Full-stack Typesafety with Cloudflare Workers 👷",
   "main": "generated-client/index.ts",
   "scripts": {
@@ -35,6 +35,7 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "cross-fetch": "^3.1.5"
+    "cross-fetch": "^3.1.5",
+    "devalue": "^4.3.0"
   }
 }

package.json

@@ -1,30 +1,61 @@
 import type { WorkerTypeFns } from "./type-gen";
-import { fetch } from "cross-fetch";
-
+import { fetch as crossFetch } from "cross-fetch";
+import * as devalue from "devalue";
 const ourFetch = async (
+  fetchImpl: typeof crossFetch,
   endpoint: string,
   functionName: string,
   ...params: any
 ) => {
-  const resp = await fetch(`${endpoint}/${encodeURIComponent(functionName)}`, {
-    body: JSON.stringify(params),
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-    },
-  });
+  const resp = await fetchImpl(
+    `${endpoint}/${encodeURIComponent(functionName)}`,
+    {
+      body: devalue.stringify(params, {
+        Error: (e) => e instanceof Error && e.message
+      }),
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      }
+    }
+  );
 
-  if (resp.ok) return resp.json();
+  if (resp.ok) {
+    const errorHeader = devalue.parse(
+      resp.headers.get("X-Worker-Functions-Error"),
+      {
+        Error: (m) => new Error(m)
+      }
+    );
+    if (errorHeader !== null) {
+      throw errorHeader;
+    }
+    return devalue.parse(await resp.text(), {
+      Error: (m) => new Error(m)
+    });
+  }
+  throw new Error("Failed to fetch");
 };
 
-export function WorkerClient(endpoint: string) {
+export function WorkerClient(
+  endpoint: string,
+  options: { fetch?: typeof crossFetch } = {
+    fetch: crossFetch
+  }
+) {
   return new Proxy(
     {},
     {
       get: (_, fn) => {
         // @ts-ignore
-        return (...params) => ourFetch(endpoint, fn, ...params);
-      },
+        return (...params) =>
+          ourFetch(
+            options.fetch ?? crossFetch,
+            endpoint,
+            fn as string,
+            ...params
+          );
+      }
     }
   ) as WorkerTypeFns;
 }

templates/client.ts

@@ -1,3 +1,5 @@
+import * as devalue from "devalue";
+
 export default {
   async fetch(
     request: Request,
@@ -28,13 +30,31 @@ export default {
     const functionName = decodeURIComponent(url.pathname.split("/")[1]);
     let input: any[] = [];
     try {
-      input = (await request.json()) as unknown[];
+      input = devalue.parse(await request.text(), {
+        Error: (m) => new Error(m)
+      }) as unknown[];
     } catch {}
-    return Response.json(await functions[functionName].bind(env)(...input), {
-      headers: {
-        "Access-Control-Allow-Origin": "*",
-        "Access-Control-Allow-Method": "POST"
+    let data: any = null;
+    let error: any = null;
+    try {
+      data = await functions[functionName].bind(env)(...input);
+    } catch (e) {
+      error = e;
+    }
+    return new Response(
+      devalue.stringify(data, {
+        Error: (e) => e instanceof Error && e.message
+      }),
+      {
+        headers: {
+          "X-Worker-Functions-Error": devalue.stringify(error, {
+            Error: (e) => e instanceof Error && e.message
+          }),
+          "Content-Type": "application/json",
+          "Access-Control-Allow-Origin": "*",
+          "Access-Control-Allow-Method": "POST"
+        }
       }
-    });
+    );
   }
 };