Search params validation agnostic thanks to TypeProvider pattern

[ecyrbe]

Hello @tannerlinsley ,

New Tanstack router validation system could maybe be improved by using the TypeProvider pattern.
This would allow to not only provide zod schemas but any schemas without having to rely on custom function validator for other validation libraries.
The trick is to use Interface and this type to have High Order Kind out of the box.
Here is an example of a provider i'm starting to implement in zodios to make it agnostic:

/**
 This is provider without any type inferrence
The trick is for providers to extend it to add compile time type inferrence
*/
export interface AnyTypeProvider {
  schema: unknown;
  input: unknown;
  output: unknown;
}

/**
  This infer user input to have Type Safety at compile time
  To use to infer type when using 'Link'
*/
export type InferInputTypeFromSchema<
  TProvider extends AnyTypeProvider,
  Schema
> = (TProvider & { schema: Schema })["input"];

/**
  This infer validated output of a schema (usefull when combined with default values and transforms)
  To use to infer type when using 'loader' or 'useMatch'
*/
export type InferOutputTypeFromSchema<
  TProvider extends AnyTypeProvider,
  Schema
> = (TProvider & { schema: Schema })["output"];

/**
  This is a specialized type provider for zod
  We could this way let user implement their own for example `yup` / `ajv` / `io-ts` / `typeBox` etc that also provide typescript type inferrence
*/
export interface ZodTypeProvider extends AnyTypeProvider {
  input: this["schema"] extends z.ZodTypeAny ? z.input<this["schema"]> : never;
  output: this["schema"] extends z.ZodTypeAny
    ? z.output<this["schema"]>
    : never;
}

This Type provider can now be passed to Router like any type and still allow inference :

/**
  we can set type provider to be zod by default if we want
*/
type RouteOptions<...., Schema , TypeProvider extends AnyTypeProvider = ZodTypeProvider> = {
  ....
  /* search validation can be any schema from any library */
  searchValidation: Schema;
 /* Loader search params are inferred thanks to the TypeProvider */
  loader?: LoaderFn<TRouteLoaderData, /*TFullSearchSchema*/ InferOutputTypeFromSchema<TypeProvider,Schema>, TAllParams>;
  /* Dynamic type provider provide a way to validate at runtime but also provide the compile time type provider */
  typeProvider?: DynamicTypeProvider<TypeProvider>
}

type DynamicTypeProvider<TypeProvider extends AnyTypeProvider> = {
 /* this will be undefined at runtime, but the type will be set to the provider type */
  _provider?: TypeProvider;
  validator: <Schema>(schema: Schema, input: unknown) => unknown;
}

And here an example of validator for zod that provides bot compile time and runtime validation (we can view this as a plugin):

const zodTypeProvider: DynamicTypeProvider<ZodTypeProvider> = {
  validator: (schema: z.ZodTypeAny, input: unknown) => schema.parse(input);
}

What do you think ?

[ecyrbe]

An example implementation can be found in zodios v11 branch

[schiller-manuel]

we have support for https://github.com/standard-schema/standard-schema now