feat: convert to rpc pattern

tests/mocks/actions.ts

@@ -3,15 +3,13 @@ import z from "zod";
 import { action } from "../../libraries/action.ts";
 import { BadRequestError } from "../../mod.ts";
 
-export const addTwoNumbers = action
-  .make("addTwoNumbers")
-  .input({ a: z.number(), b: z.number() })
-  .output({ added: z.number() })
-  .handle(async ({ a, b }) => {
+export const addNumbers = action
+  .make("number:add")
+  .input(z.tuple([z.number(), z.number()]))
+  .output({ sum: z.number() })
+  .handle(async ([a, b]) => {
     if (a < 0 || b < 0) {
-      return new BadRequestError("Invalid input numbers added");
+      return new BadRequestError("Invalid numbers provided");
     }
-    return {
-      added: a + b,
-    };
+    return { sum: a + b };
   });

tests/mocks/relay.ts

@@ -1,24 +1,31 @@
 import z from "zod";
 
+import { procedure } 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([
-  route
-    .post("/users")
-    .body(UserSchema.omit({ id: true, createdAt: true }))
-    .response(z.string()),
-  route
-    .get("/users/:userId")
-    .params({ userId: z.string().check(z.uuid()) })
-    .response(UserSchema),
-  route
-    .put("/users/:userId")
-    .params({ userId: z.string().check(z.uuid()) })
-    .body(UserSchema.omit({ id: true, createdAt: true })),
-  route.delete("/users/:userId").params({ userId: z.string().check(z.uuid()) }),
-  route.get("/add-two").search({ a: z.coerce.number(), b: z.coerce.number() }).response(z.number()),
-]);
-
-export type RelayRoutes = typeof relay.$inferRoutes;
+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())),
+  },
+  numbers: {
+    add: procedure
+      .method("number:add")
+      .params(z.tuple([z.number(), z.number()]))
+      .result(z.number()),
+  },
+});

tests/mocks/server.ts

@@ -1,40 +1,42 @@
-import { RelayAPI } from "../../libraries/api.ts";
+import { RelayApi } from "../../libraries/api.ts";
 import { NotFoundError } from "../../mod.ts";
-import { addTwoNumbers } from "./actions.ts";
+import { addNumbers } from "./actions.ts";
 import { relay } from "./relay.ts";
 import { User } from "./user.ts";
 
 export let users: User[] = [];
 
-export const api = new RelayAPI({
-  routes: [
-    relay.route("POST", "/users").handle(async ({ name, email }) => {
+export const api = new RelayApi({
+  procedures: [
+    relay.procedure("user:create").handle(async ({ name, email }) => {
       const id = crypto.randomUUID();
       users.push({ id, name, email, createdAt: new Date() });
       return id;
     }),
-    relay.route("GET", "/users/:userId").handle(async ({ userId }) => {
+    relay.procedure("user:get").handle(async (userId) => {
       const user = users.find((user) => user.id === userId);
       if (user === undefined) {
         return new NotFoundError();
       }
       return user;
     }),
-    relay.route("PUT", "/users/:userId").handle(async ({ userId, name, email }) => {
+    relay.procedure("user:update").handle(async ([userId, { name, email }]) => {
       for (const user of users) {
         if (user.id === userId) {
-          user.name = name;
-          user.email = email;
+          user.name = name ?? user.name;
+          user.email = email ?? user.email;
           break;
         }
       }
     }),
-    relay.route("DELETE", "/users/:userId").handle(async ({ userId }) => {
+    relay.procedure("user:delete").handle(async (userId) => {
       users = users.filter((user) => user.id !== userId);
     }),
     relay
-      .route("GET", "/add-two")
-      .actions([addTwoNumbers])
-      .handle(async ({ added }) => added),
+      .procedure("number:add")
+      .actions([[addNumbers, (params) => params]])
+      .handle(async (_, { sum }) => {
+        return sum;
+      }),
   ],
 });