Add "inngest/redwood" serve handler (#31)

jpwilliams · web-flow · commit 8b90c8720efe · 2022-10-26T12:32:17.000+01:00
Adds a new `"inngest/redwood"` import to support the [RedwoodJS](https://redwoodjs.com/) framework, based on #30 to ensure we're covering all bases when adding a new handler. A couple of extra additions are needed: - RedwoodJS [uses Lambda types](https://redwoodjs.com/docs/serverless-functions) to abstract the underlying platform; we can grab the [`aws-lambda`](https://www.npmjs.com/package/aws-lambda) package for this and just import the types. - RedwoodJS performs some interesting redirects in dev, by default exposing [serverless functions](https://redwoodjs.com/docs/serverless-functions) as `/{functionName}` and `/.redwood/functions/{functionName}`, though this can change based on `redwood.toml` configuration (see [Serverless Functions - Developing locally](https://redwoodjs.com/docs/serverless-functions#developing-locally)); it's pertinent here to add the ability to specify a host and path to overwrite the serve URL. The latter point above means there are now two new options for `serve()`: - `serveHost` - The host part of the URL to serve functions from - defaults to the `Host` header value - `servePath` - The path part of the URL to serve functions from - defaults to the `path` passed in the received `APIGatewayProxyEvent`
diff --git a/etc/inngest.api.md b/etc/inngest.api.md
@@ -73,6 +73,8 @@ export interface RegisterOptions {
     fetch?: typeof fetch;
     inngestRegisterUrl?: string;
     landingPage?: boolean;
+    serveHost?: string;
+    servePath?: string;
     signingKey?: string;
 }
 
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "inngest",
-  "version": "0.6.0",
+  "version": "0.6.1-redwood.2",
   "description": "Official SDK for Inngest.com",
   "main": "./index.js",
   "types": "./index.d.ts",
@@ -58,6 +58,7 @@
   "devDependencies": {
     "@inngest/eslint-plugin": "./rules",
     "@microsoft/api-extractor": "^7.31.2",
+    "@types/aws-lambda": "^8.10.108",
     "@types/express": "^4.17.13",
     "@types/jest": "^27.4.1",
     "@types/sha.js": "^2.4.0",
diff --git a/src/cloudflare.ts b/src/cloudflare.ts
@@ -26,7 +26,10 @@ class CloudflareCommHandler extends InngestCommHandler {
       let isIntrospection: boolean;
 
       try {
-        reqUrl = new URL(req.url, `https://${req.headers.get("host") || ""}`);
+        reqUrl = this.reqUrl(
+          req.url,
+          `https://${req.headers.get("host") || ""}`
+        );
 
         isIntrospection = reqUrl.searchParams.has(queryKeys.Introspect);
         reqUrl.searchParams.delete(queryKeys.Introspect);
diff --git a/src/express.ts b/src/express.ts
@@ -128,6 +128,9 @@ export class InngestCommHandler {
    */
   protected readonly showLandingPage: boolean | undefined;
 
+  protected readonly serveHost: string | undefined;
+  protected readonly servePath: string | undefined;
+
   /**
    * A private collection of functions that are being served. This map is used
    * to find and register functions when interacting with Inngest Cloud.
@@ -137,7 +140,14 @@ export class InngestCommHandler {
   constructor(
     nameOrInngest: string | Inngest<any>,
     functions: InngestFunction<any>[],
-    { inngestRegisterUrl, fetch, landingPage, signingKey }: RegisterOptions = {}
+    {
+      inngestRegisterUrl,
+      fetch,
+      landingPage,
+      signingKey,
+      serveHost,
+      servePath,
+    }: RegisterOptions = {}
   ) {
     this.name =
       typeof nameOrInngest === "string" ? nameOrInngest : nameOrInngest.name;
@@ -166,6 +176,8 @@ export class InngestCommHandler {
 
     this.signingKey = signingKey;
     this.showLandingPage = landingPage;
+    this.serveHost = serveHost;
+    this.servePath = servePath;
 
     this.headers = {
       "Content-Type": "application/json",
@@ -200,7 +212,7 @@ export class InngestCommHandler {
 
       let reqUrl;
       try {
-        reqUrl = new URL(req.originalUrl, `${protocol}${hostname || ""}`);
+        reqUrl = this.reqUrl(req.originalUrl, `${protocol}${hostname || ""}`);
         reqUrl.searchParams.delete(queryKeys.Introspect);
       } catch (e) {
         const message =
@@ -326,6 +338,31 @@ export class InngestCommHandler {
     return ["inngest-", `js:v${version}`, ` (${this.frameworkName})`];
   }
 
+  /**
+   * Return an Inngest serve endpoint URL given a potential `path` and `host`.
+   *
+   * Will automatically use the `serveHost` and `servePath` if they have been
+   * set when registering.
+   */
+  protected reqUrl(
+    /**
+     * The path of the Inngest register URL to create. Regardless of the value,
+     * will be overwritten by `servePath` if it has been set.
+     */
+    path?: string,
+
+    /**
+     * The host of the Inngest register URL to create. Regardless of the value,
+     * will be overwritten by `serveHost` if it has been set.
+     */
+    host?: string
+  ): URL {
+    return new URL(
+      this.servePath || path?.trim() || "",
+      this.serveHost || host?.trim() || ""
+    );
+  }
+
   protected registerBody(url: URL): RegisterRequest {
     const body: RegisterRequest = {
       url: url.href,
diff --git a/src/next.ts b/src/next.ts
@@ -21,7 +21,7 @@ class NextCommHandler extends InngestCommHandler {
       try {
         const scheme =
           process.env.NODE_ENV === "development" ? "http" : "https";
-        reqUrl = new URL(
+        reqUrl = this.reqUrl(
           req.url as string,
           `${scheme}://${req.headers.host || ""}`
         );
diff --git a/src/redwood.test.ts b/src/redwood.test.ts
@@ -0,0 +1,26 @@
+import * as RedwoodHandler from "./redwood";
+import { testFramework } from "./test/helpers";
+
+testFramework("Redwood.js", RedwoodHandler, {
+  transformReq: (req, res, env) => {
+    return [
+      {
+        path: req.path,
+        headers: req.headers,
+        httpMethod: req.method,
+        queryStringParameters: req.query,
+        body: req.body as string,
+      },
+      {},
+    ];
+  },
+
+  // eslint-disable-next-line @typescript-eslint/require-await
+  transformRes: async (res, ret: RedwoodHandler.RedwoodResponse) => {
+    return {
+      status: ret.statusCode,
+      body: ret.body || "",
+      headers: ret.headers || {},
+    };
+  },
+});
diff --git a/src/redwood.ts b/src/redwood.ts
@@ -0,0 +1,168 @@
+import type {
+  APIGatewayProxyEvent,
+  Context as LambdaContext,
+} from "aws-lambda";
+import { z } from "zod";
+import {
+  InngestCommHandler,
+  serve as defaultServe,
+  ServeHandler,
+} from "./express";
+import { envKeys, queryKeys } from "./helpers/consts";
+import { devServerUrl } from "./helpers/devserver";
+import { devServerHost } from "./helpers/env";
+import { landing } from "./landing";
+import { IntrospectRequest } from "./types";
+
+export interface RedwoodResponse {
+  statusCode: number;
+  body?: string | null;
+  headers?: Record<string, string>;
+}
+
+class RedwoodCommHandler extends InngestCommHandler {
+  protected override frameworkName = "redwoodjs";
+
+  public override createHandler() {
+    return async (
+      event: APIGatewayProxyEvent,
+      context: LambdaContext
+    ): Promise<RedwoodResponse> => {
+      const headers = { "x-inngest-sdk": this.sdkHeader.join("") };
+      let reqUrl: URL;
+
+      try {
+        const scheme =
+          process.env.NODE_ENV === "development" ? "http" : "https";
+
+        reqUrl = this.reqUrl(
+          event.path,
+          `${scheme}://${event.headers.host || ""}`
+        );
+        reqUrl.searchParams.delete(queryKeys.Introspect);
+      } catch (err) {
+        return {
+          statusCode: 500,
+          body: JSON.stringify(err),
+          headers,
+        };
+      }
+
+      if (!this.signingKey && process.env[envKeys.SigningKey]) {
+        this.signingKey = process.env[envKeys.SigningKey];
+      }
+
+      this._isProd =
+        process.env.VERCEL_ENV === "production" ||
+        process.env.CONTEXT === "production" ||
+        process.env.ENVIRONMENT === "production";
+
+      switch (event.httpMethod) {
+        case "GET": {
+          const showLandingPage = this.shouldShowLandingPage(
+            process.env[envKeys.LandingPage]
+          );
+
+          if (!showLandingPage) break;
+
+          if (
+            Object.hasOwnProperty.call(
+              event.queryStringParameters,
+              queryKeys.Introspect
+            )
+          ) {
+            const introspection: IntrospectRequest = {
+              ...this.registerBody(reqUrl),
+              devServerURL: devServerUrl(devServerHost()).href,
+              hasSigningKey: Boolean(this.signingKey),
+            };
+
+            return {
+              statusCode: 200,
+              body: JSON.stringify(introspection),
+              headers,
+            };
+          }
+
+          // Grab landing page and serve
+          return {
+            statusCode: 200,
+            body: landing,
+            headers: {
+              ...headers,
+              "content-type": "text/html; charset=utf-8",
+            },
+          };
+        }
+
+        case "PUT": {
+          // Push config to Inngest.
+          const { status, message } = await this.register(
+            reqUrl,
+            process.env[envKeys.DevServerUrl]
+          );
+
+          return {
+            statusCode: status,
+            body: JSON.stringify({ message }),
+            headers,
+          };
+        }
+
+        case "POST": {
+          // Inngest is trying to run a step; confirm signed and run.
+          const { fnId, stepId } = z
+            .object({
+              fnId: z.string().min(1),
+              stepId: z.string().min(1),
+            })
+            .parse({
+              fnId: event.queryStringParameters?.[queryKeys.FnId],
+              stepId: event.queryStringParameters?.[queryKeys.StepId],
+            });
+
+          /**
+           * Some requests can be base64 encoded, requiring us to decode it
+           * first before parsing as JSON.
+           */
+          const strJson = event.body
+            ? event.isBase64Encoded
+              ? Buffer.from(event.body, "base64").toString()
+              : event.body
+            : "{}";
+
+          const stepRes = await this.runStep(fnId, stepId, JSON.parse(strJson));
+
+          if (stepRes.status === 500) {
+            return {
+              statusCode: stepRes.status,
+              body: JSON.stringify(stepRes.error),
+              headers,
+            };
+          }
+
+          return {
+            statusCode: stepRes.status,
+            body: JSON.stringify(stepRes.body),
+            headers,
+          };
+        }
+      }
+
+      return {
+        statusCode: 405,
+        headers,
+      };
+    };
+  }
+}
+
+/**
+ * In Redwood.js, serve and register any declared functions with Inngest, making
+ * them available to be triggered by events.
+ *
+ * @public
+ */
+export const serve: ServeHandler = (nameOrInngest, fns, opts): any => {
+  return defaultServe(new RedwoodCommHandler(nameOrInngest, fns, opts));
+};
diff --git a/src/remix.ts b/src/remix.ts
@@ -30,7 +30,10 @@ class RemixCommHandler extends InngestCommHandler {
       let isIntrospection: boolean;
 
       try {
-        reqUrl = new URL(req.url, `https://${req.headers.get("host") || ""}`);
+        reqUrl = this.reqUrl(
+          req.url,
+          `https://${req.headers.get("host") || ""}`
+        );
         isIntrospection = reqUrl.searchParams.has(queryKeys.Introspect);
         reqUrl.searchParams.delete(queryKeys.Introspect);
       } catch (err) {
diff --git a/src/test/helpers.ts b/src/test/helpers.ts
diff --git a/src/types.ts b/src/types.ts
diff --git a/yarn.lock b/yarn.lock

Original file line number	Diff line number	Diff line change
`@@ -73,6 +73,8 @@ export interface RegisterOptions {`
`73`	`73`	`fetch?: typeof fetch;`
`74`	`74`	`inngestRegisterUrl?: string;`
`75`	`75`	`landingPage?: boolean;`
	`76`	`+ serveHost?: string;`
	`77`	`+ servePath?: string;`
`76`	`78`	`signingKey?: string;`
`77`	`79`	`}`
`78`	`80`