standard-schema (#155)

* Add standard-schema

* WIP: 型エラーは消えた

* Fix test

* Fix examples

* Remove zod and valibot unused types

* Remove express zod, valibot type utils

* Remove OpenAPI zod, valibot types

* Simplify req/res validator

* Simplify validator

* Fix eslint

* format

* Fix examples

* Simplify OpenAPI

* Move ss

* Simplify

* Remove unused code

* Fix CI

* Reorganize ss validator

* ApiEndpointsSchema

* Fix error

* update doc

* Fix example

Author: mpppk

examples/misc/express/valibot/express.ts

@@ -1,7 +1,7 @@
 import express from "express";
 import { asAsync } from "@notainc/typed-api-spec/express";
+import { ToHandlers, typed } from "@notainc/typed-api-spec/express";
 import { pathMap } from "../../spec/valibot";
-import { ToHandlers, typed } from "@notainc/typed-api-spec/express/valibot";
 
 const emptyMiddleware = (
   req: express.Request,
@@ -20,7 +20,7 @@ const newApp = () => {
   // const wApp = app as TRouter<typeof pathMap>;
   // ```
   const wApp = asAsync(typed(pathMap, app));
-  wApp.get("/users", emptyMiddleware, (req, res) => {
+  wApp.get("/users", emptyMiddleware, async (req, res) => {
     // eslint-disable-next-line no-constant-condition
     if (false) {
       // @ts-expect-error params is not defined because pathMap["/users"]["get"].params is not defined
@@ -29,41 +29,42 @@ const newApp = () => {
 
     // validate method is available in res.locals
     // validate(req).query() is equals to pathMap["/users"]["get"].query.safeParse(req.query)
-    const { data, error } = res.locals.validate(req).query();
-    if (data !== undefined) {
-      // res.status(200).json() accepts only the response schema defined in pathMap["/users"]["get"].res["200"]
-      res.status(200).json({ userNames: [`page${data.page}#user1`] });
-    } else {
+    const r = await res.locals.validate(req).query();
+    if (r.issues) {
       // res.status(400).json() accepts only the response schema defined in pathMap["/users"]["get"].res["400"]
-      res.status(400).json({ errorMessage: error.toString() });
+      return res.status(400).json({ errorMessage: r.issues.toString() });
     }
+    // res.status(200).json() accepts only the response schema defined in pathMap["/users"]["get"].res["200"]
+    return res.status(200).json({ userNames: [`page${r.value.page}#user1`] });
   });
-  wApp.post("/users", (req, res) => {
-    // validate(req).body() is equals to pathMap["/users"]["post"].body.safeParse(req.body)
-    const { data, error } = res.locals.validate(req).body();
+
+  wApp.post("/users", async (req, res) => {
     {
       // Request header also can be validated
       res.locals.validate(req).headers();
     }
-    if (data !== undefined) {
-      // res.status(200).json() accepts only the response schema defined in pathMap["/users"]["post"].res["200"]
-      res.status(200).json({ userId: data.userName + "#0" });
-    } else {
+
+    // validate(req).body() is equals to pathMap["/users"]["post"].body.safeParse(req.body)
+    const r = await res.locals.validate(req).body();
+    if (r.issues) {
       // res.status(400).json() accepts only the response schema defined in pathMap["/users"]["post"].res["400"]
-      res.status(400).json({ errorMessage: error.toString() });
+      return res.status(400).json({ errorMessage: r.issues.toString() });
     }
+    // res.status(200).json() accepts only the response schema defined in pathMap["/users"]["post"].res["200"]
+    return res.status(200).json({ userId: r.value.userName + "#0" });
   });
 
-  const getUserHandler: Handlers["/users/:userId"]["get"] = (req, res) => {
-    const { data: params, error } = res.locals.validate(req).params();
-
-    if (params !== undefined) {
-      // res.status(200).json() accepts only the response schema defined in pathMap["/users/:userId"]["get"].res["200"]
-      res.status(200).json({ userName: "user#" + params.userId });
-    } else {
+  const getUserHandler: Handlers["/users/:userId"]["get"] = async (
+    req,
+    res,
+  ) => {
+    const r = await res.locals.validate(req).params();
+    if (r.issues) {
       // res.status(400).json() accepts only the response schema defined in pathMap["/users/:userId"]["get"].res["400"]
-      res.status(400).json({ errorMessage: error.toString() });
+      return res.status(400).json({ errorMessage: r.issues.toString() });
     }
+    // res.status(200).json() accepts only the response schema defined in pathMap["/users/:userId"]["get"].res["200"]
+    return res.status(200).json({ userName: "user#" + r.value.userId });
   };
   wApp.get("/users/:userId", getUserHandler);
 

examples/misc/express/valibot/openapi/index.ts

@@ -2,8 +2,10 @@ import express from "express";
 import * as v from "valibot";
 import cors from "cors";
 import { OpenAPIV3_1 } from "openapi-types";
-import { ValibotOpenApiEndpoints } from "@notainc/typed-api-spec/valibot/openapi";
-import { toOpenApiDoc } from "@notainc/typed-api-spec/valibot";
+import {
+  OpenApiEndpointsSchema,
+  toOpenApiDoc,
+} from "@notainc/typed-api-spec/core";
 
 const openapiBaseDoc: Omit<OpenAPIV3_1.Document, "paths"> = {
   openapi: "3.1.0",
@@ -45,7 +47,7 @@ const apiEndpoints = {
       },
     },
   },
-} satisfies ValibotOpenApiEndpoints;
+} satisfies OpenApiEndpointsSchema;
 
 const newApp = () => {
   const app = express();

examples/misc/express/zod/express.ts

@@ -1,6 +1,6 @@
 import express from "express";
 import { pathMap } from "../../spec/zod";
-import { ToHandlers, typed } from "@notainc/typed-api-spec/express/zod";
+import { ToHandlers, typed } from "@notainc/typed-api-spec/express";
 import { asAsync } from "@notainc/typed-api-spec/express";
 
 const emptyMiddleware = (
@@ -20,7 +20,7 @@ const newApp = () => {
   // const wApp = app as TRouter<typeof pathMap>;
   // ```
   const wApp = asAsync(typed(pathMap, app));
-  wApp.get("/users", emptyMiddleware, (req, res) => {
+  wApp.get("/users", emptyMiddleware, async (req, res) => {
     // eslint-disable-next-line no-constant-condition
     if (false) {
       // @ts-expect-error params is not defined because pathMap["/users"]["get"].params is not defined
@@ -29,41 +29,42 @@ const newApp = () => {
 
     // validate method is available in res.locals
     // validate(req).query() is equals to pathMap["/users"]["get"].query.safeParse(req.query)
-    const { data, error } = res.locals.validate(req).query();
-    if (data !== undefined) {
-      // res.status(200).json() accepts only the response schema defined in pathMap["/users"]["get"].res["200"]
-      res.status(200).json({ userNames: [`page${data.page}#user1`] });
-    } else {
+    const r = await res.locals.validate(req).query();
+    if (r.issues) {
       // res.status(400).json() accepts only the response schema defined in pathMap["/users"]["get"].res["400"]
-      res.status(400).json({ errorMessage: error.toString() });
+      return res.status(400).json({ errorMessage: r.issues.toString() });
     }
+    // res.status(200).json() accepts only the response schema defined in pathMap["/users"]["get"].res["200"]
+    return res.status(200).json({ userNames: [`page${r.value.page}#user1`] });
   });
-  wApp.post("/users", (req, res) => {
-    // validate(req).body() is equals to pathMap["/users"]["post"].body.safeParse(req.body)
-    const { data, error } = res.locals.validate(req).body();
+
+  wApp.post("/users", async (req, res) => {
     {
       // Request header also can be validated
       res.locals.validate(req).headers();
     }
-    if (data !== undefined) {
-      // res.status(200).json() accepts only the response schema defined in pathMap["/users"]["post"].res["200"]
-      res.status(200).json({ userId: data.userName + "#0" });
-    } else {
+
+    // validate(req).body() is equals to pathMap["/users"]["post"].body.safeParse(req.body)
+    const r = await res.locals.validate(req).body();
+    if (r.issues) {
       // res.status(400).json() accepts only the response schema defined in pathMap["/users"]["post"].res["400"]
-      res.status(400).json({ errorMessage: error.toString() });
+      return res.status(400).json({ errorMessage: r.issues.toString() });
     }
+    // res.status(200).json() accepts only the response schema defined in pathMap["/users"]["post"].res["200"]
+    return res.status(200).json({ userId: r.value.userName + "#0" });
   });
 
-  const getUserHandler: Handlers["/users/:userId"]["get"] = (req, res) => {
-    const { data: params, error } = res.locals.validate(req).params();
-
-    if (params !== undefined) {
-      // res.status(200).json() accepts only the response schema defined in pathMap["/users/:userId"]["get"].res["200"]
-      res.status(200).json({ userName: "user#" + params.userId });
-    } else {
+  const getUserHandler: Handlers["/users/:userId"]["get"] = async (
+    req,
+    res,
+  ) => {
+    const r = await res.locals.validate(req).params();
+    if (r.issues) {
       // res.status(400).json() accepts only the response schema defined in pathMap["/users/:userId"]["get"].res["400"]
-      res.status(400).json({ errorMessage: error.toString() });
+      return res.status(400).json({ errorMessage: r.issues.toString() });
     }
+    // res.status(200).json() accepts only the response schema defined in pathMap["/users/:userId"]["get"].res["200"]
+    return res.status(200).json({ userName: "user#" + r.value.userId });
   };
   wApp.get("/users/:userId", getUserHandler);
 

examples/misc/express/zod/openapi/index.ts

@@ -3,8 +3,10 @@ import cors from "cors";
 import { OpenAPIV3_1 } from "openapi-types";
 import "zod-openapi/extend";
 import z from "zod";
-import { toOpenApiDoc } from "@notainc/typed-api-spec/zod/openapi";
-import { ZodOpenApiEndpoints } from "@notainc/typed-api-spec/zod/openapi";
+import {
+  OpenApiEndpointsSchema,
+  toOpenApiDoc,
+} from "@notainc/typed-api-spec/core";
 
 const openapiBaseDoc: Omit<OpenAPIV3_1.Document, "paths"> = {
   openapi: "3.1.0",
@@ -48,15 +50,15 @@ const apiEndpoints = {
       },
     },
   },
-} satisfies ZodOpenApiEndpoints;
+} satisfies OpenApiEndpointsSchema;
 
 const newApp = () => {
   const app = express();
   app.use(express.json());
   app.use(cors());
   // const wApp = asAsync(typed(apiEndpoints, app));
-  app.get("/openapi", (req, res) => {
-    const openapi = toOpenApiDoc(openapiBaseDoc, apiEndpoints);
+  app.get("/openapi", async (req, res) => {
+    const openapi = await toOpenApiDoc(openapiBaseDoc, apiEndpoints);
     res.status(200).json(openapi);
   });
   return app;

examples/misc/fastify/zod/fastify.ts

@@ -6,7 +6,7 @@ import {
   ZodTypeProvider,
 } from "fastify-type-provider-zod";
 import { pathMap } from "../../spec/zod";
-import { toRoutes } from "@notainc/typed-api-spec/fastify/zod";
+import { toRoutes } from "@notainc/typed-api-spec/fastify";
 import { ZodError } from "zod";
 const fastify = Fastify({ logger: true });
 
@@ -31,7 +31,8 @@ const routes = toRoutes(pathMap);
 server.route({
   ...routes["/users"]["get"],
   handler: async (request, reply) => {
-    const page = request.query.page;
+    type Query = { page: string };
+    const { page } = request.query as Query;
     if (Number.isNaN(Number(page))) {
       return reply.status(400).send({ errorMessage: "page is not a number" });
     }
@@ -52,7 +53,8 @@ const _noExecution = () => {
         // @ts-expect-error noexist is not defined in pathMap["/users"]["get"]
         request.query.noexist;
       }
-      const page = request.query.page;
+      type Query = { page: string };
+      const { page } = request.query as Query;
       return { userNames: [`page${page}#user1`] };
     },
   );
@@ -61,7 +63,8 @@ const _noExecution = () => {
 server.route({
   ...routes["/users"]["post"],
   handler: async (request, reply) => {
-    const userName = request.body.userName;
+    type Body = { userName: string };
+    const { userName } = request.body as Body;
     return reply
       .header("Content-Type", "application/json")
       .send({ userId: userName + "#0" });
@@ -71,7 +74,8 @@ server.route({
 server.route({
   ...routes["/users/:userId"]["get"],
   handler: async (request) => {
-    const userId = request.params.userId;
+    type Params = { userId: string };
+    const { userId } = request.params as Params;
     return { userName: `user#${userId}` };
   },
 });

examples/misc/package.json

@@ -1,10 +1,10 @@
 {
   "scripts": {
-    "format": "prettier --write ",
+    "format": "prettier --write .",
     "watch:type-check": "npx tsc --noEmit --watch",
     "test": "run-p test:*",
-    "test:lint": "eslint ",
-    "test:format": "prettier --check ",
+    "test:lint": "eslint .",
+    "test:format": "prettier --check .",
     "test:type-check": "tsc --noEmit",
     "ex:express:zod:server": "tsx express/zod/express.ts",
     "ex:express:zod:client": "tsx express/zod/fetch.ts",

examples/misc/simple/withValidation.ts

@@ -1,7 +1,7 @@
-import { newZodValidator, ZodApiEndpoints } from "@notainc/typed-api-spec/zod";
 import { withValidation } from "@notainc/typed-api-spec/fetch";
 import { z } from "zod";
 import { SpecValidatorError } from "@notainc/typed-api-spec/fetch";
+import { ApiEndpointsSchema } from "@notainc/typed-api-spec/core";
 
 const GITHUB_API_ORIGIN = "https://api.github.com";
 
@@ -12,21 +12,20 @@ const spec = {
       responses: { 200: { body: z.object({ names: z.string().array() }) } },
     },
   },
-} satisfies ZodApiEndpoints;
+} satisfies ApiEndpointsSchema;
 const spec2 = {
   "/repos/:owner/:repo/topics": {
     get: {
       // Invalid response schema
       responses: { 200: { body: z.object({ noexist: z.string() }) } },
     },
   },
-} satisfies ZodApiEndpoints;
+} satisfies ApiEndpointsSchema;
 
 const main = async () => {
   {
     // const fetchT = fetch as FetchT<typeof GITHUB_API_ORIGIN, Spec>;
-    const { req: reqValidator, res: resValidator } = newZodValidator(spec);
-    const fetchWithV = withValidation(fetch, spec, reqValidator, resValidator);
+    const fetchWithV = withValidation(fetch, spec);
     const response = await fetchWithV(
       `${GITHUB_API_ORIGIN}/repos/nota/typed-api-spec/topics?page=1`,
       { headers: { Accept: "application/vnd.github+json" } },
@@ -41,16 +40,15 @@ const main = async () => {
 
   {
     // const fetchT = fetch as FetchT<typeof GITHUB_API_ORIGIN, Spec>;
-    const { req: reqValidator, res: resValidator } = newZodValidator(spec2);
-    const fetchWithV = withValidation(fetch, spec2, reqValidator, resValidator);
+    const fetchWithV = withValidation(fetch, spec2);
     try {
       await fetchWithV(
         `${GITHUB_API_ORIGIN}/repos/nota/typed-api-spec/topics?page=1`,
         { headers: { Accept: "application/vnd.github+json" } },
       );
     } catch (e) {
       if (e instanceof SpecValidatorError) {
-        console.log("error thrown", e.error);
+        console.log("error thrown", e);
       } else {
         throw e;
       }

examples/misc/spec/valibot.ts

@@ -1,8 +1,8 @@
-import * as v from "valibot";
 import {
+  ApiEndpointsSchema,
   ToApiEndpoints,
-  ValibotApiEndpoints,
-} from "@notainc/typed-api-spec/valibot";
+} from "@notainc/typed-api-spec/core";
+import * as v from "valibot";
 
 const JsonHeader = v.object({
   "Content-Type": v.literal("application/json"),
@@ -44,5 +44,5 @@ export const pathMap = {
       },
     },
   },
-} satisfies ValibotApiEndpoints;
+} satisfies ApiEndpointsSchema;
 export type PathMap = ToApiEndpoints<typeof pathMap>;

examples/misc/spec/zod.ts

@@ -1,5 +1,8 @@
+import {
+  ApiEndpointsSchema,
+  ToApiEndpoints,
+} from "@notainc/typed-api-spec/core";
 import { z } from "zod";
-import { ToApiEndpoints, ZodApiEndpoints } from "@notainc/typed-api-spec/zod";
 
 const JsonHeader = z.union([
   z.object({ "content-type": z.literal("application/json") }),
@@ -42,5 +45,5 @@ export const pathMap = {
       },
     },
   },
-} satisfies ZodApiEndpoints;
+} satisfies ApiEndpointsSchema;
 export type PathMap = ToApiEndpoints<typeof pathMap>;

examples/misc/tsconfig.json

@@ -1,7 +1,5 @@
 {
-  "exclude": [
-    "../../pkgs/docs"
-  ],
+  "exclude": ["../../pkgs/docs"],
   "compilerOptions": {
     /* Visit https://aka.ms/tsconfig to read more about this file */