Query validation with "valibot" creates string / array unions.

[ajotaos]

Using the vValidator('query', schema) with an object schema with string keys like this:

v.object({
  foo: v.string()
})

it should result on an inferred type like: { foo: string } but the input type is allowing the following type to pass through: { foo: string | string[] }.

This behavior is not consistent with zod's validator.

[yusukebe]

Hi @ajotaos

Thanks. This seems to be a bug.

[yusukebe]

Hi ZerNico! Can you take a look at this?

[ajotaos]

I was able to get the types working by porting over the zod implementation into valibot, I just was not creative on how to get the lowercase headers done.

export type Hook<
  T extends v.GenericSchema | v.GenericSchemaAsync,
  E extends Env,
  P extends string,
  Target extends keyof ValidationTargets = keyof ValidationTargets,
  O = {}
> = (
  result: v.SafeParseResult<T> & {
    target: Target
  },
  c: Context<E, P>
) => Response | void | TypedResponse<O> | Promise<Response | void | TypedResponse<O>>

type HasUndefined<T> = undefined extends T ? true : false

export const vValidator = <
  T extends v.GenericSchema | v.GenericSchemaAsync,
  Target extends keyof ValidationTargets,
  E extends Env,
  P extends string,
  In = v.InferInput<T>,
  Out = v.InferOutput<T>,
  I extends Input = {
    in: HasUndefined<In> extends true
      ? {
          [K in Target]?: In extends ValidationTargets[K]
            ? In
            : { [K2 in keyof In]?: ValidationTargets[K][K2] }
        }
      : {
          [K in Target]: In extends ValidationTargets[K]
            ? In
            : { [K2 in keyof In]: ValidationTargets[K][K2] }
        }
    out: { [K in Target]: Out }
  },
  V extends I = I
>(
  target: Target,
  schema: T,
  hook?: Hook<T, E, P, Target>
): MiddlewareHandler<E, P, V> =>
  // @ts-expect-error
  validator(target, async (value, c) => {
    const parsed = await v.safeParseAsync(schema, value)

    if (hook) {
      const hookResult = await hook({ ...parsed, target }, c)
      if (hookResult) {
        if (hookResult instanceof Response) {
          return hookResult
        }

        if ('response' in hookResult) {
          return hookResult.response
        }
      }
    }

    if (!parsed.success) {
      return c.json({
        target,
        issues: v.flatten(parsed.issues)
      }, 400)
    }

    return parsed.output
  })