feat: object, tuple, dict schema

Author: shigma

packages/core/src/core.ts

@@ -5,7 +5,7 @@ const kValidationError = Symbol.for('ValidationError')
 
 export interface ParseOptions {
   autofix?: boolean
-  ignore?: (data: any, schema: Schema<any>) => boolean
+  ignore?: (data: any, schema: Schema) => boolean
   path?: PropertyKey[]
 }
 
@@ -27,7 +27,7 @@ export namespace Schema {
   }
 }
 
-export abstract class Schema<S, T extends S = S> implements StandardSchemaV1 {
+export abstract class Schema<S = any, T extends S = S> implements StandardSchemaV1 {
   abstract readonly type: string
 
   readonly '~standard': StandardSchemaV1.Props<S, T> = {
@@ -53,7 +53,7 @@ export abstract class Schema<S, T extends S = S> implements StandardSchemaV1 {
     return { issues: [{ message, path }] }
   }
 
-  static is(schema: any): schema is Schema<any> {
+  static is(schema: any): schema is Schema {
     return !!schema?.[kSchema]
   }
 }

packages/core/src/schema/array.ts

@@ -32,8 +32,7 @@ export class $Array<S, T extends S = S> extends Schema<readonly S[], T[]> {
     if (this.options.length) {
       const result = this.options.length.validate(value.length, options)
       if (result.issues) {
-        // TODO: improve message
-        return this.failure(value, options.path, ` with length ${result.issues[0].message}`)
+        return this.failure(value, options.path, ` with length ${this.options.length.format()}`)
       }
     }
     const values: T[] = []
@@ -43,12 +42,10 @@ export class $Array<S, T extends S = S> extends Schema<readonly S[], T[]> {
         ...options,
         path: [...options.path || [], i],
       })
-      if (!result.issues) {
-        values.push(result.value)
-      } else if (options.autofix) {
-        values.push(this.options.inner.default())
-      } else {
+      if (result.issues) {
         issues.push(...result.issues)
+      } else {
+        values.push(result.value)
       }
     }
     if (issues.length) return { issues }

packages/core/src/schema/dict.ts

@@ -0,0 +1,54 @@
+import { ParseOptions, Schema } from '../core.ts'
+
+export namespace $Dict {
+  export interface Options<S, T extends S = S> {
+    inner: Schema<S, T>
+    key?: Schema<string>
+  }
+}
+
+export class $Dict<S, T extends S = S> extends Schema<Readonly<Record<string, S>>, Record<string, T>> {
+  type = 'dict'
+  options: $Dict.Options<S, T>
+
+  constructor(inner: Schema<S, T>) {
+    super()
+    this.options = { inner }
+  }
+
+  key(value: Schema<string>) {
+    this.options.key = value
+    return this
+  }
+
+  format() {
+    return `Record<${this.options.key ? this.options.key.format() : 'string'}, ${this.options.inner.format()}>`
+  }
+
+  validate(value: unknown, options: ParseOptions) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+      return this.failure(value, options.path)
+    }
+    const values: Record<string, T> = {}
+    const issues: Schema.Issue[] = []
+    for (const key in value) {
+      if (this.options.key) {
+        const keyResult = this.options.key.validate(key, options)
+        if (keyResult.issues) {
+          issues.push(...keyResult.issues)
+        }
+      }
+      const result = this.options.inner.validate((value as any)[key], {
+        ...options,
+        path: [...options.path || [], key],
+      })
+      if (result.issues) {
+        issues.push(...result.issues)
+      } else {
+        values[key] = result.value
+      }
+    }
+    if (issues.length) return { issues }
+    return { value: values }
+  }
+}

packages/core/src/schema/object.ts

@@ -0,0 +1,51 @@
+import { ParseOptions, Schema } from '../core.ts'
+
+export namespace $Object {
+  export interface Options {
+    items: Record<string, Schema>
+    extra?: Schema // TODO
+  }
+}
+
+export class $Object<S, T extends S = S> extends Schema<S, T> {
+  type = 'object'
+  options: $Object.Options
+
+  constructor(items: Record<string, Schema>) {
+    super()
+    this.options = { items }
+  }
+
+  extra(value: Schema) {
+    this.options.extra = value
+    return this
+  }
+
+  format() {
+    const defs = Object.entries(this.options.items).map(([key, schema]) => `${key}: ${schema.format()}`)
+    return `{ ${defs.join(', ')} }`
+  }
+
+  validate(value: unknown, options: ParseOptions) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+      return this.failure(value, options.path)
+    }
+    const source: any = value
+    const target: any = {}
+    const issues: Schema.Issue[] = []
+    for (const key in this.options.items) {
+      const schema = this.options.items[key]
+      const result = schema.validate(source[key], {
+        ...options,
+        path: [...options.path || [], key],
+      })
+      if (result.issues) {
+        issues.push(...result.issues)
+      } else {
+        target[key] = result.value
+      }
+    }
+    if (issues.length) return { issues }
+    return { value: target }
+  }
+}

packages/core/src/schema/string.ts

@@ -32,8 +32,7 @@ export class $String extends Schema<string> {
     if (this.options.length) {
       const result = this.options.length.validate(value.length, options)
       if (result.issues) {
-        // TODO: improve message
-        return this.failure(value, options.path, ` with length ${result.issues[0].message}`)
+        return this.failure(value, options.path, ` with length ${this.options.length.format()}`)
       }
     }
     return { value }

packages/core/src/schema/tuple.ts

@@ -0,0 +1,46 @@
+import { ParseOptions, Schema } from '../core.ts'
+
+export namespace $Tuple {
+  export interface Options {
+    inner: Schema[]
+    extra?: Schema // TODO
+  }
+}
+
+export class $Tuple<S, T extends S = S> extends Schema<S, T> {
+  type = 'tuple'
+  options: $Tuple.Options
+
+  constructor(inner: Schema[]) {
+    super()
+    this.options = { inner }
+  }
+
+  extra(value: Schema) {
+    this.options.extra = value
+    return this
+  }
+
+  format() {
+    return `[${this.options.inner.map((schema) => schema.format()).join(', ')}]`
+  }
+
+  validate(value: unknown, options: ParseOptions) {
+    if (!Array.isArray(value)) return this.failure(value, options.path)
+    const values: any = []
+    const issues: Schema.Issue[] = []
+    for (let i = 0; i < this.options.inner.length; i++) {
+      const result = this.options.inner[i].validate(value[i], {
+        ...options,
+        path: [...options.path || [], i],
+      })
+      if (result.issues) {
+        issues.push(...result.issues)
+      } else {
+        values.push(result.value)
+      }
+    }
+    if (issues.length) return { issues }
+    return { value: values }
+  }
+}