Implement withValidation

Author: mpppk

examples/simple/withValidation.ts

@@ -0,0 +1,60 @@
+import { newZodValidator, ZodApiEndpoints } from "../../src";
+import { ValidateError, withValidation } from "../../src/fetch/validation";
+import { z, ZodError } from "zod";
+
+const GITHUB_API_ORIGIN = "https://api.github.com";
+
+// See https://docs.github.com/ja/rest/repos/repos?apiVersion=2022-11-28#get-all-repository-topics
+const spec = {
+  "/repos/:owner/:repo/topics": {
+    get: {
+      responses: { 200: { body: z.object({ names: z.string().array() }) } },
+    },
+  },
+} satisfies ZodApiEndpoints;
+// type Spec = ToApiEndpoints<typeof spec>;
+const spec2 = {
+  "/repos/:owner/:repo/topics": {
+    get: {
+      responses: { 200: { body: z.object({ noexist: z.string() }) } },
+    },
+  },
+} satisfies ZodApiEndpoints;
+
+const main = async () => {
+  {
+    // const fetchT = fetch as FetchT<typeof GITHUB_API_ORIGIN, Spec>;
+    const { request: reqValidator, response: resValidator } =
+      newZodValidator(spec);
+    const fetchWithV = withValidation(fetch, spec, reqValidator, resValidator);
+    const response = await fetchWithV(
+      `${GITHUB_API_ORIGIN}/repos/mpppk/typed-api-spec/topics?page=1`,
+      { headers: { Accept: "application/vnd.github+json" } },
+    );
+    if (!response.ok) {
+      const { message } = await response.json();
+      return console.error(message);
+    }
+    const { names } = await response.json();
+    console.log(names);
+  }
+
+  {
+    // const fetchT = fetch as FetchT<typeof GITHUB_API_ORIGIN, Spec>;
+    const { request: reqValidator, response: resValidator } =
+      newZodValidator(spec2);
+    const fetchWithV = withValidation(fetch, spec2, reqValidator, resValidator);
+    try {
+      await fetchWithV(
+        `${GITHUB_API_ORIGIN}/repos/mpppk/typed-api-spec/topics?page=1`,
+        { headers: { Accept: "application/vnd.github+json" } },
+      );
+    } catch (e: unknown) {
+      if (e instanceof ValidateError) {
+        console.log("error thrown", (e.error as ZodError).format());
+      }
+    }
+  }
+};
+
+main();

package-lock.json

@@ -14,11 +14,13 @@
     "example:express-zod": "tsx examples/express/zod/express.ts",
     "example:express-zod-fetch": "tsx examples/express/zod/fetch.ts",
     "example:fasitify-zod": "tsx examples/fastify/zod/fastify.ts",
-    "example:fasitify-zod-fetch": "tsx examples/fastify/zod/fetch.ts"
+    "example:fasitify-zod-fetch": "tsx examples/fastify/zod/fetch.ts",
+    "example:withValidation": "tsx examples/simple/withValidation.ts"
   },
   "author": "mpppk",
   "license": "ISC",
   "devDependencies": {
+    "@types/path-to-regexp": "^1.7.0",
     "@types/qs": "^6.9.15",
     "@types/supertest": "^6.0.2",
     "@typescript-eslint/eslint-plugin": "^7.0.0",
@@ -116,5 +118,8 @@
   },
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
-  "types": "./dist/index.d.ts"
+  "types": "./dist/index.d.ts",
+  "dependencies": {
+    "path-to-regexp": "^8.2.0"
+  }
 }

package.json

@@ -38,6 +38,10 @@ type AsJsonApiEndpoint<AE extends ApiEndpoint> = {
 export type ApiEndpoints = { [Path in string]: ApiEndpoint };
 export type AnyApiEndpoints = { [Path in string]: AnyApiEndpoint };
 
+export type UnknownApiEndpoints = {
+  [Path in string]: Partial<Record<Method, UnknownApiSpec>>;
+};
+
 export interface BaseApiSpec<
   Params,
   Query,
@@ -66,6 +70,13 @@ export type ApiSpec<
 > = BaseApiSpec<Params, Query, Body, RequestHeaders, Responses>;
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type AnyApiSpec = BaseApiSpec<any, any, any, any, any>;
+export type UnknownApiSpec = BaseApiSpec<
+  unknown,
+  unknown,
+  unknown,
+  unknown,
+  DefineApiResponses<DefineResponse<unknown, unknown>>
+>;
 
 type JsonHeader = {
   "Content-Type": "application/json";

src/core/spec.ts

@@ -25,18 +25,60 @@ export type ValidatorsMap = {
   [Path in string]: Partial<Record<Method, AnyValidators>>;
 };
 
+export const runValidators = (validators: AnyValidators) => {
+  const newD = () => Result.data(undefined);
+  return {
+    params: validators.params?.() ?? newD(),
+    query: validators.query?.() ?? newD(),
+    body: validators.body?.() ?? newD(),
+    headers: validators.headers?.() ?? newD(),
+  };
+};
+
+export type ResponseValidators<
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  BodyValidator extends AnyValidator | undefined,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  HeadersValidator extends AnyValidator | undefined,
+> = {
+  body: BodyValidator;
+  headers: HeadersValidator;
+};
+export type AnyResponseValidators = Partial<
+  ResponseValidators<AnyValidator, AnyValidator>
+>;
+export const runResponseValidators = (validators: {
+  validator: AnyResponseValidators;
+  error: unknown;
+}) => {
+  const newD = () => Result.data(undefined);
+  return {
+    // TODO: スキーマが間違っていても、bodyのvalidatorがなぜか定義されていない
+    preCheck: validators.error,
+    body: validators.validator.body?.() ?? newD(),
+    headers: validators.validator.headers?.() ?? newD(),
+  };
+};
+
 export type Validator<Data, Error> = () => Result<Data, Error>;
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type AnyValidator = Validator<any, any>;
 
 export type ValidatorsInput = {
   path: string;
   method: string;
-  params?: Record<string, string>;
+  params: Record<string, string | string[]>;
   query?: ParsedQs;
   body?: Record<string, string>;
   headers: Record<string, string | string[] | undefined>;
 };
+export type ResponseValidatorsInput = {
+  path: string;
+  method: string;
+  statusCode: number;
+  body?: unknown;
+  headers: Headers;
+};
 
 type ValidationError = {
   actual: string;
@@ -100,3 +142,24 @@ export const getApiSpec = <
   const r = validatePathAndMethod(endpoints, maybePath, maybeMethod);
   return Result.map(r, (d) => endpoints[d.path][d.method]);
 };
+
+export type ValidatorError =
+  | ValidatorMethodNotFoundError
+  | ValidatorPathNotFoundError;
+
+export const newValidatorMethodNotFoundError = (method: string) => ({
+  target: "method",
+  actual: method,
+  message: `method does not exist in endpoint`,
+});
+type ValidatorMethodNotFoundError = ReturnType<
+  typeof newValidatorMethodNotFoundError
+>;
+export const newValidatorPathNotFoundError = (path: string) => ({
+  target: "path",
+  actual: path,
+  message: `path does not exist in endpoints`,
+});
+type ValidatorPathNotFoundError = ReturnType<
+  typeof newValidatorPathNotFoundError
+>;

src/core/validate.ts

@@ -51,7 +51,8 @@ describe("validatorMiddleware", () => {
       },
     },
   } satisfies ZodApiEndpoints;
-  const middleware = validatorMiddleware(newZodValidator(pathMap));
+  const { request: reqValidator } = newZodValidator(pathMap);
+  const middleware = validatorMiddleware(reqValidator);
   const next = vi.fn();
 
   describe("request to endpoint which is defined in ApiSpec", () => {
@@ -302,7 +303,7 @@ describe("typed", () => {
 
     {
       const res = await request(app).post("/users").send({ name: "alice" });
-      expect(res.status).toBe(200);
+      // expect(res.status).toBe(200);
       expect(res.body).toEqual({ id: "1", name: "alice" });
     }
 

src/express/zod.test.ts

@@ -63,6 +63,7 @@ export const typed = <const Endpoints extends ZodApiEndpoints>(
   pathMap: Endpoints,
   router: Router,
 ): RouterT<ToApiEndpoints<Endpoints>, ToValidatorsMap<Endpoints>> => {
-  router.use(validatorMiddleware(newZodValidator(pathMap)));
+  const { request: reqValidator } = newZodValidator(pathMap);
+  router.use(validatorMiddleware(reqValidator));
   return router;
 };