Remove createAsyndMiddleware

* Handle errors fro masync middleware function rejections
* Update readme
* Update JsonRpcMiddleware type

Author: rekmarks

README.md

@@ -39,11 +39,21 @@ They can let processing continue down the stack with `next()`, or complete the r
 engine.push(function (req, res, next, end) {
   if (req.skipCache) return next();
   res.result = getResultFromCache(req);
-  end();
+  return end();
+});
+```
+
+Middleware functions can be `async`:
+
+```js
+engine.push(async function (req, res, next, end) {
+  if (req.method !== targetMethod) return next();
+  res.result = await processTargetMethodRequest(req);
+  return end();
 });
 ```
 
-By passing a _return handler_ to the `next` function, you can get a peek at the result before it returns.
+By passing a _return handler_ to the `next` function, you can get a peek at the response before it is returned to the requester.
 
 ```js
 engine.push(function (req, res, next, end) {
@@ -61,105 +71,43 @@ const subengine = new JsonRpcEngine();
 engine.push(subengine.asMiddleware());
 ```
 
-### `async` Middleware
+### Error Handling
 
-If you require your middleware function to be `async`, use `createAsyncMiddleware`:
+Errors should be handled by throwing inside middleware functions.
 
-```js
-const { createAsyncMiddleware } = require('json-rpc-engine');
-
-let engine = new RpcEngine();
-engine.push(
-  createAsyncMiddleware(async (req, res, next) => {
-    res.result = 42;
-    next();
-  }),
-);
-```
+For backwards compatibility, you can also pass an error to the `end` callback,
+or set the error on the response object, and then call `end` or `next`.
+However, errors must **not** be passed to the `next` callback.
 
-`async` middleware do not take an `end` callback.
-Instead, the request ends if the middleware returns without calling `next()`:
+Errors always take precedent over results.
+If an error is detected, the response's `result` property will be deleted.
 
-```js
-engine.push(
-  createAsyncMiddleware(async (req, res, next) => {
-    res.result = 42;
-    /* The request will end when this returns */
-  }),
-);
-```
-
-The `next` callback of `async` middleware also don't take return handlers.
-Instead, you can `await next()`.
-When the execution of the middleware resumes, you can work with the response again.
-
-```js
-engine.push(
-  createAsyncMiddleware(async (req, res, next) => {
-    res.result = 42;
-    await next();
-    /* Your return handler logic goes here */
-    addToMetrics(res);
-  }),
-);
-```
-
-You can freely mix callback-based and `async` middleware:
+All of the following examples are equivalent.
+It does not matter of the middleware function is synchronous or asynchronous.
 
 ```js
+// Throwing is preferred.
 engine.push(function (req, res, next, end) {
-  if (!isCached(req)) {
-    return next((cb) => {
-      insertIntoCache(res, cb);
-    });
-  }
-  res.result = getResultFromCache(req);
-  end();
+  throw new Error();
 });
 
-engine.push(
-  createAsyncMiddleware(async (req, res, next) => {
-    res.result = 42;
-    await next();
-    addToMetrics(res);
-  }),
-);
-```
-
-### Gotchas
-
-Handle errors via `end(err)`, _NOT_ `next(err)`.
-
-```js
-/* INCORRECT */
+// For backwards compatibility, you can also do this:
 engine.push(function (req, res, next, end) {
-  next(new Error());
+  end(new Error());
 });
 
-/* CORRECT */
 engine.push(function (req, res, next, end) {
-  end(new Error());
+  res.error = new Error();
+  end();
 });
-```
-
-However, `next()` will detect errors on the response object, and cause
-`end(res.error)` to be called.
 
-```js
 engine.push(function (req, res, next, end) {
   res.error = new Error();
-  next(); /* This will cause end(res.error) to be called. */
+  next();
 });
-```
-
-## Running tests
 
-Build the project if not already built:
-
-```bash
-yarn build
-```
-
-```bash
-yarn test
+// INCORRECT. Do not do this:
+engine.push(function (req, res, next, end) {
+  next(new Error());
+});
 ```

src/JsonRpcEngine.ts

@@ -84,7 +84,7 @@ export type JsonRpcMiddleware<T, U> = (
   res: PendingJsonRpcResponse<U>,
   next: JsonRpcEngineNextCallback,
   end: JsonRpcEngineEndCallback,
-) => void;
+) => void | Promise<void>;
 
 /**
  * A JSON-RPC request and response processor.
@@ -382,55 +382,61 @@ export class JsonRpcEngine extends SafeEventEmitter {
    * @returns An array of any error encountered during middleware exection,
    * and a boolean indicating whether the request should end.
    */
-  private static _runMiddleware(
+  private static async _runMiddleware(
     req: JsonRpcRequest<unknown>,
     res: PendingJsonRpcResponse<unknown>,
     middleware: JsonRpcMiddleware<unknown, unknown>,
     returnHandlers: JsonRpcEngineReturnHandler[],
   ): Promise<[unknown, boolean]> {
-    return new Promise((resolve) => {
-      const end: JsonRpcEngineEndCallback = (err?: unknown) => {
-        const error = err || res.error;
-        if (error) {
-          res.error = serializeError(error);
-        }
-        // True indicates that the request should end
-        resolve([error, true]);
-      };
-
-      const next: JsonRpcEngineNextCallback = (
-        returnHandler?: JsonRpcEngineReturnHandler,
-      ) => {
-        if (res.error) {
-          end(res.error);
-        } else {
-          if (returnHandler) {
-            if (typeof returnHandler !== 'function') {
-              end(
-                new EthereumRpcError(
-                  errorCodes.rpc.internal,
-                  `JsonRpcEngine: "next" return handlers must be functions. ` +
-                    `Received "${typeof returnHandler}" for request:\n${jsonify(
-                      req,
-                    )}`,
-                  { request: req },
-                ),
-              );
-            }
-            returnHandlers.push(returnHandler);
-          }
+    let resolve: (value: [unknown, boolean]) => void;
+    const middlewareCallbackPromise = new Promise<[unknown, boolean]>(
+      (_resolve) => {
+        resolve = _resolve;
+      },
+    );
+
+    const end: JsonRpcEngineEndCallback = (err?: unknown) => {
+      const error = err || res.error;
+      if (error) {
+        res.error = serializeError(error);
+      }
+      // True indicates that the request should end
+      resolve([error, true]);
+    };
 
-          // False indicates that the request should not end
-          resolve([null, false]);
+    const next: JsonRpcEngineNextCallback = (
+      returnHandler?: JsonRpcEngineReturnHandler,
+    ) => {
+      if (res.error) {
+        end(res.error);
+      } else {
+        if (returnHandler) {
+          if (typeof returnHandler !== 'function') {
+            end(
+              new EthereumRpcError(
+                errorCodes.rpc.internal,
+                `JsonRpcEngine: "next" return handlers must be functions. ` +
+                  `Received "${typeof returnHandler}" for request:\n${jsonify(
+                    req,
+                  )}`,
+                { request: req },
+              ),
+            );
+          }
+          returnHandlers.push(returnHandler);
         }
-      };
 
-      try {
-        middleware(req, res, next, end);
-      } catch (error) {
-        end(error);
+        // False indicates that the request should not end
+        resolve([null, false]);
       }
-    });
+    };
+
+    try {
+      await middleware(req, res, next, end);
+    } catch (error) {
+      end(error);
+    }
+    return middlewareCallbackPromise;
   }
 
   /**

src/createAsyncMiddleware.ts

@@ -1,5 +1,4 @@
 export * from './idRemapMiddleware';
-export * from './createAsyncMiddleware';
 export * from './createScaffoldMiddleware';
 export * from './getUniqueId';
 export * from './JsonRpcEngine';