getDefaults sould return [] instead of undefined for arrays

[notramo]

The getDefaults function returns undefined as a default value for array(), but it's not ergonomic. I find myself always doing one of the following:

• Add unnecessary complication to code that works with the input, to handle undefined, e.g. instead of doing a simple .push(), I have to add an undefined check or a nullish coalescing operator.
• Add an optional() with default value []

I recommend to set the out-of-the-box default value to [], as it covers the majority of use cases, and if undefined default is needed, there's optional() and undefinedable().

import { getDefaults, object, array, string } from 'valibot';

const mySchema = object({
  myArray: array(string()),
});

console.debug(getDefaults(mySchema));

outputs:

{
  myArray: undefined,
}

better output would be:

{
  myArray: [],
}

[fabian-hiller]

Currently, getDefaults only supports object and tuple schemas. Feel free to share your use case so we can investigate whether we should change the current implementation.

Here is a workaround that might work for you in the meantime. Otherwise you can copy the source code of getDefaults and modify it to your needs.

import * as v from 'valibot';

const Schema = v.object({
  array: v.optional(v.array(v.string()), []),
});

const defaults = v.getDefaults(Schema);

[andersk]

This would not be a good change. Perhaps in your particular use case it makes sense to default to [], but in other use cases it will cause problems.

For example, consider an API like

v.union([
  v.object({ allow: v.array(v.string()) }),
  v.object({ deny: v.array(v.string()) }),
]);

where the client specifies either an allowlist {"allow": ["foo", "bar"]} or a denylist {"deny": ["baz", "quux"]}. We cannot accept {}, because there’s no way to tell whether that means to allow nothing or to deny nothing.

As another example, if we’re validating a payload for consumption by some external program we didn’t write, that program might not accept a missing array in lieu of an empty one, so we shouldn’t implicitly accept it either.

The programmer needs to be explicit about which arrays to default to []. v.optional(v.array(…), []) is a fine way to specify that. And for an array that doesn’t default to [], getDefaults should not pretend it does.

[fabian-hiller]

Thank you for your feedback! I really appreciate your contributions over the past few weeks!