Standard Schema support

[notramo]

@ianstormtaylor are there any plans on supporting the Standard Schema interface in Superstruct?

https://github.com/standard-schema/standard-schema/

[Loxoz]

I may be wrong, but I don't think Standard Schema should be implemented directly in Superstruct.
One of the reasons I use Superstruct is that it is light and tree-shaking when bundled, and this might add some weight to it.

However, even if a little bit against Standard Schema's philosophy, it is very easy to make an adapter to any Struct, validate it with Standard Schema's function, and still get correct types.

Here is a simple implementation:

import { Struct, Infer } from "superstruct";
import * as s from "superstruct";
import { StandardSchemaV1 } from "@standard-schema/spec";

export type StructSchema<S extends Struct<any>> = StandardSchemaV1<unknown, Infer<S>>;

export function structSchema<S extends Struct<any>>(struct: S): StructSchema<S> {
    return {
        "~standard": {
            version: 1,
            vendor: "superstruct",
            validate(input) {
                const [err, value] = struct.validate(input, { coerce: true });

                if (err) {
                    return { issues: [{ message: err.message, path: err.path.map(String) }] };
                }

                return { value };
            },
        },
    };
}

example usage:

const schema = structSchema(s.type({ foo: s.literal("bar") }));

const result1 = await schema["~standard"].validate({ foo: "bar" });
console.log(result1);
/*
{ value: { foo: 'bar' } }
*/

const result2 = await schema["~standard"].validate({ notFoo: "notBar" });
console.log(result2);
/*
{
  "issues": [
    {
      "message": "At path: foo -- Expected the literal `\"bar\"`, but received: undefined",
      "path": [
        "foo"
      ]
    }
  ]
}
*/

if (result2.issues) { // will throw
    throw new Error(JSON.stringify(result2.issues, null, 2));
}

result2.value; // correctly typed

const simpleSchema = structSchema(s.boolean());

console.log(await simpleSchema["~standard"].validate(true));
/*
{ value: true }
*/
console.log(await simpleSchema["~standard"].validate(undefined));
/*
{
  issues: [
    {
      message: 'Expected a value of type `boolean`, but received: `undefined`',
      path: []
    }
  ]
}
*/

Hope this helps.

[notramo]

What about adding it to SuperStruct as a separately importable, tree-shaking compatible function, instead of being part of every schema by default? Probably it could be named standardSchema() or similar.

By the way, Valibot is also focused on modularity and tree-shaking but it supports Standard Schema by default, without any extra adapter.

[Azarattum]

I like the importable function approach. I think the function could be called just standard since we are already passing schema to it. This name would also align with current library's single-word naming convention.

Being a part of the library would make superstruct officially support standard schema while not impacting bundle size/tree shaking for users who don't need it.