Allow passing error when transforming outputs in middleware (#684)

## Summary
<!-- Succinctly describe your change, providing context, what you've
changed, and why. -->

Allows passing an `error` when using `onFunctionRun.transformOutput` in
middleware.

Runtime code already supports this, allowing for common actions such as
recreating (or creating new) errors based on data returned from
executions. For example:

```ts
new InngestMiddleware({
  name: "My Middleware",
  init() {
    return {
      onFunctionRun({ fn }) {
        return {
          transformOutput({ result }) {
            if (result.error && result.error instanceof ForbiddenError) {
              return {
                result: {
                  error: new NonRetriableError(result.error.message),
                },
              };
            }
          },
        };
      },
    };
  },
});
```

## Checklist
<!-- Tick these items off as you progress. -->
<!-- If an item isn't applicable, ideally please strikeout the item by
wrapping it in "~~"" and suffix it with "N/A My reason for skipping
this." -->
<!-- e.g. "- [ ] ~~Added tests~~ N/A Only touches docs" -->

- [ ] ~Added a [docs PR](https://github.com/inngest/website) that
references this PR~ N/A Bug fix
- [x] Added unit/integration tests
- [x] Added changesets if applicable

.changeset/smart-years-cry.md

@@ -0,0 +1,5 @@
+---
+"inngest": patch
+---
+
+Allow passing `error` when transforming outputs in middleware

packages/inngest/src/components/InngestMiddleware.test.ts

@@ -3,6 +3,7 @@
 import { Inngest } from "@local/components/Inngest";
 import { referenceFunction } from "@local/components/InngestFunctionReference";
 import { InngestMiddleware } from "@local/components/InngestMiddleware";
+import { NonRetriableError } from "@local/components/NonRetriableError";
 import { ExecutionVersion } from "@local/components/execution/InngestExecution";
 import { type IsEqual, type IsUnknown } from "@local/helpers/types";
 import { StepOpCode } from "@local/types";
@@ -440,6 +441,130 @@ describe("stacking and inference", () => {
         });
       });
     });
+
+    describe("transformOutput", () => {
+      test("can see an error in output context", async () => {
+        let error: Error | undefined;
+
+        const fn = new Inngest({
+          id: "test",
+          middleware: [
+            new InngestMiddleware({
+              name: "mw",
+              init() {
+                return {
+                  onFunctionRun() {
+                    return {
+                      transformOutput({ result }) {
+                        error = result.error as Error;
+                      },
+                    };
+                  },
+                };
+              },
+            }),
+          ],
+        }).createFunction({ id: "" }, { event: "" }, ({ step }) => {
+          throw new Error("test error");
+        });
+
+        await runFnWithStack(fn, {}, { executionVersion: ExecutionVersion.V1 });
+
+        expect(error).toBeInstanceOf(Error);
+      });
+
+      test("can overwrite an existing error in output context", async () => {
+        const fn = new Inngest({
+          id: "test",
+          middleware: [
+            new InngestMiddleware({
+              name: "mw1",
+              init() {
+                return {
+                  onFunctionRun() {
+                    return {
+                      transformOutput() {
+                        return {
+                          result: { error: new Error("foo") },
+                        };
+                      },
+                    };
+                  },
+                };
+              },
+            }),
+            new InngestMiddleware({
+              name: "mw2",
+              init() {
+                return {
+                  onFunctionRun() {
+                    return {
+                      transformOutput() {
+                        return {
+                          result: { error: new Error("bar") },
+                        };
+                      },
+                    };
+                  },
+                };
+              },
+            }),
+          ],
+        }).createFunction({ id: "" }, { event: "" }, () => {
+          throw new Error("test error");
+        });
+
+        const res = await runFnWithStack(
+          fn,
+          {},
+          { executionVersion: ExecutionVersion.V1 }
+        );
+
+        expect(res).toMatchObject({
+          type: "function-rejected",
+          error: { message: "bar" },
+          retriable: true,
+        });
+      });
+
+      test("can set a NonRetriableError", async () => {
+        const fn = new Inngest({
+          id: "test",
+          middleware: [
+            new InngestMiddleware({
+              name: "mw1",
+              init() {
+                return {
+                  onFunctionRun() {
+                    return {
+                      transformOutput() {
+                        return {
+                          result: { error: new NonRetriableError("foo") },
+                        };
+                      },
+                    };
+                  },
+                };
+              },
+            }),
+          ],
+        }).createFunction({ id: "" }, { event: "" }, () => {
+          throw new Error("test error");
+        });
+
+        const res = await runFnWithStack(
+          fn,
+          {},
+          { executionVersion: ExecutionVersion.V1 }
+        );
+
+        expect(res).toMatchObject({
+          type: "function-rejected",
+          error: { message: "foo" },
+          retriable: false,
+        });
+      });
+    });
   });
 
   describe("onSendEvent", () => {

packages/inngest/src/components/InngestMiddleware.ts

@@ -499,7 +499,9 @@ type MiddlewareSendEventOutput = (
 type MiddlewareRunOutput = (ctx: {
   result: Readonly<Pick<OutgoingOp, "error" | "data">>;
   step?: Readonly<Omit<OutgoingOp, "id">>;
-}) => MaybePromise<{ result?: Partial<Pick<OutgoingOp, "data">> } | void>;
+}) => MaybePromise<{
+  result?: Partial<Pick<OutgoingOp, "data" | "error">>;
+} | void>;
 
 type MiddlewareRunFinished = (ctx: {
   result: Readonly<Pick<OutgoingOp, "error" | "data">>;