How to defining Valibot schemas that agree with a TypeScript type?

[hungify]

Example from Zod

import { toZod } from 'tozod';

type Player = {
  name: string;
  age?: number | undefined;
  active: boolean | null;
};

export const Player: toZod<Player> = z.object({
  name: z.string(),
  age: z.number().optional(),
  active: z.boolean().nullable(),
});

How can I achieve that in Valibot?

[fabian-hiller]

You can use BaseSchema:

import * as v from 'valibot';

type Player = {
  name: string;
  age?: number | undefined;
  active: boolean | null;
};

export const Player = v.object({
  name: v.string(),
  age: v.optional(v.number()),
  active: v.nullable(v.boolean()),
}) satisfies v.GenericSchema<Player>;

[hungify2022]

I found another way to create a schema based on types.
It matches with v.BaseSchema<Player> without v.ObjectSchema<{...}>

https://sinclairzx81.github.io/typebox-workbench/

[fabian-hiller]

Yes, that's a cool website!

[LexSwed]

Hey @fabian-hiller 👋
I have another use case where my types are generated from protobufs (example) and since every field in the proto definition is nullish, there needs to be a validation of the gRPC response for the clients to expect specific data structure used for rendering.
With the current satisifies BaseSchema solution, when a field is removed from the API, but it still exists in validation, TypeScript won't complain, due to satisifes being permissive to additional properties.
Maybe something like generic on ObjectEntries can help?

// autogenerated from proto
type Money = {
  currency: Currency;
  amount: number;
}

const moneySchema = object<Money>({
  currency: picklist(currencies),
  amount: number(),
  // here TypeScript should complain because extra no longer exists on Money type
  extra: number(),
})

I don't even want to validate that the output types are matching (e.g. amount: number not matching amount: string), but extra keys should fail in TS. Any ideas would be appreciated 🙏

[fabian-hiller]

Right now I do not have time to look into this, but I am aware that this is an important feature for many users. I will try to find a solution after v1 is released.

[LexSwed]

Thanks and no worries!

Just sharing a solution I landed on (with JSDoc explanation):

/**
 * Validates the output and keys of generated types for @type {object} to highlight
 * specific fields or keys that aren't matching the types.
 * Partial generics are not supported @see {@link https://github.com/microsoft/TypeScript/issues/26242},
 * so to provide a type, but also infer the @type {ObjectEntries}, using currying for now instead.
 */
const objectBySchema =
  <const TExpected extends Record<string, unknown>>() =>
  <const TEntries extends ObjectEntries>(
    // show error when there are no keys in common between defined schema and generated types
    schema: keyof TEntries & keyof TExpected extends never
      ? never
      : {
          // allow only the keys that are in the generated types
          [K in keyof TExpected & keyof TEntries]: InferOutput<
            TEntries[K]
          > extends TExpected[K]
            ? TEntries[K]
            : GenericSchema<TExpected[K]>;
        },
  ) =>
    object(schema);