Client validation

examples/simple/withValidation.ts

@@ -0,0 +1,58 @@
+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 { req: reqValidator, res: 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 { req: reqValidator, res: 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.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"
+  }
 }

src/core/spec.ts

@@ -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/validate.ts

@@ -1,5 +1,5 @@
 import { Result } from "../utils";
-import { AnyApiEndpoint, AnyApiEndpoints, Method } from "./spec";
+import { AnyApiEndpoint, AnyApiEndpoints, isMethod, Method } from "./spec";
 import { ParsedQs } from "qs";
 
 export type Validators<
@@ -25,18 +25,61 @@ export type ValidatorsMap = {
   [Path in string]: Partial<Record<Method, AnyValidators>>;
 };
 
+export const runValidators = (validators: AnyValidators, error: unknown) => {
+  const newD = () => Result.data(undefined);
+  return {
+    preCheck: error,
+    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 +143,36 @@ export const getApiSpec = <
   const r = validatePathAndMethod(endpoints, maybePath, maybeMethod);
   return Result.map(r, (d) => endpoints[d.path][d.method]);
 };
+
+export const preCheck = <E extends AnyApiEndpoints>(
+  endpoints: E,
+  path: string,
+  maybeMethod: string,
+) => {
+  const method = maybeMethod?.toLowerCase();
+  if (!isMethod(method)) {
+    return Result.error(newValidatorMethodNotFoundError(method));
+  }
+  return getApiSpec(endpoints, path, 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/express/index.ts

@@ -92,20 +92,24 @@ export type RouterT<
 };
 
 export const validatorMiddleware = <
-  V extends (input: ValidatorsInput) => AnyValidators,
+  V extends (input: ValidatorsInput) => {
+    validator: AnyValidators;
+    error: unknown;
+  },
 >(
   validator: V,
 ) => {
   return (_req: Request, res: Response, next: NextFunction) => {
     res.locals.validate = (req: Request) => {
-      return validator({
+      const { validator: v2 } = validator({
         path: req.route?.path?.toString(),
         method: req.method,
         headers: req.headers,
         params: req.params,
         query: req.query,
         body: req.body,
       });
+      return v2;
     };
     next();
   };

src/express/valibot.test.ts

@@ -58,7 +58,8 @@ describe("valibot", () => {
         },
       },
     } satisfies ValibotApiEndpoints;
-    const middleware = validatorMiddleware(newValibotValidator(pathMap));
+    const { req: reqValidator } = newValibotValidator(pathMap);
+    const middleware = validatorMiddleware(reqValidator);
     const next = vi.fn();
 
     describe("request to endpoint which is defined in ApiSpec", () => {

src/express/valibot.ts

@@ -65,6 +65,7 @@ export const typed = <const Endpoints extends ValibotApiEndpoints>(
   pathMap: Endpoints,
   router: Router,
 ): RouterT<ToApiEndpoints<Endpoints>, ToValidatorsMap<Endpoints>> => {
-  router.use(validatorMiddleware(newValibotValidator(pathMap)));
+  const { req: reqValidator } = newValibotValidator(pathMap);
+  router.use(validatorMiddleware(reqValidator));
   return router;
 };

src/express/zod.test.ts

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

src/express/zod.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 { req: reqValidator } = newZodValidator(pathMap);
+  router.use(validatorMiddleware(reqValidator));
   return router;
 };