Recursive schema about valibot HOT 9 CLOSED

This should work with recursive.

from valibot.

Awesome, I even looked through the code, must have totally overlooked it then, thanks!

Is this the right approach to use it then?

import { BaseSchema, object, recursive, string, parse, Output, merge, array } from "valibot";

const baseCategorySchema = object({
  name: string(),
});

type Category = Output<typeof baseCategorySchema> & {
  subcategories?: Category[];
};

const categorySchema: BaseSchema<Category> = merge([baseCategorySchema, object({ subcategories: recursive(() => array(categorySchema)) })]);

const result = parse(categorySchema, {
  name: "People",
  subcategories: [
    {
      name: "Politicians",
      subcategories: [
        {
          name: "Presidents",
          subcategories: [],
        },
      ],
    },
  ],
});

from valibot.

Looks good. Does it work as expected?

from valibot.

Jup seems to work fine. An example like this could probably be added to the docs then.
This is exactly the example from Zod but converted to Valibot.

from valibot.

As soon as I find the time, I'll probably add advanced guides to the docs and include that. Thanks for your contribution!

from valibot.

Random (related) question/confirmation as I check out valibot for the first time :) ...

I was curious to see if the following would be the right approach to parsing a general JSON value with Valibot?

import {
  type BaseSchema,
  type Output,
  union,
  boolean,
  number,
  string,
  nullType,
  recursive,
  array,
  record,
} from 'valibot'

export type JsonPrimitive = Output<typeof vJsonPrimitive>
export type Json = JsonPrimitive | { [key: string]: Json } | Json[]

export const vJsonPrimitive = union([number(), boolean(), string(), nullType()])

export const vJson: BaseSchema<Json> = union([
  vJsonPrimitive,
  recursive(() => array(vJson)),
  recursive(() => record(vJson)),
])

Note zod's docs have a similar example (https://github.com/colinhacks/zod#json-type):

const literalSchema = z.union([z.string(), z.number(), z.boolean(), z.null()])
type Literal = z.infer<typeof literalSchema>
type Json = Literal | { [key: string]: Json } | Json[]
const jsonSchema: z.ZodType<Json> = z.lazy(() => z.union([literalSchema, z.array(jsonSchema), z.record(jsonSchema)]))

This is a common use-case... let me know if you are open to adding it to the docs (I am happy to make a PR if I can confirm this is the right approach with valibot :) ).

from valibot.

The code looks good to me. For the docs, the most I would change is some naming. However, at this point I don't know where I would add it to the docs. Right now the focus is not on the docs. But that will change in the next few weeks. It might even make sense to add a json schema to Valibot instead of adding this functionality to the docs.

from valibot.

Also, it might be interesting to add some kind of json validation function to be able to check in a string pipeline if a input corresponds to stringified JSON.

from valibot.

Lazy (formerly recursive) schemas are now documented here:

• https://valibot.dev/guides/other/#lazy-schema
• https://valibot.dev/api/lazy/

from valibot.