feat: support lazy, close #60

Author: shigma

packages/core/src/index.ts

@@ -55,11 +55,12 @@ declare global {
       is<T>(constructor: Constructor<T>): Schema<T>
       array<X>(inner: X): Schema<TypeS<X>[], TypeT<X>[]>
       dict<X, Y extends Schema<any, string> = Schema<string>>(inner: X, sKey?: Y): Schema<Dict<TypeS<X>, TypeS<Y>>, Dict<TypeT<X>, TypeT<Y>>>
-      tuple<X extends readonly any[]>(list: X): Schema<TupleS<X>, TupleT<X>>
+      tuple<const X extends readonly any[]>(list: X): Schema<TupleS<X>, TupleT<X>>
       object<X extends Dict>(dict: X): Schema<ObjectS<X>, ObjectT<X>>
       union<const X>(list: readonly X[]): Schema<TypeS<X>, TypeT<X>>
       intersect<const X>(list: readonly X[]): Schema<IntersectS<X>, IntersectT<X>>
       transform<X, T>(inner: X, callback: (value: TypeS<X>, options: Schemastery.Options) => T, preserve?: boolean): Schema<TypeS<X>, T>
+      lazy<X extends Schema>(callback: () => X): X
       ValidationError: typeof ValidationError
     }
 
@@ -102,6 +103,7 @@ declare global {
     dict?: Dict<Schema>
     bits?: Dict<number>
     callback?: Function
+    builder?: Function
     value?: T
     refs?: Dict<Schema>
     preserve?: boolean
@@ -384,7 +386,7 @@ Schema.resolve = function resolve(data, schema, options = {}, strict = false) {
   if (!schema) return [data]
   if (options.ignore?.(data, schema)) return [data]
 
-  if (isNullable(data)) {
+  if (isNullable(data) && schema.type !== 'lazy') {
     if (schema.meta.required) throw new ValidationError(`missing required value`, options)
     let current = schema
     let fallback = schema.meta.default
@@ -427,6 +429,18 @@ Schema.from = function from(source: any) {
   }
 }
 
+Schema.lazy = function lazy(builder) {
+  const toJSON = () => {
+    if (!schema.inner![kSchema]) {
+      schema.inner = schema.builder!()
+      schema.inner!.meta = { ...schema.meta, ...schema.inner!.meta }
+    }
+    return schema.inner!.toJSON()
+  }
+  const schema = new Schema({ type: 'lazy', builder, inner: { toJSON } as any })
+  return schema as any
+}
+
 Schema.natural = function natural() {
   return Schema.number().step(1).min(0)
 }
@@ -479,6 +493,14 @@ Schema.arrayBuffer = function arrayBuffer(encoding?: 'hex' | 'base64') {
   ])
 }
 
+Schema.extend('lazy', (data, schema, options, strict) => {
+  if (!schema.inner![kSchema]) {
+    schema.inner = schema.builder!()
+    schema.inner!.meta = { ...schema.meta, ...schema.inner!.meta }
+  }
+  return Schema.resolve(data, schema.inner!, options, strict)
+})
+
 Schema.extend('any', (data) => {
   return [data]
 })

packages/core/tests/index.spec.ts

@@ -81,7 +81,9 @@ describe('Schema API', () => {
       bar: Schema.union([1, 2, 3]),
     })
 
+    // @ts-expect-error
     expect(config({ foo: 0, bar: 2 })).to.deep.equal({ foo: 1, bar: 2 })
+    // @ts-expect-error
     expect(() => config({ foo: 2, bar: 0 })).to.throw()
   })
 })

packages/core/tests/misc.spec.ts

@@ -13,8 +13,14 @@ describe('Miscellaneous', () => {
   })
 
   test('serialization (recursive)', () => {
-    const Node = Schema.object({ id: Number })
-    Node.set('children', Schema.array(Node))
+    interface Node {
+      id: number
+      children: Node[]
+    }
+
+    const Node: Schema<Node> = Schema.lazy(() => {
+      return Schema.object({ id: Number, children: Schema.array(Node) })
+    }).role('node')
     const validate = new Schema(JSON.parse(JSON.stringify(Node)))
 
     expect(validate({ id: 1 })).to.deep.equal({ id: 1, children: [] })