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;
-      }),
-  ],
-});
+]);