justus 0.0.1 → 0.0.2

package/package.json

@@ -1,10 +1,20 @@
 {
   "name": "justus",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "A JavaScript validation library, with types!",
-  "main": "dist/index.cjs",
-  "types": "dist/index.d.ts",
-  "module": "dist/index.mjs",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./dts-generator": {
+      "import": "./dist/dts-generator.mjs",
+      "require": "./dist/dts-generator.js"
+    }
+  },
+  "types": "./index.d.ts",
   "scripts": {
     "build": "build.sh",
     "dev": "nodemon -e ts -x build.sh -w src -w test -w test-d",
@@ -14,14 +24,14 @@
   "author": "Juit Developers <developers@juit.com>",
   "license": "MIT",
   "devDependencies": {
-    "@microsoft/api-extractor": "^7.18.19",
+    "@microsoft/api-extractor": "^7.18.21",
     "@types/chai": "^4.2.22",
     "@types/mocha": "^9.0.0",
-    "@typescript-eslint/eslint-plugin": "^5.5.0",
-    "@typescript-eslint/parser": "^5.5.0",
+    "@typescript-eslint/eslint-plugin": "^5.6.0",
+    "@typescript-eslint/parser": "^5.6.0",
     "chai": "^4.3.4",
-    "esbuild": "^0.14.1",
-    "eslint": "^8.3.0",
+    "esbuild": "^0.14.2",
+    "eslint": "^8.4.0",
     "eslint-config-google": "^0.14.0",
     "mocha": "^9.1.3",
     "nodemon": "^2.0.15",

package/src/dts-generator.ts

@@ -0,0 +1,274 @@
+import ts from 'typescript'
+import {
+  AllOfValidator,
+  AnyArrayValidator,
+  AnyNumberValidator,
+  AnyObjectValidator,
+  AnyStringValidator,
+  AnyValidator,
+  ArrayValidator,
+  assertSchema,
+  BooleanValidator,
+  ConstantValidator,
+  DateValidator,
+  getValidator,
+  NumberValidator,
+  ObjectValidator,
+  OneOfValidator,
+  StringValidator,
+  TupleValidator,
+  Validation,
+  Validator,
+} from './index'
+
+/* ========================================================================== *
+ * LOCAL TYPES                                                                *
+ * ========================================================================== */
+
+/** A function taking a `Validator` and producing its `TypeNode`. */
+type TypeGenerator<V extends Validator = Validator> = (
+  validator: V,
+  references: ReadonlyMap<Validator, string>
+) => ts.TypeNode
+
+/** The generic constructor of a `Validator` instance. */
+type ValidatorConstructor<V extends Validator = Validator> = { // <T = any> = {
+  new (...args: any[]): V
+}
+
+/* ========================================================================== *
+ * GENERATE TYPES FOR VALIDATORS                                              *
+ * ========================================================================== */
+
+/** Registry of all `Validator` constructors and related `TypeGenerator`s. */
+const generators = new Map<Function, TypeGenerator<any>>()
+
+/** Register a `TypeGenerator` function for a `Validator`. */
+export function registerTypeGenerator<V extends Validator>(
+    validator: ValidatorConstructor<V>,
+    generator: TypeGenerator<V>,
+): void {
+  assertSchema(validator.prototype instanceof Validator, 'Not a `Validator` class')
+  generators.set(validator, generator)
+}
+
+/** Generate typings for the given `Validation`s. */
+export function generateTypes(validations: Record<string, Validation>): string {
+  // Create two maps (one mapping "string -> validator" and another mapping
+  // "validator -> string"). The first map will serve as our "exports" map,
+  // while the second will make sure that any exported validator gets referenced
+  // in the generated DTS, rather than being re-generated
+  const validators = new Map<string, Validator>()
+  const references = new Map<Validator, string>()
+
+  Object.entries(validations).forEach(([ name, validation ]) => {
+    const validator = getValidator(validation)
+    // References will be added only once, first one takes precedence!
+    if (! references.has(validator)) references.set(validator, name)
+    validators.set(name, validator)
+  })
+
+  // Create the array of type alias declarations to be printed and exported
+  const types: ts.TypeAliasDeclaration[] = []
+  for (const [ name, validator ] of validators.entries()) {
+    // Clone our references map, and remove the validator being exported. This
+    // will make sure that we don't have any loops in our types
+    const referenceable = new Map(references)
+    if (referenceable.get(validator) === name) {
+      referenceable.delete(validator)
+    }
+
+    // Generate the type of the validator, with our stripped reference table
+    const type = generateTypeNode(validator, referenceable)
+
+    // Create a type alias declaration with the name of the export
+    const modifiers = [ ts.factory.createModifier(ts.SyntaxKind.ExportKeyword) ]
+    const decl = ts.factory.createTypeAliasDeclaration(undefined, modifiers, name, [], type)
+    types.push(decl)
+  }
+
+  // Print out all our type aliases
+  return ts.createPrinter().printList(
+      ts.ListFormat.SourceFileStatements,
+      ts.factory.createNodeArray(types),
+      ts.createSourceFile('types.d.ts', '', ts.ScriptTarget.Latest))
+}
+
+/* ========================================================================== *
+ * TYPE GENERATORS                                                            *
+ * ========================================================================== */
+
+/** Generate a TypeScript `TypeNode` for the given validator instance. */
+function generateTypeNode(
+    validator: Validator,
+    references: ReadonlyMap<Validator, string>,
+): ts.TypeNode {
+  const reference = references.get(validator)
+  if (reference) return ts.factory.createTypeReferenceNode(reference)
+
+  const generator = generators.get(validator.constructor)
+  assertSchema(!! generator, `Type generator for "${validator.constructor.name}" not found`)
+  return generator(validator, references)
+}
+
+/* ========================================================================== */
+
+// Simple nodes
+
+const anyType = ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)
+const anyArrayType = ts.factory.createArrayTypeNode(anyType)
+const booleanType = ts.factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword)
+const numberType = ts.factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword)
+const neverType = ts.factory.createKeywordTypeNode(ts.SyntaxKind.NeverKeyword)
+const stringType = ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)
+const recordType = ts.factory.createMappedTypeNode(
+    undefined, // readonly
+    ts.factory.createTypeParameterDeclaration('key', stringType),
+    undefined, // name type
+    undefined, // question token
+    anyType, // type of the mapped key
+    undefined) // members
+
+// Modifiers and tokens
+
+const readonlyKeyword = [ ts.factory.createModifier(ts.SyntaxKind.ReadonlyKeyword) ]
+const optionalKeyword = ts.factory.createToken(ts.SyntaxKind.QuestionToken)
+
+
+/* ========================================================================== */
+
+// Simple generator returning nodes
+
+registerTypeGenerator(AnyValidator, () => anyType)
+registerTypeGenerator(AnyArrayValidator, () => anyArrayType)
+registerTypeGenerator(AnyNumberValidator, () => numberType)
+registerTypeGenerator(AnyObjectValidator, () => recordType)
+registerTypeGenerator(AnyStringValidator, () => stringType)
+registerTypeGenerator(BooleanValidator, () => booleanType)
+registerTypeGenerator(DateValidator, () => ts.factory.createTypeReferenceNode('Date'))
+
+/* ========================================================================== */
+
+// Complex generator functions...
+
+registerTypeGenerator(ArrayValidator, (validator, references) => {
+  const itemType = generateTypeNode(validator.items, references)
+  return ts.factory.createArrayTypeNode(itemType)
+})
+
+registerTypeGenerator(ConstantValidator, (validator) => {
+  const literal =
+    typeof validator.constant === 'number' ? ts.factory.createNumericLiteral(validator.constant) :
+    typeof validator.constant === 'string' ? ts.factory.createStringLiteral(validator.constant) :
+    validator.constant === false ? ts.factory.createFalse() :
+    validator.constant === true ? ts.factory.createTrue() :
+    validator.constant === null ? ts.factory.createNull() :
+    undefined
+
+  assertSchema(!! literal, `Invalid constant "${validator.constant}"`)
+  return ts.factory.createLiteralTypeNode(literal)
+})
+
+registerTypeGenerator(NumberValidator, (validator: NumberValidator) => {
+  if (! validator.brand) return numberType
+
+  const signature = ts.factory.createPropertySignature(undefined, `__brand_${validator.brand}`, undefined, neverType)
+  const literal = ts.factory.createTypeLiteralNode([ signature ])
+  return ts.factory.createIntersectionTypeNode([ numberType, literal ])
+})
+
+registerTypeGenerator(StringValidator, (validator: StringValidator) => {
+  if (! validator.brand) return stringType
+
+  const signature = ts.factory.createPropertySignature(undefined, `__brand_${validator.brand}`, undefined, neverType)
+  const literal = ts.factory.createTypeLiteralNode([ signature ])
+  return ts.factory.createIntersectionTypeNode([ stringType, literal ])
+})
+
+registerTypeGenerator(TupleValidator, (validator: TupleValidator<any>, references) => {
+  const members = validator.members
+
+  // count how many rest parameters do we have..
+  const { count, first, next } =
+      members.reduce(({ count, first, next }, { single }, i) => {
+        if (! single) {
+          if (i < first) first = i
+          next = i + 1
+          count += 1
+        }
+        return { count, first, next }
+      }, { count: 0, first: members.length, next: -1 })
+
+  // if we have zero or one rest parameter, things are easy...
+  if (count < 2) {
+    const types = members.map(({ single, validator }) => {
+      const memberType = generateTypeNode(validator, references)
+
+      if (single) return generateTypeNode(validator, references)
+
+      const arrayType = ts.factory.createArrayTypeNode(memberType)
+      return ts.factory.createRestTypeNode(arrayType)
+    })
+
+    return ts.factory.createTupleTypeNode(types)
+  }
+
+  // We have two or more rest parameters... we need combine everything between
+  // the first and the last one in a giant union!
+  const before = members.slice(0, first)
+      .map(({ validator }) => generateTypeNode(validator, references))
+  const types = members.slice(first, next)
+      .map(({ validator }) => generateTypeNode(validator, references))
+  const after = members.slice(next)
+      .map(({ validator }) => generateTypeNode(validator, references))
+
+  const union = ts.factory.createUnionTypeNode(types)
+  const array = ts.factory.createArrayTypeNode(union)
+  const rest = ts.factory.createRestTypeNode(array)
+
+  return ts.factory.createTupleTypeNode([ ...before, rest, ...after ])
+})
+
+registerTypeGenerator(AllOfValidator, (validator, references) => {
+  const members = validator.validators.map((validator) => generateTypeNode(validator, references))
+  return ts.factory.createIntersectionTypeNode(members)
+})
+
+registerTypeGenerator(OneOfValidator, (validator, references) => {
+  const members = validator.validators.map((validator) => generateTypeNode(validator, references))
+  return ts.factory.createUnionTypeNode(members)
+})
+
+registerTypeGenerator(ObjectValidator, (validator, references) => {
+  const properties: ts.PropertySignature[] = []
+
+  for (const [ key, property ] of validator.properties.entries()) {
+    const { validator, readonly, optional } = property || { optional: true }
+    const type = validator ? generateTypeNode(validator, references) : neverType
+
+    const signature = ts.factory.createPropertySignature(
+          readonly ? readonlyKeyword : undefined,
+          key,
+          optional ? optionalKeyword : undefined,
+          type)
+
+    properties.push(signature)
+  }
+
+  if (validator.additionalProperties) {
+    const extra = ts.factory.createMappedTypeNode(
+        undefined, // readonly
+        ts.factory.createTypeParameterDeclaration('key', stringType),
+        undefined, // name type
+        undefined, // question token
+        generateTypeNode(validator.additionalProperties, references),
+        undefined) // members
+
+    if (properties.length == 0) return extra
+
+    const type = ts.factory.createTypeLiteralNode(properties)
+    return ts.factory.createIntersectionTypeNode([ type, extra ])
+  } else {
+    return ts.factory.createTypeLiteralNode(properties)
+  }
+})

package/src/index.ts

@@ -11,13 +11,13 @@ export * from './utilities'
 // Validators
 export { allOf, oneOf, AllOfValidator, OneOfValidator } from './validators/union'
 export { any, AnyValidator } from './validators/any'
-export { array, arrayOf, ArrayValidator } from './validators/array'
+export { array, arrayOf, AnyArrayValidator, ArrayValidator } from './validators/array'
 export { boolean, BooleanValidator } from './validators/boolean'
 export { constant, ConstantValidator } from './validators/constant'
 export { date, DateValidator } from './validators/date'
-export { number, NumberValidator } from './validators/number'
-export { object, ObjectValidator } from './validators/object'
-export { string, StringValidator } from './validators/string'
+export { number, AnyNumberValidator, NumberValidator } from './validators/number'
+export { object, AnyObjectValidator, ObjectValidator } from './validators/object'
+export { string, AnyStringValidator, StringValidator } from './validators/string'
 export { tuple, TupleValidator } from './validators/tuple'
 
 /* ========================================================================== *

package/src/types.ts

@@ -296,3 +296,12 @@ type InferNever<S extends Schema> =
       never
     ] : never
   }
+
+/* ========================================================================== *
+ * TYPE BRANDING                                                              *
+ * ========================================================================== */
+
+/** Utility type to infer primitive branding according to a string */
+export type Branding<S extends string> = {
+  [ key in keyof { __brand: never } as `__brand_${S}` ] : never
+}

package/src/validators/array.ts

@@ -20,9 +20,16 @@ export interface ArrayConstraints<V extends Validation> {
   items?: V,
 }
 
-/**
- * A validator for `Array` instances.
- */
+/** Basic validator for `Array` instances. */
+export class AnyArrayValidator<T = any> extends Validator<T[]> {
+  validate(value: unknown, options: ValidationOptions): T[] {
+    void options
+    assertValidation(Array.isArray(value), 'Value is not an "array"')
+    return [ ...value ]
+  }
+}
+
+/** A validator for `Array` instances with constraints. */
 export class ArrayValidator<T> extends Validator<T[]> {
   readonly maxItems: number
   readonly minItems: number
@@ -80,12 +87,7 @@ export class ArrayValidator<T> extends Validator<T[]> {
   }
 }
 
-const anyArrayValidator = new class extends Validator<any[]> {
-  validate(value: unknown): any[] {
-    assertValidation(Array.isArray(value), 'Value is not an "array"')
-    return value
-  }
-}
+const anyArrayValidator = new AnyArrayValidator()
 
 /* -------------------------------------------------------------------------- */
 

package/src/validators/number.ts

@@ -1,6 +1,23 @@
-import { Validator } from '../types'
+import { Branding, Validator } from '../types'
 import { assertSchema, assertValidation } from '../errors'
 import { makeTupleRestIterable } from './tuple'
+import { ValidationError } from '..'
+
+/* ========================================================================== */
+
+const PRECISION = 6 // our default precision, in decimal digits
+const MULTIPLIER = Math.pow(10, PRECISION) // multiplier for precision
+
+function countDecimals(n: number): number {
+  // match the parts of the exponential form of the number
+  const match = n.toExponential().match(/^\d+(\.\d+)?e([+-]\d+)$/)
+  if (! match) throw new RangeError(`Can't calculate digits for number "${n}"`)
+  // number of digits in the absolute value, minus whatever is the exp
+  const digits = ((match[1] || '.').length - 1) - (parseInt(match[2]))
+  return digits < 0 ? 0 : digits
+}
+
+/* ========================================================================== */
 
 /** Constraints to validate a `number` with. */
 export interface NumberConstraints {
@@ -18,7 +35,22 @@ export interface NumberConstraints {
   allowNaN?: boolean,
 }
 
-/** A `Validator` validating `number`s. */
+/** Constraints to validate a `number` with extra branding information. */
+export interface BrandedNumberConstraints<B extends string> extends NumberConstraints {
+  /** The _brand_ of the string (will generate a `__brand_${B}` type property */
+  brand: B
+}
+
+/** A `Validator` validating any `number`. */
+export class AnyNumberValidator extends Validator<number> {
+  validate(value: unknown): number {
+    assertValidation(typeof value == 'number', 'Value is not a "number"')
+    assertValidation(! isNaN(value), 'Number is "NaN"')
+    return value
+  }
+}
+
+/** A `Validator` validating `number`s with constaints. */
 export class NumberValidator<N extends number = number> extends Validator<N> {
   #isMultipleOf?: ((value: number) => boolean)
 
@@ -28,6 +60,7 @@ export class NumberValidator<N extends number = number> extends Validator<N> {
   readonly maximum: number
   readonly minimum: number
   readonly multipleOf?: number
+  readonly brand?: string
 
   constructor(constraints: NumberConstraints = {}) {
     super()
@@ -41,6 +74,8 @@ export class NumberValidator<N extends number = number> extends Validator<N> {
       multipleOf,
     } = constraints
 
+    if ('brand' in constraints) this.brand = (<any> constraints).brand
+
     assertSchema(maximum >= minimum, `Constraint "minimum" (${minimum}) is greater than "maximum" (${maximum})`)
 
     if (exclusiveMaximum !== undefined) {
@@ -60,18 +95,21 @@ export class NumberValidator<N extends number = number> extends Validator<N> {
 
     if (multipleOf !== undefined) {
       assertSchema(multipleOf > 0, `Constraint "multipleOf" (${multipleOf}) must be greater than zero`)
+      const decimals = countDecimals(multipleOf)
 
-      // Split the multiple of in integer and fraction
-      const bigMultipleOf = multipleOf * NumberValidator.PRECISION
-      const bigInteger = bigMultipleOf % NumberValidator.PRECISION
-      const bigDecimal = bigMultipleOf - Math.trunc(bigMultipleOf)
-
-      if (bigInteger === 0) {
+      if (decimals === 0) {
         // Easy case is when we only have to deal with integers...
         this.#isMultipleOf = (value): boolean => ! (value % multipleOf)
-      } else if (bigDecimal === 0) {
+      } else if (decimals <= PRECISION) {
         // We have some "decimal" part (max 6 decimal digits), multiply...
-        this.#isMultipleOf = (value): boolean => ! ((value * NumberValidator.PRECISION) % bigMultipleOf)
+        this.#isMultipleOf = (value): boolean => {
+          try {
+            if (countDecimals(value) > PRECISION) return false
+            return ! ((value * MULTIPLIER) % (multipleOf * MULTIPLIER))
+          } catch (error: any) {
+            throw new ValidationError(error.message)
+          }
+        }
       } else {
         // Required precision was too much (more than 6 decimal digits)
         assertSchema(false, `Constraint "multipleOf" (${multipleOf}) requires too much precision`)
@@ -108,20 +146,14 @@ export class NumberValidator<N extends number = number> extends Validator<N> {
 
     return value as N
   }
-
-  static readonly PRECISION = 1000000
 }
 
-const anyNumberValidator = new class extends Validator<number> {
-  validate(value: unknown): number {
-    assertValidation(typeof value == 'number', 'Value is not a "number"')
-    assertValidation(! isNaN(value), 'Number is "NaN"')
-    return value
-  }
-}
+const anyNumberValidator = new AnyNumberValidator()
 
 function _number(): Validator<number>
-function _number<N extends number = number>(constraints?: NumberConstraints): NumberValidator<N>
+function _number(constraints?: NumberConstraints): NumberValidator<number>
+function _number<N extends number>(constraints?: NumberConstraints): NumberValidator<N>
+function _number<B extends string>(constraints: BrandedNumberConstraints<B>): NumberValidator<number & Branding<B>>
 
 function _number(constraints?: NumberConstraints): Validator<number> {
   return constraints ? new NumberValidator(constraints) : anyNumberValidator

package/src/validators/object.ts

@@ -1,4 +1,15 @@
-import { additionalValidator, InferSchema, modifierValidator, never, Schema, schemaValidator, ValidationOptions, Validator } from '../types'
+import {
+  InferSchema,
+  Schema,
+  TupleRestParameter,
+  ValidationOptions,
+  Validator,
+  additionalValidator,
+  modifierValidator,
+  never,
+  restValidator,
+  schemaValidator,
+} from '../types'
 import { assertValidation, ValidationErrorBuilder } from '../errors'
 import { getValidator } from '../utilities'
 import { isModifier } from '../schema'
@@ -8,30 +19,47 @@ import { makeTupleRestIterable } from './tuple'
  * OBJECT VALIDATOR                                                           *
  * ========================================================================== */
 
-/** A `Validator` validating `object`s according to a `Schema` */
+type ObjectProperty = {
+  validator: Validator,
+  readonly?: true,
+  optional?: true,
+}
+
+/** A `Validator` validating any `object`. */
+export class AnyObjectValidator extends Validator<Record<string, any>> {
+  validate(value: unknown): Record<string, any> {
+    assertValidation(typeof value == 'object', 'Value is not an "object"')
+    assertValidation(value !== null, 'Value is "null"')
+    return value
+  }
+}
+
+/** A `Validator` validating `object`s according to a `Schema`. */
 export class ObjectValidator<S extends Schema> extends Validator<InferSchema<S>> {
   readonly schema: Readonly<S>
 
-  #additionalProperties?: Validator
-  #requiredProperties: Record<string, Validator<any>> = {}
-  #optionalProperties: Record<string, Validator<any>> = {}
-  #neverProperties: Set<string> = new Set<string>()
+  properties = new Map<string, ObjectProperty | undefined>()
+  additionalProperties?: Validator
 
   constructor(schema: S) {
     super()
     const { [additionalValidator]: additional, ...properties } = schema
 
-    if (additional) this.#additionalProperties = getValidator(additional)
+    if (additional) this.additionalProperties = getValidator(additional)
 
     for (const key of Object.keys(properties)) {
       const definition = properties[key]
 
       if (definition === never) {
-        this.#neverProperties.add(key)
+        this.properties.set(key, undefined)
       } else if (isModifier(definition)) {
-        (definition.optional ? this.#optionalProperties : this.#requiredProperties)[key] = definition[modifierValidator]
+        this.properties.set(key, {
+          validator: definition[modifierValidator],
+          readonly: definition.readonly,
+          optional: definition.optional,
+        })
       } else {
-        this.#requiredProperties[key] = getValidator(definition)
+        this.properties.set(key, { validator: getValidator(definition) })
       }
     }
 
@@ -46,22 +74,24 @@ export class ObjectValidator<S extends Schema> extends Validator<InferSchema<S>>
     const builder = new ValidationErrorBuilder()
     const clone: Record<string, any> = {}
 
-    for (const [ key, validator ] of Object.entries(this.#requiredProperties)) {
-      if (record[key] === undefined) {
-        builder.record('Required property missing', key)
+    for (const [ key, property ] of this.properties.entries()) {
+      const { validator, optional } = property || {}
+
+      // no validator? this is "never" (forbidden)
+      if (! validator) {
+        if (record[key] === undefined) continue
+        if (options.stripForbiddenProperties) continue
+        builder.record('Forbidden property', key)
         continue
       }
 
-      try {
-        clone[key] = validator.validate(record[key], options)
-      } catch (error) {
-        builder.record(error, key)
+      // no value? might be optional, but definitely not validated
+      if (record[key] === undefined) {
+        if (! optional) builder.record('Required property missing', key)
+        continue
       }
-    }
-
-    for (const [ key, validator ] of Object.entries(this.#optionalProperties)) {
-      if (record[key] === undefined) continue
 
+      // all the rest gets validated normally
       try {
         clone[key] = validator.validate(record[key], options)
       } catch (error) {
@@ -69,19 +99,8 @@ export class ObjectValidator<S extends Schema> extends Validator<InferSchema<S>>
       }
     }
 
-    for (const key of this.#neverProperties) {
-      if (record[key] === undefined) continue
-      if (options.stripForbiddenProperties) continue
-      builder.record('Forbidden property', key)
-    }
-
-    const additional = this.#additionalProperties
-    const additionalKeys = Object.keys(record).filter((k) => {
-      if (k in this.#requiredProperties) return false
-      if (k in this.#optionalProperties) return false
-      if (this.#neverProperties.has(k)) return false
-      return true
-    })
+    const additionalKeys = Object.keys(record).filter((k) => !this.properties.has(k))
+    const additional = this.additionalProperties
 
     if (additional) {
       additionalKeys.forEach((key) => {
@@ -102,23 +121,23 @@ export class ObjectValidator<S extends Schema> extends Validator<InferSchema<S>>
   }
 }
 
-/** Validate _any_ `object` */
-const anyObjectValidator = new class extends Validator<Record<string, any>> {
-  validate(value: unknown): Record<string, any> {
-    assertValidation(typeof value == 'object', 'Value is not an "object"')
-    assertValidation(value !== null, 'Value is "null"')
-    return value
-  }
-}
+const anyObjectValidator = new AnyObjectValidator()
 
 function _object(): Validator<Record<string, any>>
-function _object<S extends Schema>(schema: S): S
+function _object<S extends Schema>(schema: S): S & {
+  [Symbol.iterator](): Generator<TupleRestParameter<InferSchema<S>>>
+}
 function _object(schema?: Schema): Validator<Record<string, any>> | Schema {
   if (! schema) return anyObjectValidator
 
-  return Object.defineProperty(schema, schemaValidator, {
-    value: new ObjectValidator(schema),
-    enumerable: false,
+  const validator = new ObjectValidator(schema)
+  function* iterator(): Generator<TupleRestParameter> {
+    yield { [restValidator]: validator }
+  }
+
+  return Object.defineProperties(schema, {
+    [schemaValidator]: { value: validator, enumerable: false },
+    [Symbol.iterator]: { value: iterator, enumerable: false },
   })
 }