Support fastify

examples/express/valibot/express.ts

@@ -1,6 +1,6 @@
 import express from "express";
 import { asAsync } from "../../../src/express";
-import { pathMap } from "./spec";
+import { pathMap } from "../../spec/valibot";
 import { ToHandlers, typed } from "../../../src/express/valibot";
 
 const emptyMiddleware = (

examples/express/valibot/fetch.ts

@@ -1,4 +1,4 @@
-import type { PathMap } from "./spec";
+import type { PathMap } from "../../spec/valibot";
 import JSONT from "../../../src/json";
 import { unreachable } from "../../../src/utils";
 import type FetchT from "../../../src/fetch";

examples/express/zod/express.ts

@@ -1,6 +1,6 @@
 import express from "express";
 import { asAsync } from "../../../src/express";
-import { pathMap } from "./spec";
+import { pathMap } from "../../spec/zod";
 import { ToHandlers, typed } from "../../../src/express/zod";
 
 const emptyMiddleware = (

examples/express/zod/fetch.ts

@@ -1,4 +1,4 @@
-import type { PathMap } from "./spec";
+import type { PathMap } from "../../spec/zod";
 import JSONT from "../../../src/json";
 import { unreachable } from "../../../src/utils";
 import type FetchT from "../../../src/fetch";

examples/fastify/zod/fastify.ts

@@ -0,0 +1,86 @@
+// Import the framework and instantiate it
+import Fastify, { FastifyError } from "fastify";
+import {
+  serializerCompiler,
+  validatorCompiler,
+  ZodTypeProvider,
+} from "fastify-type-provider-zod";
+import { pathMap } from "../../spec/zod";
+import { toRoutes } from "../../../src/fastify/zod";
+import { ZodError } from "zod";
+const fastify = Fastify({ logger: true });
+
+fastify.setValidatorCompiler(validatorCompiler);
+fastify.setSerializerCompiler(serializerCompiler);
+const server = fastify.withTypeProvider<ZodTypeProvider>();
+server.setErrorHandler<ZodError | FastifyError>((error, request, reply) => {
+  if (error instanceof ZodError) {
+    return reply
+      .status(400)
+      .type("application/json")
+      .send({ errorMessage: JSON.stringify(error.issues) });
+  }
+  return reply
+    .status(error.statusCode ?? 500)
+    .type("application/json")
+    .send({ errorMessage: error.message });
+});
+const routes = toRoutes(pathMap);
+
+// Define by using route object
+server.route({
+  ...routes["/users"]["get"],
+  handler: async (request, reply) => {
+    const page = request.query.page;
+    if (Number.isNaN(Number(page))) {
+      return reply.status(400).send({ errorMessage: "page is not a number" });
+    }
+    return { userNames: [`page${page}#user1`] };
+  },
+});
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const _noExecution = () => {
+  // Or you can also define by using RouteShorthandMethod
+  server.get(
+    "/users",
+    {
+      schema: routes["/users"]["get"]["schema"],
+    },
+    async (request) => {
+      {
+        // @ts-expect-error noexist is not defined in pathMap["/users"]["get"]
+        request.query.noexist;
+      }
+      const page = request.query.page;
+      return { userNames: [`page${page}#user1`] };
+    },
+  );
+};
+
+server.route({
+  ...routes["/users"]["post"],
+  handler: async (request, reply) => {
+    const userName = request.body.userName;
+    return reply
+      .header("Content-Type", "application/json")
+      .send({ userId: userName + "#0" });
+  },
+});
+
+server.route({
+  ...routes["/users/:userId"]["get"],
+  handler: async (request) => {
+    const userId = request.params.userId;
+    return { userName: `user#${userId}` };
+  },
+});
+
+(async () => {
+  try {
+    await fastify.listen({ port: 3000 });
+  } catch (err) {
+    fastify.log.error(err);
+    process.exit(1);
+  }
+})();

examples/fastify/zod/fetch.ts

@@ -0,0 +1,79 @@
+import JSONT from "../../../src/json";
+import { unreachable } from "../../../src/utils";
+import type FetchT from "../../../src/fetch";
+import { PathMap } from "../../spec/zod";
+
+const fetchT = fetch as FetchT<typeof origin, PathMap>;
+const origin = "http://localhost:3000";
+const headers = { "Content-Type": "application/json" } as const;
+const JSONT = JSON as JSONT;
+
+const main = async () => {
+  {
+    const path = `${origin}/users?page=1`;
+    const method = "get";
+    const res = await fetchT(path, { method });
+    switch (res.status) {
+      case 200: {
+        // r is the response schema defined in pathMap["/users"]["get"].res["200"]
+        const r = await res.json();
+        console.log(`${path}:${method} => ${r.userNames}`);
+        break;
+      }
+      case 400: {
+        // e is the response schema defined in pathMap["/users"]["get"].res["400"]
+        const e = await res.json();
+        console.log(`${path}:${method} => ${e.errorMessage}`);
+        break;
+      }
+      default:
+        unreachable(res);
+    }
+  }
+  {
+    // case-insensitive method example
+    await fetchT(`${origin}/users?page=1`, { method: "GET" });
+  }
+
+  {
+    const path = `${origin}/users`;
+    const method = "post";
+    const res = await fetchT(path, {
+      method,
+      headers,
+      // body is the request schema defined in pathMap["/users"]["post"].body
+      // stringify is same as JSON.stringify but with common information
+      body: JSONT.stringify({ userName: "user1" }),
+    });
+    if (res.ok) {
+      // r is the response schema defined in pathMap["/users"]["post"].res["20X"]
+      const r = await res.json();
+      console.log(`${path}:${method} => ${r.userId}`);
+      console.log(res.headers.get("Content-Type"));
+    } else {
+      // e is the response schema defined in pathMap["/users"]["post"].res other than "20X"
+      const e = await res.text();
+      console.log(`error:${path}:${method} => ${JSON.stringify(e)}`);
+      console.log(res.status);
+    }
+  }
+
+  {
+    // path parameter example
+    // "/users/:userId" accepts `/users/${string}` pattern
+    const path = `${origin}/users/1`;
+    const method = "get";
+    const res = await fetchT(path, { method });
+    if (res.ok) {
+      // r is the response schema defined in pathMap["/users/:userId"]["get"].res["20X"]
+      const r = await res.json();
+      console.log(`${path}:${method} => ${r.userName}`);
+    } else {
+      // e is the response schema defined in pathMap["/users/:userId"]["get"].res other than "20X"
+      const e = await res.json();
+      console.log(`${path}:${method} => ${e.errorMessage}`);
+    }
+  }
+};
+
+main();

examples/express/valibot/spec.ts → examples/spec/valibot.ts

@@ -1,5 +1,5 @@
 import * as v from "valibot";
-import { ToApiEndpoints, ValibotApiEndpoints } from "../../../src/valibot";
+import { ToApiEndpoints, ValibotApiEndpoints } from "../../src/valibot";
 
 const JsonHeader = v.object({
   "Content-Type": v.literal("application/json"),

examples/express/zod/spec.ts → examples/spec/zod.ts

@@ -1,9 +1,10 @@
 import { z } from "zod";
-import { ToApiEndpoints, ZodApiEndpoints } from "../../../src";
+import { ToApiEndpoints, ZodApiEndpoints } from "../../src";
 
-const JsonHeader = z.object({
-  "Content-Type": z.literal("application/json"),
-});
+const JsonHeader = z.union([
+  z.object({ "content-type": z.string() }),
+  z.object({ "Content-Type": z.string() }),
+]);
 export const pathMap = {
   "/users": {
     get: {