ternary validation

[BerkliumBirb]

Hello. I have a task that looks like this:

• the string should either be ftp:// url
  • and also required to have userinfo there
• or be just a simple string that looks like a path

I tried to implement that using union:

union([
  pipe(
    url(),
    check(url => new URL(url).username?.length > 0, 'Userinfo required')
  ),
  pipe(
    check(candidate => isAbsolute(candidate), 'Should be absolute path')
  )
])

But the problem is that union fallbacks to the next part if one fails, thus any Userinfo checks are always silenced.

Would be great to have something like this:

ternary(
  // condition
  url(),
  // left
  check(url => new URL(url).username?.length > 0, 'Userinfo required'),
  // right
  check(candidate => isAbsolute(candidate), 'Should be absolute path')
)

or

variant(
  url(),
  [
    valid(check(url => new URL(url).username?.length > 0, 'Userinfo required')),
    invalid(check(candidate => isAbsolute(candidate), 'Should be absolute path'))
  ]
)

Is there any way to implement this thing?

[fabian-hiller]

This is a typical OR condition that can be covered by union. I would write it this way:

import * as v from 'valibot';
import { isAbsolutePath } from '~/utils';

const Schema = v.union([
  v.pipe(v.string(), v.startsWith('ftp://'), v.url()),
  v.pipe(v.string(), v.check(isAbsolutePath)),
]);

[fabian-hiller]

This works with union when the schema is different between the union options. Since both start with a string schema, union can't know which message is more important and return them as subissues instead. If nothing helps, you can always fall back to rawCheck:

import * as v from 'valibot';
import { isAbsolutePath } from '~/utils';

const Schema = v.pipe(
  v.string(),
  v.rawCheck(({ dataset, addIssue }) => {
    if (dataset.typed) {
      if (dataset.value.startsWith('ftp://')) {
        try {
          new URL(dataset.value);
        } catch {
          addIssue({ message: 'Invalid FTP URL' });
        }
      } else if (!isAbsolutePath(dataset.value)) {
        addIssue({ message: 'Path must be absolute' });
      }
    }
  })
);

[fabian-hiller]

Here is another option. You can pass a function to union to generate the error message. Using the first argument of the function, you can access the issue information and return the error message of the first subissue as the error message of union:

import * as v from 'valibot';
import { isAbsolutePath } from '~/utils';

const Schema = v.union(
  [
    v.pipe(v.string(), v.startsWith('ftp://'), v.url()),
    v.pipe(v.string(), v.check(isAbsolutePath)),
  ],
  (issue) => issue.issues?.[0].message ?? issue.message
);

[fabian-hiller]

You can also access the issue.input of the union to return a message based on it.

[BerkliumBirb]

Since both start with a string schema, union can't know which message is more important and return them as subissues instead

That's exactly why I proposed something like ternary(selector, positivePath, negativePath) so that the result of the first check will be used to determine which issues should be returned.

return the error message of the first subissue as the error message of union

That wouldn't work either, because it'll return "Not a URL" like error for ./asdf along with "not an absolute path" yet the latter is much more helpful in this case than the former.

If nothing helps, you can always fall back to rawCheck

Yeah, I know. But that's something I would really like to avoid, since there are pretty hefty checks in my real world case, and I would like to use valibot's actions instead of implementing them myself.

You can also access the issue.input of the union to return a message based on it.

That way I'll have to implement yet another v.url() but outside the schema just to format the issue for the person.

---

So I wonder if there's any way to implement ternary (condSchema ? truthySchema : falsySchema)? I think this can be somehow based on the s.variant()?

[fabian-hiller]

Thanks for the context. I now understand your initial idea. I am unsure about the API, but feel free to create an issue so others can join and discuss this with us. Until we make a decision, you can implement the ternary action yourself. I can guide you if needed.