Can multiple validator("query", ...) middlewares be combined?

[silvioprog]

I'm using validator and I want to split query validation into multiple middlewares, but still access a single merged result via c.req.valid("query").

Example:

// validators.ts
export const limitValidator = validator("query", (value, c) => {
  // validate/transform limit
  return { limit: /* ... */ }
});

export const excludedValidator = validator("query", (value, c) => {
  // validate/transform excluded
  return { excluded: /* ... */ }
});

export default [limitValidator, excludedValidator] as const;

// index.ts
import validators from "./validators";

app.get("/", ...validators, (c) => {
  const { limit, excluded } = c.req.valid("query");
  // limit is undefined
  return c.text("ok");
});

Is validated("query") supposed to contain results from all query validators, or does each validator("query") overwrite the previous one? If overwriting is expected, what's the recommended way to "compose" query validators (merge results, or use a single validator/schema)?

[JackyST0]

Each validator("query", ...) middleware overwrites the previous validation result in c.req.valid("query"). They don't merge automatically.

Solutions

Option 1: Use a single combined validator (Recommended)

import { z } from 'zod'
import { zValidator } from '@hono/zod-validator'

const querySchema = z.object({
  limit: z.coerce.number().optional(),
  excluded: z.string().optional(),
  // ... all your query params
})

app.get("/", zValidator("query", querySchema), (c) => {
  const { limit, excluded } = c.req.valid("query")
  return c.text("ok")
})

Option 2: Store results in context variables

const limitValidator = validator("query", (value, c) => {
  const limit = /* validate */
  c.set("limit", limit)
  return { limit }
})

const excludedValidator = validator("query", (value, c) => {
  const excluded = /* validate */
  c.set("excluded", excluded)
  return { excluded }
})

app.get("/", limitValidator, excludedValidator, (c) => {
  const limit = c.get("limit")
  const excluded = c.get("excluded")
  // or access the last validator's result
  // const { excluded } = c.req.valid("query")
  return c.text("ok")
})

Option 3: Compose validators manually

const composeValidators = (...validators) => {
  return validator("query", (value, c) => {
    let result = {}
    for (const v of validators) {
      const validated = v(value, c)
      result = { ...result, ...validated }
    }
    return result
  })
}

app.get("/", composeValidators(limitValidatorFn, excludedValidatorFn), (c) => {
  const { limit, excluded } = c.req.valid("query")
  return c.text("ok")
})

Recommendation

Use Option 1 with a single Zod schema - it's cleaner and gives you full type safety.

---

If this solves your problem, please mark it as the answer! ✅

[KeepALifeUS]

Answer: Combining Hono Validators

Each validator("query", ...) overwrites the previous result. The last validator wins.

Solution 1: Single combined validator (Recommended)

import { zValidator } from "@hono/zod-validator";
import { z } from "zod";

const querySchema = z.object({
  limit: z.coerce.number().optional(),
  excluded: z.string().optional(),
});

app.get("/", zValidator("query", querySchema), (c) => {
  const { limit, excluded } = c.req.valid("query");
  return c.json({ limit, excluded });
});

Solution 2: Merge schemas

const limitSchema = z.object({ limit: z.coerce.number() });
const excludedSchema = z.object({ excluded: z.string() });

const combinedSchema = limitSchema.merge(excludedSchema);

app.get("/", zValidator("query", combinedSchema), handler);

Solution 3: Custom merging middleware

const mergeValidators = (...validators) => {
  return async (c, next) => {
    let merged = {};
    for (const v of validators) {
      await v(c, async () => {});
      merged = { ...merged, ...c.req.valid("query") };
    }
    c.set("mergedQuery", merged);
    await next();
  };
};

app.get("/", mergeValidators(limitValidator, excludedValidator), (c) => {
  const { limit, excluded } = c.get("mergedQuery");
});

Recommendation

Use Solution 1 or 2 - single schema is cleaner and type-safe. Split validators are better stored as reusable schema fragments that you merge at the route level.