Optional Input and Required Output

[samstorment]

I've found a way to create a schema with optional input and required output types using default values with optional and fallback. However, it's pretty clunky because I have to pass my default value to both of those functions. Is there a better way to do what I'm trying below so I don't have to pass the default value twice?

const schema = v.object({
    // default value of 'desc'
    sort: v.optional(v.fallback(v.string(), 'desc'), 'desc'),
});

type Input  = v.InferInput<typeof schema>;  // { sort?: string | undefined; }
type Output = v.InferOutput<typeof schema>; // { sort: string; }

[dosubot[bot]]

Hi @samstorment! I'm Dosu and I’m helping the valibot team.

You don't need to use both optional and fallback or repeat the default value. In Valibot, you can achieve optional input and required output with a default value by passing the default directly to optional, like this:

const schema = v.object({
  sort: v.optional(v.string(), 'desc'),
});

type Input  = v.InferInput<typeof schema>;  // { sort?: string | undefined }
type Output = v.InferOutput<typeof schema>; // { sort: string }

This is the recommended and concise approach—optional with a default value handles missing or undefined input and produces a required output with the default applied. You only need to specify the default once. If you ever need a dynamic default, you can pass a function as the second argument to optional as well docs.

Use fallback only if you want to provide a default for any invalid input, not just missing or undefined docs.

To reply, just mention @dosu.

---

Docs are dead. Just use Dosu.

[samstorment]

I do realize that is possible but I want to use my default value if:

• the input is not provided (covered by optional)
• if the input does not match the schema (covered by fallback)

I feel like there should be a way to compose these two into a new function that receives a fallback argument, but I couldn't figure it out with the types exported from the user facing API.

Also I'm just replying to the bot in case anyone comes along and sees this. I've been through the song and dance on this issue with the usual chat bots already.

[dosubot[bot]]

There isn't a built-in Valibot combinator that lets you compose optional and fallback with a single default value—you have to specify the default twice if you want to cover both missing and invalid input cases. This is a known limitation of the current user-facing API docs docs. Your current approach is the standard workaround:

sort: v.optional(v.fallback(v.string(), 'desc'), 'desc')

If you want to avoid repeating the value, you could write a small helper function in your own codebase, but Valibot itself doesn't provide one. Also, keep in mind that fallback bypasses any transforms after it runs, so if you need transforms to apply to both the provided and default values, use optional with a default instead discussion.

To reply, just mention @dosu.

---

^{How did I do? Good | Irrelevant | Incorrect | Verbose | Hallucination | Report 🐛 | Other}    

[fabian-hiller]

How about you write v.fallback(v.pipe(v.optional(v.string()), v.string()), 'desc')? v.optional(v.string()) defines the input and v.string() defines the output. v.fallback(...) ensures it returns 'desc' as the output whenever the input does not match the input or output schema.

[samstorment]

In real world practice I think that does work and always uses the default value of 'desc', but typescript still produces an output type where sort is optional:

const schema = v.object({
    sort: v.fallback(v.pipe(v.optional(v.string()), v.string()), 'desc')
});

type Input  = v.InferInput<typeof schema>;  // { sort?: string | undefined }
type Output = v.InferOutput<typeof schema>; // { sort?: string | undefined }

I mainly want to ensure that I don't have to do undefined checks in code that uses my validated objects

// search is of type { sort?: string | undefined } 
const search = v.parse(schema, { sort: 'asc' });
if (search.sort) { ... }

I have to check if search.sort is defined or tell typescript I know better with search.sort!

The solution I've landed on for now is this helper function that seems to work:

function optionalFallback<
    TSchema extends v.GenericSchema, 
    TDefault extends v.InferOutput<TSchema>
>(
    schema: TSchema,
    defaultValue: TDefault
) {
    return v.optional(v.fallback(schema, defaultValue), defaultValue);
}

const schema = v.object({
    sort: optionalFallback(v.string(), 'desc')
});

type Input  = v.InferInput<typeof schema>;  // { sort?: string | undefined }
type Output = v.InferOutput<typeof schema>; // { sort: string }