feat: add rest support

tests/mocks/relay.ts

@@ -1,31 +1,59 @@
 import z from "zod";
 
-import { procedure } from "../../libraries/procedure.ts";
+import { rpc } from "../../libraries/procedure.ts";
 import { Relay } from "../../libraries/relay.ts";
+import { route } from "../../libraries/route.ts";
 import { UserSchema } from "./user.ts";
 
 export const relay = new Relay({
-  user: {
-    create: procedure
-      .method("user:create")
-      .params(UserSchema.omit({ id: true, createdAt: true }))
-      .result(z.string()),
-    get: procedure.method("user:get").params(z.string().check(z.uuid())).result(UserSchema),
-    update: procedure.method("user:update").params(
-      z.tuple([
-        z.string(),
-        z.object({
-          name: z.string().optional(),
-          email: z.string().check(z.email()).optional(),
-        }),
-      ]),
-    ),
-    delete: procedure.method("user:delete").params(z.string().check(z.uuid())),
+  rpc: {
+    user: {
+      create: rpc
+        .method("user:create")
+        .params(UserSchema.omit({ id: true, createdAt: true }))
+        .result(z.string()),
+      get: rpc.method("user:get").params(z.string().check(z.uuid())).result(UserSchema),
+      update: rpc.method("user:update").params(
+        z.tuple([
+          z.string(),
+          z.object({
+            name: z.string().optional(),
+            email: z.string().check(z.email()).optional(),
+          }),
+        ]),
+      ),
+      delete: rpc.method("user:delete").params(z.string().check(z.uuid())),
+    },
+    numbers: {
+      add: rpc
+        .method("number:add")
+        .params(z.tuple([z.number(), z.number()]))
+        .result(z.number()),
+    },
   },
-  numbers: {
-    add: procedure
-      .method("number:add")
-      .params(z.tuple([z.number(), z.number()]))
-      .result(z.number()),
+  rest: {
+    user: {
+      create: route
+        .post("/users")
+        .body(UserSchema.omit({ id: true, createdAt: true }))
+        .response(z.string()),
+      get: route.get("/users/:userId").params({ userId: z.string() }).response(UserSchema),
+      update: route
+        .put("/users/:userId")
+        .params({ userId: z.string() })
+        .body(
+          z.object({
+            name: z.string().optional(),
+            email: z.string().check(z.email()).optional(),
+          }),
+        ),
+      delete: route.delete("/users/:userId").params({ userId: z.string().check(z.uuid()) }),
+    },
+    numbers: {
+      add: route
+        .post("/numbers/add")
+        .body(z.tuple([z.number(), z.number()]))
+        .response(z.number()),
+    },
   },
 });

tests/mocks/server.ts

@@ -6,37 +6,65 @@ import { User } from "./user.ts";
 
 export let users: User[] = [];
 
-export const api = new RelayApi({
-  procedures: [
-    relay.method("user:create").handle(async ({ name, email }) => {
-      const id = crypto.randomUUID();
-      users.push({ id, name, email, createdAt: new Date() });
-      return id;
-    }),
-    relay.method("user:get").handle(async (userId) => {
-      const user = users.find((user) => user.id === userId);
-      if (user === undefined) {
-        return new NotFoundError();
+export const api = new RelayApi([
+  relay.method("user:create").handle(async ({ name, email }) => {
+    const id = crypto.randomUUID();
+    users.push({ id, name, email, createdAt: new Date() });
+    return id;
+  }),
+  relay.method("user:get").handle(async (userId) => {
+    const user = users.find((user) => user.id === userId);
+    if (user === undefined) {
+      return new NotFoundError();
+    }
+    return user;
+  }),
+  relay.method("user:update").handle(async ([userId, { name, email }]) => {
+    for (const user of users) {
+      if (user.id === userId) {
+        user.name = name ?? user.name;
+        user.email = email ?? user.email;
+        break;
       }
-      return user;
+    }
+  }),
+  relay.method("user:delete").handle(async (userId) => {
+    users = users.filter((user) => user.id !== userId);
+  }),
+  relay
+    .method("number:add")
+    .actions([[addNumbers, (params) => params]])
+    .handle(async (_, { sum }) => {
+      return sum;
     }),
-    relay.method("user:update").handle(async ([userId, { name, email }]) => {
-      for (const user of users) {
-        if (user.id === userId) {
-          user.name = name ?? user.name;
-          user.email = email ?? user.email;
-          break;
-        }
+  relay.post("/users").handle(async ({ name, email }) => {
+    const id = crypto.randomUUID();
+    users.push({ id, name, email, createdAt: new Date() });
+    return id;
+  }),
+  relay.get("/users/:userId").handle(async ({ userId }) => {
+    const user = users.find((user) => user.id === userId);
+    if (user === undefined) {
+      return new NotFoundError();
+    }
+    return user;
+  }),
+  relay.put("/users/:userId").handle(async ({ userId }, { name, email }) => {
+    for (const user of users) {
+      if (user.id === userId) {
+        user.name = name ?? user.name;
+        user.email = email ?? user.email;
+        break;
       }
+    }
+  }),
+  relay.delete("/users/:userId").handle(async ({ userId }) => {
+    users = users.filter((user) => user.id !== userId);
+  }),
+  relay
+    .post("/numbers/add")
+    .actions([[addNumbers, (body) => body]])
+    .handle(async (_, { sum }) => {
+      return sum;
     }),
-    relay.method("user:delete").handle(async (userId) => {
-      users = users.filter((user) => user.id !== userId);
-    }),
-    relay
-      .method("number:add")
-      .actions([[addNumbers, (params) => params]])
-      .handle(async (_, { sum }) => {
-        return sum;
-      }),
-  ],
-});
+]);

tests/procedure.test.ts

@@ -19,7 +19,15 @@ describe("Procedure", () => {
         },
       },
       async (request) => {
-        return api.call(await api.parse(request));
+        switch (request.headers.get("x-relay-type")) {
+          case "rest": {
+            return api.rest(request);
+          }
+          case "rpc": {
+            return api.rpc(await api.parse(request));
+          }
+        }
+        return new Response(null, { status: 404 });
       },
     );
     client = relay.client({
@@ -31,34 +39,69 @@ describe("Procedure", () => {
     await server.shutdown();
   });
 
-  it("should successfully relay users", async () => {
-    const userId = await client.user.create({ name: "John Doe", email: "john.doe@fixture.none" });
+  describe("RPC", () => {
+    it("should successfully relay users", async () => {
+      const userId = await client.rpc.user.create({ name: "John Doe", email: "john.doe@fixture.none" });
 
-    assertEquals(typeof userId, "string");
-    assertEquals(users.length, 1);
+      assertEquals(typeof userId, "string");
+      assertEquals(users.length, 1);
 
-    const user = await client.user.get(userId);
+      const user = await client.rpc.user.get(userId);
 
-    assertEquals(user.createdAt instanceof Date, true);
+      assertEquals(user.createdAt instanceof Date, true);
 
-    await client.user.update([userId, { name: "Jane Doe", email: "jane.doe@fixture.none" }]);
+      await client.rpc.user.update([userId, { name: "Jane Doe", email: "jane.doe@fixture.none" }]);
 
-    assertEquals(users.length, 1);
-    assertObjectMatch(users[0], {
-      name: "Jane Doe",
-      email: "jane.doe@fixture.none",
+      assertEquals(users.length, 1);
+      assertObjectMatch(users[0], {
+        name: "Jane Doe",
+        email: "jane.doe@fixture.none",
+      });
+
+      await client.rpc.user.delete(userId);
+
+      assertEquals(users.length, 0);
     });
 
-    await client.user.delete(userId);
+    it("should successfully run .actions", async () => {
+      assertEquals(await client.rpc.numbers.add([1, 1]), 2);
+    });
 
-    assertEquals(users.length, 0);
+    it("should reject .actions with error", async () => {
+      await assertRejects(() => client.rpc.numbers.add([-1, 1]), "Invalid input numbers added");
+    });
   });
 
-  it("should successfully run .actions", async () => {
-    assertEquals(await client.numbers.add([1, 1]), 2);
-  });
+  describe("REST", () => {
+    it("should successfully relay users", async () => {
+      const userId = await client.rest.user.create({ name: "John Doe", email: "john.doe@fixture.none" });
 
-  it("should reject .actions with error", async () => {
-    await assertRejects(() => client.numbers.add([-1, 1]), "Invalid input numbers added");
+      assertEquals(typeof userId, "string");
+      assertEquals(users.length, 1);
+
+      const user = await client.rest.user.get({ userId });
+
+      assertEquals(user.createdAt instanceof Date, true);
+
+      await client.rest.user.update({ userId }, { name: "Jane Doe", email: "jane.doe@fixture.none" });
+
+      assertEquals(users.length, 1);
+      assertObjectMatch(users[0], {
+        name: "Jane Doe",
+        email: "jane.doe@fixture.none",
+      });
+
+      await client.rest.user.delete({ userId });
+
+      assertEquals(users.length, 0);
+    });
+
+    it("should successfully run .actions", async () => {
+      assertEquals(await client.rest.numbers.add([1, 1]), 2);
+    });
+
+    it("should reject .actions with error", async () => {
+      await assertRejects(() => client.rest.numbers.add([-1, 1]), "Invalid input numbers added");
+    });
   });
 });