feat: array schema

Author: shigma

packages/core/src/core.ts

@@ -48,7 +48,8 @@ export abstract class Schema<S, T extends S = S> implements StandardSchemaV1 {
     return value
   }
 
-  failure(message: string, path?: PropertyKey[]): Schema.FailureResult {
+  failure(value: unknown, path?: PropertyKey[], suffix = ''): Schema.FailureResult {
+    const message = `expected ${this.format()}${suffix} but got ${value}`
     return { issues: [{ message, path }] }
   }
 

packages/core/src/schema/array.ts

@@ -0,0 +1,57 @@
+import { ParseOptions, Schema } from '../core.ts'
+
+const isArray = (value: unknown): value is readonly unknown[] => Array.isArray(value)
+
+export namespace $Array {
+  export interface Options<S, T extends S = S> {
+    inner: Schema<S, T>
+    length?: Schema<number>
+  }
+}
+
+export class $Array<S, T extends S = S> extends Schema<readonly S[], T[]> {
+  type = 'array'
+  options: $Array.Options<S, T>
+
+  constructor(inner: Schema<S, T>) {
+    super()
+    this.options = { inner }
+  }
+
+  length(value: Schema<number>) {
+    this.options.length = value
+    return this
+  }
+
+  format(): string {
+    return `Array<${this.options.inner.format()}>`
+  }
+
+  validate(value: unknown, options: ParseOptions) {
+    if (!isArray(value)) return this.failure(value, options.path)
+    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}`)
+      }
+    }
+    const values: T[] = []
+    const issues: Schema.Issue[] = []
+    for (let i = 0; i < value.length; i++) {
+      const result = this.options.inner.validate(value[i], {
+        ...options,
+        path: [...options.path || [], i],
+      })
+      if (!result.issues) {
+        values.push(result.value)
+      } else if (options.autofix) {
+        values.push(this.options.inner.default())
+      } else {
+        issues.push(...result.issues)
+      }
+    }
+    if (issues.length) return { issues }
+    return { value: values }
+  }
+}

packages/core/src/schema/boolean.ts

@@ -4,7 +4,7 @@ export class $Boolean extends Schema<boolean> {
   type = 'boolean'
 
   validate(value: unknown, options: ParseOptions) {
-    if (typeof value !== 'boolean') return this.failure(`expect boolean but got ${value}`, options.path)
+    if (typeof value !== 'boolean') return this.failure(value, options.path)
     return { value }
   }
 }

packages/core/src/schema/const.ts

@@ -24,7 +24,7 @@ export class $Const<T> extends Schema<T> {
 
   validate(value: unknown, options: ParseOptions) {
     if (!deepEqual(value, this.options.value, true)) {
-      return this.failure(`expect ${this.format()} but got ${value}`, options.path)
+      return this.failure(value, options.path)
     }
     return { value: value as T }
   }

packages/core/src/schema/function.ts

@@ -4,7 +4,7 @@ export class $Function extends Schema<Function> {
   type = 'function'
 
   validate(value: unknown, options: ParseOptions) {
-    if (typeof value !== 'function') return this.failure(`expect function but got ${value}`, options.path)
+    if (typeof value !== 'function') return this.failure(value, options.path)
     return { value }
   }
 }

packages/core/src/schema/is.ts

@@ -38,7 +38,7 @@ export class $Is<T> extends Schema<T> {
         prototype = Object.getPrototypeOf(prototype)
       }
     }
-    if (!isValid) return this.failure(`expect ${this.options.constructor.name} but got ${value}`, options.path)
+    if (!isValid) return this.failure(value, options.path)
     return { value: value as T }
   }
 }

packages/core/src/schema/never.ts

@@ -6,6 +6,6 @@ export class $Never<T> extends Schema<T> {
   type = 'never'
 
   validate(value: unknown, options: ParseOptions) {
-    return this.failure(`expect never but got ${value}`, options.path)
+    return this.failure(value, options.path)
   }
 }

packages/core/src/schema/number.ts

@@ -49,13 +49,13 @@ export class $Number extends Schema<number> {
   }
 
   validate(value: unknown, options: ParseOptions) {
-    if (typeof value !== 'number') return this.failure(`expect number but got ${value}`, options.path)
+    if (typeof value !== 'number') return this.failure(value, options.path)
     const { max = Infinity, min = -Infinity } = this.options
-    if (value > max) return this.failure(`expect number <= ${max} but got ${value}`, options.path)
-    if (value < min) return this.failure(`expect number >= ${min} but got ${value}`, options.path)
+    if (value > max) return this.failure(value, options.path, ` greater than ${max}`)
+    if (value < min) return this.failure(value, options.path, ` less than ${min}`)
     const { step } = this.options
     if (step && !isMultipleOf(value, this.options.min ?? 0, step)) {
-      return this.failure(`expect number multiple of ${step} but got ${value}`, options.path)
+      return this.failure(value, options.path, ` multiple of ${step}`)
     }
     return { value }
   }

packages/core/src/schema/string.ts

@@ -22,18 +22,18 @@ export class $String extends Schema<string> {
   }
 
   validate(value: unknown, options: ParseOptions) {
-    if (typeof value !== 'string') return this.failure(`expect string but got ${value}`, options.path)
+    if (typeof value !== 'string') return this.failure(value, options.path)
     if (this.options.pattern) {
       const regexp = new RegExp(this.options.pattern.source, this.options.pattern.flags)
       if (!regexp.test(value)) {
-        return this.failure(`expect string to match ${regexp} but got ${value}`, options.path)
+        return this.failure(value, options.path, ` to match ${regexp}`)
       }
     }
     if (this.options.length) {
       const result = this.options.length.validate(value.length, options)
       if (result.issues) {
-        // TODO improve message
-        return this.failure(`expect string length to be ${result.issues[0].message} but got ${value.length}`, options.path)
+        // TODO: improve message
+        return this.failure(value, options.path, ` with length ${result.issues[0].message}`)
       }
     }
     return { value }