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.