feat: add support for typed APIs with zod (#264)

.vscode/launch.json

@@ -31,5 +31,22 @@
       "cwd": "${workspaceFolder}/apps/test-app/",
       "outFiles": ["${workspaceFolder}/**/*.js", "!**/node_modules/**"]
     }
+    {
+      "type": "node",
+      "name": "synth apps/tests/aws-runtime-cdk",
+      "request": "launch",
+      "runtimeExecutable": "node",
+      "runtimeArgs": [
+        "--nolazy",
+        "-r",
+        "ts-node/register/transpile-only",
+        "--enable-source-maps"
+      ],
+      "args": ["src/app.ts"],
+      "console": "integratedTerminal",
+      "internalConsoleOptions": "openOnSessionStart",
+      "cwd": "${workspaceFolder}/apps/tests/aws-runtime-cdk",
+      "outFiles": ["${workspaceFolder}/**/*.js", "!**/node_modules/**"]
+    }
   ]
 }

README.md

@@ -69,10 +69,10 @@ With our plug-and-play foundation blocks, you can use as much or as little as ne
 Easily create scalable, event-driven APIs with code-first routes.
 
 ```ts
-import { api, ApiResponse } from "@eventual/core";
+import { api, HttpResponse } from "@eventual/core";
 
 api.post("/echo", async (request) => {
-  return new ApiResponse(await request.text());
+  return new HttpResponse(await request.text());
 });
 ```
 
@@ -87,7 +87,7 @@ interface MyEvent {
 
 export const myEvent = event<MyEvent>("MyEvent");
 
-myEvent.onEvent((e) => {
+myEvent.onEvent("onMyEvent", (e) => {
   console.log(e.key);
 });
 ```

apps/test-app-runtime/src/bench.ts

@@ -1,6 +1,6 @@
-import { AwsHttpServiceClient } from "@eventual/aws-client";
+import { AWSHttpEventualClient } from "@eventual/aws-client";
 
-const workflowClient = new AwsHttpServiceClient({
+const workflowClient = new AWSHttpEventualClient({
   serviceUrl: process.env.EVENTUAL_SERVICE_URL ?? "",
 });
 

apps/test-app-runtime/src/open-account.ts

@@ -1,4 +1,4 @@
-import { activity, api, ApiResponse, event, workflow } from "@eventual/core";
+import { activity, api, event, HttpResponse, workflow } from "@eventual/core";
 
 import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
 import {
@@ -77,7 +77,7 @@ api.post("/open-account", async (request) => {
     input,
   });
 
-  return new ApiResponse(JSON.stringify(response), {
+  return new HttpResponse(JSON.stringify(response), {
     headers: {
       "Content-Type": "application/json",
     },
@@ -87,7 +87,7 @@ api.post("/open-account", async (request) => {
 
 const openAccountEvent = event<OpenAccountRequest>("OpenAccount");
 
-openAccountEvent.onEvent(async (event) => {
+openAccountEvent.onEvent("onOpenAccountEvent", async (event) => {
   await openAccount.startExecution({
     input: event,
   });

apps/test-app-sst/services/functions/service.ts

@@ -1,4 +1,4 @@
-import { event, activity, workflow, api, ApiResponse } from "@eventual/core";
+import { event, activity, workflow, api, HttpResponse } from "@eventual/core";
 
 api.post("/work", async (request) => {
   const items: string[] = await request.json();
@@ -7,7 +7,7 @@ api.post("/work", async (request) => {
     input: items,
   });
 
-  return new ApiResponse(JSON.stringify({ executionId }), {
+  return new HttpResponse(JSON.stringify({ executionId }), {
     status: 200,
   });
 });

apps/test-app/src/app.ts

@@ -17,9 +17,7 @@ const stack = new Stack(app, "test-eventual");
 const benchService = new eventual.Service(stack, "Benchmark", {
   entry: require.resolve("test-app-runtime/lib/time-benchmark.js"),
   workflows: {
-    orchestrator: {
-      reservedConcurrentExecutions: 100,
-    },
+    reservedConcurrentExecutions: 100,
   },
 });
 

apps/test-app/src/slack-bot.ts

@@ -1,13 +1,15 @@
 import { App, CfnOutput, Stack, aws_secretsmanager } from "aws-cdk-lib";
 import * as eventual from "@eventual/aws-cdk";
 
+import type * as slackbot from "test-app-runtime/lib/slack-bot.js";
+
 const app = new App();
 
 const stack = new Stack(app, "slack-service");
 
 const slackSecrets = new aws_secretsmanager.Secret(stack, "SlackSecrets");
 
-const slackBot = new eventual.Service(stack, "slack-bot", {
+const slackBot = new eventual.Service<typeof slackbot>(stack, "slack-bot", {
   name: "slack-bot",
   entry: require.resolve("test-app-runtime/lib/slack-bot.js"),
   environment: {

apps/tests/aws-runtime-cdk/src/app.ts

@@ -13,6 +13,8 @@ import { Queue } from "aws-cdk-lib/aws-sqs";
 import path from "path";
 import { ChaosExtension } from "./chaos-extension";
 
+import type * as testServiceRuntime from "tests-runtime";
+
 const app = new App();
 
 const stack = new Stack(app, "eventual-tests");
@@ -25,16 +27,21 @@ const role = new Role(stack, "testRole", {
 
 const testQueue = new Queue(stack, "testQueue");
 
-const testService = new eventual.Service(stack, "testService", {
-  name: "eventual-tests",
-  entry: require.resolve("tests-runtime"),
-  environment: {
-    TEST_QUEUE_URL: testQueue.queueUrl,
-  },
-  logging: {
-    logLevel: LogLevel.DEBUG,
-  },
-});
+const testService = new eventual.Service<typeof testServiceRuntime>(
+  stack,
+  "testService",
+  {
+    name: "eventual-tests",
+    entry: require.resolve("tests-runtime"),
+    environment: {
+      TEST_QUEUE_URL: testQueue.queueUrl,
+    },
+    logging: {
+      logLevel: LogLevel.DEBUG,
+    },
+    commands: {},
+  }
+);
 
 testService.api.grantInvokeHttpServiceApi(role);
 testService.cliRole.grantAssumeRole(role);
@@ -69,11 +76,12 @@ chaosExtension.grantReadWrite(role);
  * Async lambda test.
  */
 
+const entry = path.join(
+  require.resolve("tests-runtime"),
+  "../async-writer-handler.js"
+);
 const asyncWriterFunction = new NodejsFunction(stack, "asyncWriterFunction", {
-  entry: path.join(
-    require.resolve("tests-runtime"),
-    "../async-writer-handler.js"
-  ),
+  entry,
   handler: "handle",
   environment: {
     TEST_SERVICE_URL: testService.api.gateway.apiEndpoint,

apps/tests/aws-runtime/test/async-writer-handler.ts

@@ -1,7 +1,7 @@
 import { Handler } from "aws-lambda";
-import { AwsHttpServiceClient } from "@eventual/aws-client";
+import { AWSHttpEventualClient } from "@eventual/aws-client";
 
-const serviceClient = new AwsHttpServiceClient({
+const serviceClient = new AWSHttpEventualClient({
   serviceUrl: process.env.TEST_SERVICE_URL ?? "",
 });
 

apps/tests/aws-runtime/test/runtime-test-harness.ts

@@ -8,13 +8,13 @@ import {
   WorkflowOutput,
   ExecutionHandle,
 } from "@eventual/core";
-import { AwsHttpServiceClient } from "@eventual/aws-client";
+import { AWSHttpEventualClient } from "@eventual/aws-client";
 import { chaosSSMParamName, serviceUrl } from "./env.js";
 import { ChaosRule } from "./chaos-extension/chaos-engine.js";
 import { SSMChaosClient } from "./chaos-extension/chaos-client.js";
 import { SSMClient } from "@aws-sdk/client-ssm";
 
-const serviceClient = new AwsHttpServiceClient({
+const serviceClient = new AWSHttpEventualClient({
   serviceUrl: serviceUrl(),
   region: "us-east-1",
 });

apps/tests/aws-runtime/test/test-service.ts

@@ -13,8 +13,7 @@ import {
   EventualError,
   signal,
   duration,
-  api,
-  ApiResponse,
+  command,
 } from "@eventual/core";
 import { SendMessageCommand, SQSClient } from "@aws-sdk/client-sqs";
 import { AsyncWriterTestEvent } from "./async-writer-handler.js";
@@ -322,6 +321,7 @@ const SignalEventPayload = z.object({
 const signalEvent = event("SignalEvent", SignalEventPayload);
 
 export const onSignalEvent = signalEvent.onEvent(
+  "onSignalEvent",
   async ({ executionId, signalId, proxy }) => {
     console.debug("received signal event", { executionId, signalId, proxy });
     if (proxy) {
@@ -395,7 +395,7 @@ export const timedWorkflow = workflow("timedWorkflow", async () => {
 const resumeSignal = signal("resume");
 const notifyEvent = event<{ executionId: string }>("notify");
 
-notifyEvent.onEvent(async ({ executionId }) => {
+notifyEvent.onEvent("onNotifyEvent", async ({ executionId }) => {
   await resumeSignal.sendSignal(executionId);
 });
 
@@ -428,12 +428,53 @@ export const allCommands = workflow("allCommands", async (_, context) => {
   return { signalCount: n };
 });
 
-export const userApi = api.get(
-  "/hello",
+export const helloApi = command(
+  "helloApi",
   {
-    memorySize: 512,
+    path: "/hello",
   },
   async () => {
-    return new ApiResponse("hello world");
+    return "hello world";
+  }
+);
+
+// provide a schema for the parameters
+export const typed1 = command(
+  "typed1",
+  {
+    path: "/user/typed1/:userId",
+    input: z.object({
+      userId: z.string(),
+    }),
+  },
+  async ({ userId }) => {
+    return {
+      userId: userId,
+      createdTime: new Date(0).toISOString(),
+    };
+  }
+);
+
+const User = z.object({
+  userId: z.string(),
+  createdTime: z.date(),
+});
+
+// provide a schema for the output body
+export const typed2 = command(
+  "typed2",
+  {
+    path: "/user/typed2/:userId",
+    method: "GET",
+    input: z.object({
+      userId: z.string(),
+    }),
+    output: User,
+  },
+  async (request) => {
+    return {
+      userId: request.userId,
+      createdTime: new Date(0),
+    };
   }
 );

apps/tests/aws-runtime/test/tester.test.ts

@@ -128,7 +128,59 @@ eventualRuntimeTestHarness(
 const url = serviceUrl();
 
 test("hello API should route and return OK response", async () => {
-  const response = await (await fetch(`${url}/hello`)).text();
+  const restResponse = await (await fetch(`${url}/hello`)).json();
+  const rpcResponse = await (
+    await fetch(`${url}/_rpc/helloApi`, {
+      method: "POST",
+    })
+  ).json();
+
+  expect(restResponse).toEqual("hello world");
+  expect(rpcResponse).toEqual("hello world");
+});
+
+test("params with schema should parse", async () => {
+  const restResponse = await (
+    await fetch(`${url}/user/typed1/my-user-id`)
+  ).json();
+
+  const rpcResponse = await (
+    await fetch(`${url}/_rpc/typed1`, {
+      method: "POST",
+      body: JSON.stringify({
+        userId: "my-user-id",
+      }),
+    })
+  ).json();
+
+  const expectedResponse = {
+    userId: "my-user-id",
+    createdTime: new Date(0).toISOString(),
+  };
+
+  expect(restResponse).toEqual(expectedResponse);
+  expect(rpcResponse).toEqual(expectedResponse);
+});
 
-  expect(response).toEqual("hello world");
+test("output with schema should serialize", async () => {
+  const restResponse = await (
+    await fetch(`${url}/user/typed2/my-user-id`)
+  ).json();
+
+  const rpcResponse = await (
+    await fetch(`${url}/_rpc/typed2`, {
+      method: "POST",
+      body: JSON.stringify({
+        userId: "my-user-id",
+      }),
+    })
+  ).json();
+
+  const expected = {
+    userId: "my-user-id",
+    createdTime: new Date(0).toISOString(),
+  };
+
+  expect(restResponse).toEqual(expected);
+  expect(rpcResponse).toEqual(expected);
 });

package.json

@@ -19,7 +19,7 @@
     "lint": "eslint . --fix",
     "prepare": "husky install",
     "test": "NODE_OPTIONS=--experimental-vm-modules turbo run test",
-    "test:runtime": "pnpm --filter tests-runtime test:runtime",
+    "test:runtime": "pnpm --filter tests-runtime test:runtime-deploy",
     "test:cli": "pnpm --filter tests-runtime test:cli",
     "test:smoke": "./scripts/smoke-test",
     "typecheck": "tsc -b",

packages/@eventual/aws-cdk/src/activities.ts

@@ -27,7 +27,7 @@ export interface ActivitiesProps {
   workflows: IWorkflows;
   scheduler: IScheduler;
   environment?: Record<string, string>;
-  events: Events;
+  events: Events<any>;
   logging: Logging;
   service: IService;
   readonly api: IServiceApi;
@@ -101,7 +101,7 @@ export class Activities
     });
 
     this.worker = new ServiceFunction(this, "Worker", {
-      code: props.build.getCode(props.build.activities.default.file),
+      code: props.build.getCode(props.build.activities.file),
       functionName: `${props.serviceName}-activity-handler`,
       serviceType: ServiceType.ActivityWorker,
       memorySize: 512,