add abort + fix git

Author: Wojciech Wierchola

.gitignore

@@ -2,4 +2,5 @@ node_modules
 browser
 *.js
 *.js.map
-*.d.ts
+*.d.ts
+!index.d.ts

browser.ts

@@ -20,13 +20,25 @@ export const makeApi = <Data extends ApiData>({
       Object.keys(headers).forEach(key => fetchHeaders.set(key, headers[key]));
     }
   }
-  return (action, payload) =>
-    fetch(endpoint, {
-      method: "POST",
-      headers: fetchHeaders,
-      body: JSON.stringify({
-        action,
-        payload
-      })
-    }).then(r => r.json());
+  return (action, payload) => {
+    try {
+      const controller = new AbortController();
+      const signal = controller.signal;
+      const promise = fetch(endpoint, {
+        signal,
+        method: "POST",
+        headers: fetchHeaders,
+        body: JSON.stringify({
+          action,
+          payload
+        })
+      }).then(r => r.json());
+      Object.defineProperty(promise, "abort", {
+        value: () => controller.abort()
+      });
+      return promise;
+    } catch (err) {
+      return Promise.reject(err);
+    }
+  };
 };

index.d.ts

@@ -0,0 +1,31 @@
+export type ActionFunction<Payload = any, Output = any, Context = any> = (
+  payload: Payload,
+  context: Context
+) => Promise<Output>;
+
+export type Unpacked<T> = T extends Promise<infer U> ? U : T;
+
+export type Payload<T extends ActionFunction> = T extends (
+  p: infer P,
+  c: any
+) => any
+  ? P
+  : never;
+
+export type Output<T extends ActionFunction> = T extends (
+  p: any,
+  c: any
+) => infer R
+  ? R
+  : never;
+
+export type ApiData = { [key: string]: ActionFunction };
+
+export type PromiseA<T> = Promise<T> & {
+  abort?: () => void;
+};
+
+export type ApiResolver<D extends ApiData> = <N extends keyof D>(
+  name: N,
+  payload: Payload<D[N]>
+) => PromiseA<Unpacked<Output<D[N]>>>;

node.ts

@@ -1,15 +1,51 @@
-import { ApiResolver, ApiData } from "@webcarrot/api";
+import {
+  ApiResolver,
+  ApiData,
+  Payload,
+  PromiseA,
+  Unpacked,
+  Output
+} from "@webcarrot/api";
+
+const makeError = () => {
+  const error = new Error("Action aborted");
+  error.name === "AbortError";
+  return error;
+};
 
 export const makeApi = <Data extends ApiData, Context>({
   actions,
   context
 }: {
   actions: Data;
   context: Context;
-}): ApiResolver<Data> => async (action, payload) => {
-  if (action in actions) {
-    return await actions[action](payload, context);
-  } else {
-    throw new Error(`Unknown action ${action}`);
-  }
+}): ApiResolver<Data> => <N extends keyof Data>(
+  action: N,
+  payload: Payload<Data[N]>
+): PromiseA<Unpacked<Output<Data[N]>>> => {
+  let aborted = false;
+  const promise = new Promise<Unpacked<Output<Data[N]>>>((resolve, reject) => {
+    if (aborted) {
+      reject(makeError());
+    } else if (action in actions) {
+      actions[action](payload, context).then(
+        data => {
+          if (!aborted) {
+            resolve(data);
+          } else {
+            reject(makeError());
+          }
+        },
+        err => reject(aborted ? makeError() : err)
+      );
+    } else {
+      reject(new Error(`Unknown action ${action}`));
+    }
+  });
+  Object.defineProperty(promise, "abort", {
+    value: () => {
+      aborted = true;
+    }
+  });
+  return promise;
 };