@scalar/validation 0.1.0 → 0.3.0

package/src/types.ts

@@ -3,13 +3,16 @@ import type {
   ArraySchema,
   BooleanSchema,
   EvaluateSchema,
+  IntersectionSchema,
   LazySchema,
   LiteralSchema,
   NotDefinedSchema,
   NullableSchema,
   NumberSchema,
   ObjectSchema,
+  OptionalSchema,
   RecordSchema,
+  Schema,
   StringSchema,
   UnionSchema,
 } from './schema'
@@ -17,6 +20,37 @@ import type {
 // Export Static type with depth limit to prevent infinite recursion
 export type Static<T> = _Static<T, 10>
 
+/**
+ * Folds intersection member schemas into an intersection of their static types.
+ * Uses `Schema` for tuple positions (not a narrower alias) so `infer First extends …` does not
+ * reject valid tuple elements and collapse to `{}`.
+ */
+type IntersectObjectStatics<Schemas extends readonly Schema[], Depth extends number> = Schemas extends readonly []
+  ? {}
+  : Schemas extends readonly [infer First extends Schema, ...infer Rest extends readonly Schema[]]
+    ? _Static<First, Depth> & IntersectObjectStatics<Rest, Depth>
+    : {}
+
+type OptionalPropertyKeys<P> = {
+  [K in keyof P]: P[K] extends OptionalSchema<any> ? K : never
+}[keyof P]
+
+type RequiredPropertyKeys<P> = {
+  [K in keyof P]: P[K] extends OptionalSchema<any> ? never : K
+}[keyof P]
+
+type OptionalSchemaInner<S> = S extends OptionalSchema<infer Inner> ? Inner : never
+
+type ObjectStatics<Properties, Depth extends number> = [keyof Properties] extends [never]
+  ? {}
+  : OptionalPropertyKeys<Properties> extends never
+    ? { [K in keyof Properties]: _Static<Properties[K], Prev<Depth>> }
+    : RequiredPropertyKeys<Properties> extends never
+      ? { [K in OptionalPropertyKeys<Properties>]?: _Static<OptionalSchemaInner<Properties[K]>, Prev<Depth>> }
+      : { [K in RequiredPropertyKeys<Properties>]: _Static<Properties[K], Prev<Depth>> } & {
+          [K in OptionalPropertyKeys<Properties>]?: _Static<OptionalSchemaInner<Properties[K]>, Prev<Depth>>
+        }
+
 // Internal type with depth counter
 type _Static<T, Depth extends number = 10> = Depth extends 0
   ? any
@@ -39,14 +73,18 @@ type _Static<T, Depth extends number = 10> = Depth extends 0
                   : T extends RecordSchema<infer Key, infer Value>
                     ? Record<_Static<Key, Prev<Depth>> & PropertyKey, _Static<Value, Prev<Depth>>>
                     : T extends ObjectSchema<infer Properties>
-                      ? { [K in keyof Properties]: _Static<Properties[K], Prev<Depth>> }
-                      : T extends UnionSchema<infer Schemas>
-                        ? _Static<Schemas[number], Prev<Depth>>
-                        : T extends EvaluateSchema<infer S>
-                          ? _Static<S, Prev<Depth>>
-                          : T extends LazySchema<infer S>
-                            ? _Static<ReturnType<S>, Prev<Depth>>
-                            : never
+                      ? ObjectStatics<Properties, Depth>
+                      : T extends OptionalSchema<infer S>
+                        ? _Static<S, Prev<Depth>> | undefined
+                        : T extends IntersectionSchema<infer Schemas>
+                          ? IntersectObjectStatics<Schemas, Prev<Depth>>
+                          : T extends UnionSchema<infer Schemas>
+                            ? _Static<Schemas[number], Prev<Depth>>
+                            : T extends EvaluateSchema<infer S>
+                              ? _Static<S, Prev<Depth>>
+                              : T extends LazySchema<infer S>
+                                ? _Static<ReturnType<S>, Prev<Depth>>
+                                : never
 
 // Helper type to decrement depth counter
 type Prev<T extends number> = T extends 10

package/src/validate.test.ts

@@ -5,6 +5,7 @@ import {
   array,
   boolean,
   evaluate,
+  intersection,
   lazy,
   literal,
   notDefined,
@@ -652,6 +653,58 @@ describe('union', () => {
   })
 })
 
+describe('intersection', () => {
+  it('passes when the value satisfies every member object schema', () => {
+    const T = intersection([object({ a: number(), b: number() }), object({ c: string(), d: string() })])
+    expect(validate(T, { a: 1, b: 2, c: 'x', d: 'y' })).toBe(true)
+  })
+
+  it('fails when one member object schema fails', () => {
+    const T = intersection([object({ a: number(), b: number() }), object({ c: string(), d: string() })])
+    expect(validate(T, { a: 1, b: 2, c: 'x', d: 3 })).toBe(false)
+  })
+
+  it('fails when the first member fails even if later members would pass', () => {
+    const T = intersection([object({ x: literal(1) }), object({ y: string() })])
+    expect(validate(T, { x: 2, y: 'ok' })).toBe(false)
+  })
+
+  it('requires overlapping keys to satisfy every arm that declares them', () => {
+    const T = intersection([object({ id: number() }), object({ id: string() })])
+    expect(validate(T, { id: 1 })).toBe(false)
+    expect(validate(T, { id: '1' })).toBe(false)
+  })
+
+  it('rejects non-plain objects before member checks', () => {
+    const T = intersection([object({ x: number() }), object({ y: number() })])
+    expect(validate(T, null)).toBe(false)
+    expect(validate(T, undefined)).toBe(false)
+    expect(validate(T, 0)).toBe(false)
+    expect(validate(T, [])).toBe(false)
+    expect(validate(T, new Date())).toBe(false)
+  })
+
+  it('treats an empty intersection as vacuously valid', () => {
+    const T = intersection([])
+    expect(validate(T, null)).toBe(true)
+    expect(validate(T, { a: 1 })).toBe(true)
+  })
+
+  it('matches a single member the same as that object schema alone', () => {
+    const O = object({ x: number() })
+    const T = intersection([O])
+    expect(validate(T, { x: 1 })).toBe(true)
+    expect(validate(T, {})).toBe(false)
+    expect(validate(O, { x: 1 })).toBe(validate(T, { x: 1 }))
+  })
+
+  it('validates members that use lazy schemas', () => {
+    const T = intersection([object({ a: number() }), object({ nested: lazy(() => object({ z: string() })) })])
+    expect(validate(T, { a: 1, nested: { z: 'ok' } })).toBe(true)
+    expect(validate(T, { a: 1, nested: { z: 1 } })).toBe(false)
+  })
+})
+
 describe('notDefined', () => {
   const T = notDefined()
   it('Should fail string', () => {

package/src/validate.ts

@@ -14,10 +14,12 @@ import type { Schema } from './schema'
  * - 'notDefined':  Only `undefined` is valid.
  * - 'array':       Array with all items validated recursively.
  * - 'record':      Object with string/number keys and values, checked recursively.
- * - 'object':      Object with fixed property keys, each validated recursively.
+ * - 'object':      Plain object with fixed property keys, each validated recursively.
  * - 'union':       Accepts if value matches any of the listed schemas.
+ * - 'optional':    Accepts `undefined` or a value matching the inner schema.
+ * - 'intersection': Accepts if value matches every member schema (members are object schemas; value must be a plain object).
  * - 'literal':     Exact match with a literal value.
- * - 'recursive':   Schema referring to itself for nested validation (e.g. trees).
+ * - 'lazy':        Delegates to the schema returned by the factory.
  * - 'evaluate':    Transforms value then validates against an inner schema.
  *
  * @example
@@ -72,9 +74,22 @@ export const validate = (schema: Schema | undefined, value: unknown): boolean =>
     const schemaKeys = Object.keys(schema.properties)
     return schemaKeys.every((key) => validate(schema.properties[key], value[key]))
   }
+  if (schema.type === 'optional') {
+    return value === undefined || validate(schema.schema, value)
+  }
   if (schema.type === 'union') {
     return schema.schemas.some((schema) => validate(schema, value))
   }
+  if (schema.type === 'intersection') {
+    if (schema.schemas.length === 0) {
+      // Vacuous: no constraints (matches `Array.prototype.every` on an empty list).
+      return true
+    }
+    if (!isObject(value)) {
+      return false
+    }
+    return schema.schemas.every((subSchema) => validate(subSchema, value))
+  }
   if (schema.type === 'literal') {
     return value === schema.value
   }