Discuss about Valibot 🤖

[fabian-hiller]

Everything that does not fit to an issue or PR will probably find the right place here. We are happy about every new idea! Please be respectful to each other when discussing.

[jamesarosen]

It's not completely clear to me when transformations apply. I commonly need to map from something that has entries() to an object, so I'd like to have something like this:

type HasEntries<T = string, U = unknown> = {
  entries: () => [T, U][];
}

const entriesToObject = (x: HasEntries) => Object.fromEntries(x.entries);

Would this be a transform? How would I chain it together with an object schema like the following?

const mySchema = object({
  foo: optional(string()),
  bar: string(),
})

[fabian-hiller]

Then coerce is the right choice: https://valibot.dev/guides/methods/#coerce

Note that you also can pass a schema as the last argument to transform. This way you can validate the input before and after the transformation.

[jamesarosen]

This next question is a bit more philosophical. coerce only accepts an (value: unknown) => T. Would you expect folks who use coerce to narrow the type via a first round of validation? That is, validate is S-> coerce S to T -> parse T.

The alternative would be to change coerce to coerce<S, T>(value: S) => T, which would then allow only an S to be passed to the resulting schema.

[fabian-hiller]

coerce is for forcing unknown data into a specific data type. If you want to transform validated data, you should use transform. The last argument of transform allows you to validate the data after the transformations, if necessary. Does that answer your question?

[jamesarosen]

Maybe, but only I think of that validation-after-transform as also having coercion.

Here's what I started with, without valibot:

function parseOptionalDate(s: string | null) {
  if (s == null) return null
  d = new Date(s)
  return isNaN(d) ? null : d
}

function parseRangeParams(searchParams: URLSearchParams) {
  return {
    from: parseOptionalDate(searchParams.get('from')),
    to: parseOptionalDate(searchParams.get('to')),
  }
}

I can valibot-ize it a bit like so:

const MaybeDateSchema = coerce(optional(date()), (i) => { d = new Date(i); return isNaN(d) ? null : d })

const RangeSchema = object({
  from: optional(date()),
  to: optional(date()),
})

function parseRangeParams(searchParams: URLSearchParams) {
  return parse(RangeSchema, {
    from: searchParams.get('from'),
    to: searchParams.get('to'),
  })
}

But I'm getting stuck on fully valibot-izing it so that I can do this:

// from: Date | null, to: Date | null, searchParams: URLSearchParams
const { from , to } = parse(RangeSearchParamsSchema, searchParams)

I feel like I need to coerce the URLSearchParams to an Object, but I want to "pipe" that into another schema afterwards.

[fabian-hiller]

I think in your use case it makes more sense to split it into two steps, as in the second code example. Squeezing everything into one schema makes the code unintelligible.