@atproto/lex-schema 0.0.1 → 0.0.3

package/src/schema/integer.test.ts

@@ -0,0 +1,312 @@
+import { IntegerSchema } from './integer.js'
+
+describe('IntegerSchema', () => {
+  describe('basic validation', () => {
+    const schema = new IntegerSchema({})
+
+    it('validates integers', () => {
+      const result = schema.safeParse(42)
+      expect(result.success).toBe(true)
+    })
+
+    it('validates zero', () => {
+      const result = schema.safeParse(0)
+      expect(result.success).toBe(true)
+    })
+
+    it('validates negative integers', () => {
+      const result = schema.safeParse(-42)
+      expect(result.success).toBe(true)
+    })
+
+    it('validates large integers', () => {
+      const result = schema.safeParse(Number.MAX_SAFE_INTEGER)
+      expect(result.success).toBe(true)
+    })
+
+    it('validates small integers', () => {
+      const result = schema.safeParse(Number.MIN_SAFE_INTEGER)
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects floats', () => {
+      const result = schema.safeParse(3.14)
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects strings', () => {
+      const result = schema.safeParse('42')
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects booleans', () => {
+      const result = schema.safeParse(true)
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects null', () => {
+      const result = schema.safeParse(null)
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects undefined', () => {
+      const result = schema.safeParse(undefined)
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects objects', () => {
+      const result = schema.safeParse({})
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects arrays', () => {
+      const result = schema.safeParse([42])
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects NaN', () => {
+      const result = schema.safeParse(NaN)
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects Infinity', () => {
+      const result = schema.safeParse(Infinity)
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects -Infinity', () => {
+      const result = schema.safeParse(-Infinity)
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('default value', () => {
+    const schema = new IntegerSchema({ default: 10 })
+
+    it('uses default when undefined is provided', () => {
+      const result = schema.safeParse(undefined)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(10)
+      }
+    })
+
+    it('does not use default when explicit value is provided', () => {
+      const result = schema.safeParse(20)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(20)
+      }
+    })
+
+    it('does not use default when zero is provided', () => {
+      const result = schema.safeParse(0)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(0)
+      }
+    })
+  })
+
+  describe('minimum constraint', () => {
+    const schema = new IntegerSchema({ minimum: 10 })
+
+    it('accepts values equal to minimum', () => {
+      const result = schema.safeParse(10)
+      expect(result.success).toBe(true)
+    })
+
+    it('accepts values greater than minimum', () => {
+      const result = schema.safeParse(20)
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects values less than minimum', () => {
+      const result = schema.safeParse(5)
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects zero when minimum is positive', () => {
+      const result = schema.safeParse(0)
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects negative values when minimum is positive', () => {
+      const result = schema.safeParse(-10)
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('maximum constraint', () => {
+    const schema = new IntegerSchema({ maximum: 100 })
+
+    it('accepts values equal to maximum', () => {
+      const result = schema.safeParse(100)
+      expect(result.success).toBe(true)
+    })
+
+    it('accepts values less than maximum', () => {
+      const result = schema.safeParse(50)
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects values greater than maximum', () => {
+      const result = schema.safeParse(150)
+      expect(result.success).toBe(false)
+    })
+
+    it('accepts zero when maximum is positive', () => {
+      const result = schema.safeParse(0)
+      expect(result.success).toBe(true)
+    })
+
+    it('accepts negative values when maximum is positive', () => {
+      const result = schema.safeParse(-10)
+      expect(result.success).toBe(true)
+    })
+  })
+
+  describe('minimum and maximum constraints', () => {
+    const schema = new IntegerSchema({ minimum: 10, maximum: 100 })
+
+    it('accepts values within range', () => {
+      const result = schema.safeParse(50)
+      expect(result.success).toBe(true)
+    })
+
+    it('accepts minimum value', () => {
+      const result = schema.safeParse(10)
+      expect(result.success).toBe(true)
+    })
+
+    it('accepts maximum value', () => {
+      const result = schema.safeParse(100)
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects values below minimum', () => {
+      const result = schema.safeParse(5)
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects values above maximum', () => {
+      const result = schema.safeParse(150)
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('negative range constraints', () => {
+    const schema = new IntegerSchema({ minimum: -100, maximum: -10 })
+
+    it('accepts negative values within range', () => {
+      const result = schema.safeParse(-50)
+      expect(result.success).toBe(true)
+    })
+
+    it('accepts minimum negative value', () => {
+      const result = schema.safeParse(-100)
+      expect(result.success).toBe(true)
+    })
+
+    it('accepts maximum negative value', () => {
+      const result = schema.safeParse(-10)
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects values below minimum', () => {
+      const result = schema.safeParse(-150)
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects values above maximum', () => {
+      const result = schema.safeParse(-5)
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects zero', () => {
+      const result = schema.safeParse(0)
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects positive values', () => {
+      const result = schema.safeParse(10)
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('zero constraints', () => {
+    const schema = new IntegerSchema({ minimum: 0, maximum: 0 })
+
+    it('accepts zero', () => {
+      const result = schema.safeParse(0)
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects positive values', () => {
+      const result = schema.safeParse(1)
+      expect(result.success).toBe(false)
+    })
+
+    it('rejects negative values', () => {
+      const result = schema.safeParse(-1)
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('combined with default value', () => {
+    const schema = new IntegerSchema({ default: 50, minimum: 10, maximum: 100 })
+
+    it('uses default when undefined is provided', () => {
+      const result = schema.safeParse(undefined)
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.value).toBe(50)
+      }
+    })
+
+    it('validates explicit values with constraints', () => {
+      const result = schema.safeParse(75)
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects explicit values outside constraints', () => {
+      const result = schema.safeParse(5)
+      expect(result.success).toBe(false)
+    })
+  })
+
+  describe('edge cases', () => {
+    it('handles minimum of 0', () => {
+      const schema = new IntegerSchema({ minimum: 0 })
+      expect(schema.safeParse(0).success).toBe(true)
+      expect(schema.safeParse(-1).success).toBe(false)
+      expect(schema.safeParse(1).success).toBe(true)
+    })
+
+    it('handles maximum of 0', () => {
+      const schema = new IntegerSchema({ maximum: 0 })
+      expect(schema.safeParse(0).success).toBe(true)
+      expect(schema.safeParse(1).success).toBe(false)
+      expect(schema.safeParse(-1).success).toBe(true)
+    })
+
+    it('handles very large ranges', () => {
+      const schema = new IntegerSchema({
+        minimum: Number.MIN_SAFE_INTEGER,
+        maximum: Number.MAX_SAFE_INTEGER,
+      })
+      expect(schema.safeParse(Number.MIN_SAFE_INTEGER).success).toBe(true)
+      expect(schema.safeParse(Number.MAX_SAFE_INTEGER).success).toBe(true)
+      expect(schema.safeParse(0).success).toBe(true)
+    })
+
+    it('allows unconstrained schema', () => {
+      const schema = new IntegerSchema({})
+      expect(schema.safeParse(Number.MIN_SAFE_INTEGER).success).toBe(true)
+      expect(schema.safeParse(Number.MAX_SAFE_INTEGER).success).toBe(true)
+      expect(schema.safeParse(0).success).toBe(true)
+      expect(schema.safeParse(-999999).success).toBe(true)
+      expect(schema.safeParse(999999).success).toBe(true)
+    })
+  })
+})

package/src/schema/integer.ts

@@ -1,4 +1,4 @@
-import { ValidationResult, Validator, ValidatorContext } from '../validation.js'
+import { Schema, ValidationResult, ValidatorContext } from '../validation.js'
 
 export type IntegerSchemaOptions = {
   default?: number
@@ -6,15 +6,13 @@ export type IntegerSchemaOptions = {
   maximum?: number
 }
 
-export class IntegerSchema extends Validator<number> {
-  readonly lexiconType = 'integer' as const
-
-  constructor(readonly options: IntegerSchemaOptions) {
+export class IntegerSchema extends Schema<number> {
+  constructor(readonly options: IntegerSchemaOptions = {}) {
     super()
   }
 
-  override validateInContext(
-    input: unknown = this.options.default,
+  validateInContext(
+    input: unknown = this.options?.default,
     ctx: ValidatorContext,
   ): ValidationResult<number> {
     if (!isInteger(input)) {

package/src/schema/intersection.test.ts

@@ -0,0 +1,32 @@
+import { BooleanSchema } from './boolean.js'
+import { DictSchema } from './dict.js'
+import { EnumSchema } from './enum.js'
+import { IntersectionSchema } from './intersection.js'
+import { ObjectSchema } from './object.js'
+import { StringSchema } from './string.js'
+
+describe('IntersectionSchema', () => {
+  const schema = new IntersectionSchema(
+    new ObjectSchema({
+      title: new StringSchema({}),
+    }),
+    new DictSchema(new EnumSchema(['tag1', 'tag2']), new BooleanSchema({})),
+  )
+
+  it('validates extra properties with the provided validator', () => {
+    const result = schema.safeParse({
+      title: 'My Post',
+      tag1: true,
+      tag2: false,
+    })
+    expect(result.success).toBe(true)
+  })
+
+  it('rejects extra properties that fail the provided validator', () => {
+    const result = schema.safeParse({
+      title: 'My Post',
+      tag1: 'not a boolean',
+    })
+    expect(result.success).toBe(false)
+  })
+})

package/src/schema/intersection.ts

@@ -1,57 +1,54 @@
+import { Simplify } from '../core.js'
 import {
   Infer,
+  Schema,
   ValidationResult,
-  Validator,
   ValidatorContext,
 } from '../validation.js'
+import { DictSchema } from './dict.js'
+import { ObjectSchema } from './object.js'
+
+/**
+ * Allows to more accurately represent the intersection of two object types
+ * where both types may share some keys, and one of them uses an index
+ * signature.
+ *
+ * @see {@link https://www.typescriptlang.org/play/?#code/C4TwDgpgBAglC8UDeUBmB7dAuKByARgIYBOuUAvlAGTJQDaA+lAJYB2UAzsMWwOYC6OVgFcAtvgjEKAKGkATCAGMANiWiL0rLlEI4YsjVuBQA1hBA4uPVrwRQARBnT2Dm7QDdCy4dESE6ZiD8UAD0IVAi4pJQABQcABbowspyUBIORMT2AJSyEAAeYOjExqCQUACSrMCSHErAzJoAPNJQsFAFNaxyHFAASkrFck1WfAA0UMKsJqzoAO6sAHxjrVAAQh35XT39g8TDozYTUzPzSyuLdqtwVKttMYHoqO00j88bnRDdvawQ7pJ3NpQAD860BbRwSHBQLadAA0ix2G91oJ1vDggAfWABcxPF5QOH8aFtci5aRlaAwVDMfIQVKIKo1Yh1RQNZq0Jw4AgkMjkCYoRiIzjcPioyISKTkRayBQqNRQQzaQgAMRpdL01NpclcRignm8EFVWrsKrVchxQVC4XF0SxmSAA Playground link}
+ */
+export type Intersect<A, B> = B[keyof B] extends never
+  ? A
+  : keyof A & keyof B extends never
+    ? // If A and B don't overlap, just return A & B
+      A & B
+    : // Otherwise, properly represent the fact that accessing using an
+      // index signature could return a value from either A or B
+      A & { [K in keyof B]: B[K] | A[keyof A & K] }
 
-export type IntersectionSchemaValidators = readonly [
-  Validator,
-  Validator,
-  ...Validator[],
-]
 export type IntersectionSchemaOutput<
-  V extends readonly Validator[],
-  Base = unknown,
-> = V extends readonly [
-  infer First extends Validator,
-  ...infer Rest extends Validator[],
-]
-  ? IntersectionSchemaOutput<Rest, Base & Infer<First>>
-  : Base
+  Left extends ObjectSchema,
+  Right extends DictSchema,
+> = Simplify<Intersect<Infer<Left>, Infer<Right>>>
 
 export class IntersectionSchema<
-  V extends IntersectionSchemaValidators = any,
-> extends Validator<IntersectionSchemaOutput<V>> {
-  constructor(protected readonly validators: V) {
+  const Left extends ObjectSchema = any,
+  const Right extends DictSchema = any,
+> extends Schema<IntersectionSchemaOutput<Left, Right>> {
+  constructor(
+    protected readonly left: Left,
+    protected readonly right: Right,
+  ) {
     super()
   }
 
-  override validateInContext(
+  validateInContext(
     input: unknown,
     ctx: ValidatorContext,
-  ): ValidationResult<IntersectionSchemaOutput<V>> {
-    for (let i = 0; i < this.validators.length; i++) {
-      const result = ctx.validate(input, this.validators[i])
-
-      if (!result.success) {
-        return result
-      }
-
-      // @NOTE because transforming the value could make it invalid for previous
-      // validators, we need to ensure the input remains unchanged only gets
-      // transformed by the first validator.
-      if (i !== 0 && input !== result.value) {
-        // The alternative would be to allow transforms on a first pass
-        // (ignoring errors) and then re-validate the final value against all
-        // validators (without allowing further transforms). This would be way
-        // less efficient (we could make this optional).
-        return ctx.issueInvalidValue(input, [result.value])
-      }
-
-      input = result.value
-    }
+  ): ValidationResult<IntersectionSchemaOutput<Left, Right>> {
+    const leftResult = ctx.validate(input, this.left)
+    if (!leftResult.success) return leftResult
 
-    return ctx.success(input as IntersectionSchemaOutput<V>)
+    return this.right.validateInContext(leftResult.value, ctx, {
+      ignoredKeys: this.left.validatorsMap,
+    }) as ValidationResult<IntersectionSchemaOutput<Left, Right>>
   }
 }