@atproto/lex-schema 0.1.5 → 0.1.6

package/src/schema/dict.test.ts

@@ -1,181 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { boolean } from './boolean.js'
-import { dict } from './dict.js'
-import { enumSchema } from './enum.js'
-import { integer } from './integer.js'
-import { string } from './string.js'
-
-describe('DictSchema', () => {
-  const schema = dict(string(), integer())
-
-  it('validates plain objects with valid keys and values', () => {
-    const result = schema.safeParse({
-      count: 42,
-      total: 100,
-      score: 85,
-    })
-    expect(result.success).toBe(true)
-  })
-
-  it('validates empty objects', () => {
-    const result = schema.safeParse({})
-    expect(result.success).toBe(true)
-  })
-
-  it('rejects non-objects', () => {
-    const result = schema.safeParse('not an object')
-    expect(result.success).toBe(false)
-  })
-
-  it('rejects arrays', () => {
-    const result = schema.safeParse([1, 2, 3])
-    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 invalid value types', () => {
-    const result = schema.safeParse({
-      count: 'not a number',
-    })
-    expect(result.success).toBe(false)
-  })
-
-  it('rejects when one value is invalid', () => {
-    const result = schema.safeParse({
-      count: 42,
-      invalid: 'string',
-      total: 100,
-    })
-    expect(result.success).toBe(false)
-  })
-
-  it('validates with enum key schema', () => {
-    const enumKeySchema = dict(enumSchema(['tag1', 'tag2', 'tag3']), boolean())
-
-    const result = enumKeySchema.safeParse({
-      tag1: true,
-      tag2: false,
-      tag3: true,
-    })
-    expect(result.success).toBe(true)
-  })
-
-  it('rejects invalid keys with enum key schema', () => {
-    const enumKeySchema = dict(enumSchema(['tag1', 'tag2']), boolean())
-
-    const result = enumKeySchema.safeParse({
-      tag1: true,
-      invalidTag: false,
-    })
-    expect(result.success).toBe(false)
-  })
-
-  it('validates nested dict schemas', () => {
-    const nestedSchema = dict(string(), dict(string(), integer()))
-
-    const result = nestedSchema.safeParse({
-      group1: { count: 10, total: 20 },
-      group2: { score: 85 },
-    })
-    expect(result.success).toBe(true)
-  })
-
-  it('validates with string key schema constraints', () => {
-    const constrainedKeySchema = dict(
-      string({ minLength: 3, maxLength: 10 }),
-      integer(),
-    )
-
-    const result = constrainedKeySchema.safeParse({
-      abc: 1,
-      defghij: 2,
-    })
-    expect(result.success).toBe(true)
-  })
-
-  it('rejects keys that do not meet key schema constraints', () => {
-    const constrainedKeySchema = dict(string({ minLength: 3 }), integer())
-
-    const result = constrainedKeySchema.safeParse({
-      ab: 1, // too short
-    })
-    expect(result.success).toBe(false)
-  })
-
-  it('validates with value schema constraints', () => {
-    const constrainedValueSchema = dict(
-      string(),
-      integer({ minimum: 0, maximum: 100 }),
-    )
-
-    const result = constrainedValueSchema.safeParse({
-      score: 50,
-      total: 100,
-    })
-    expect(result.success).toBe(true)
-  })
-
-  it('rejects values that do not meet value schema constraints', () => {
-    const constrainedValueSchema = dict(
-      string(),
-      integer({ minimum: 0, maximum: 100 }),
-    )
-
-    const result = constrainedValueSchema.safeParse({
-      score: 150, // too high
-    })
-    expect(result.success).toBe(false)
-  })
-
-  it('validates dict with string values', () => {
-    const stringValueSchema = dict(string(), string())
-
-    const result = stringValueSchema.safeParse({
-      name: 'Alice',
-      city: 'New York',
-      country: 'USA',
-    })
-    expect(result.success).toBe(true)
-  })
-
-  it('validates dict with boolean values', () => {
-    const booleanValueSchema = dict(string(), boolean())
-
-    const result = booleanValueSchema.safeParse({
-      enabled: true,
-      visible: false,
-      active: true,
-    })
-    expect(result.success).toBe(true)
-  })
-
-  it('handles objects with numeric string keys', () => {
-    const result = schema.safeParse({
-      '0': 1,
-      '1': 2,
-      '2': 3,
-    })
-    expect(result.success).toBe(true)
-  })
-
-  it('preserves the original object when no transformations occur', () => {
-    const input = { count: 42, total: 100 }
-    const result = schema.safeParse(input)
-
-    if (result.success) {
-      // The implementation returns the same object if no changes are needed
-      expect(result.value).toBe(input)
-    } else {
-      throw new Error('Expected validation to succeed')
-    }
-  })
-})

package/src/schema/dict.ts

@@ -1,122 +0,0 @@
-import { isPlainObject } from '@atproto/lex-data'
-import {
-  InferInput,
-  InferOutput,
-  Schema,
-  ValidationContext,
-  Validator,
-} from '../core.js'
-
-/**
- * Schema for validating dictionary/map-like objects with dynamic keys.
- *
- * Unlike `ObjectSchema` which validates a fixed set of properties, `DictSchema`
- * validates objects where any string key is allowed, with both keys and values
- * validated against their respective schemas.
- *
- * @note There is no dictionary in Lexicon schemas. This is a custom extension
- * to allow map-like objects when using the lex library programmatically (i.e.
- * not code generated from a lexicon schema).
- *
- * @template TKey - The validator type for dictionary keys (must validate strings)
- * @template TValue - The validator type for dictionary values
- *
- * @example
- * ```ts
- * const schema = new DictSchema(l.string(), l.integer())
- * const result = schema.validate({ a: 1, b: 2, c: 3 })
- * ```
- */
-export class DictSchema<
-  const TKey extends Validator<string> = any,
-  const TValue extends Validator = any,
-> extends Schema<
-  Record<InferInput<TKey>, InferInput<TValue>>,
-  Record<InferInput<TKey>, InferOutput<TValue>>
-> {
-  readonly type = 'dict' as const
-
-  constructor(
-    readonly keySchema: TKey,
-    readonly valueSchema: TValue,
-  ) {
-    super()
-  }
-
-  validateInContext(
-    input: unknown,
-    ctx: ValidationContext,
-    options?: { ignoredKeys?: { has(k: string): boolean } },
-  ) {
-    if (!isPlainObject(input)) {
-      return ctx.issueUnexpectedType(input, 'dict')
-    }
-
-    let copy: undefined | Record<string, unknown>
-
-    for (const key in input) {
-      if (options?.ignoredKeys?.has(key)) continue
-
-      const keyResult = ctx.validate(key, this.keySchema)
-      if (!keyResult.success) return keyResult
-      if (keyResult.value !== key) {
-        // We can't safely "move" the key to a different name in the output
-        // object (because there may already be something there), so we issue a
-        // "required key" error if the key validation changes the key
-        return ctx.issueRequiredKey(input, key)
-      }
-
-      const valueResult = ctx.validateChild(input, key, this.valueSchema)
-      if (!valueResult.success) return valueResult
-
-      if (!Object.is(valueResult.value, input[key])) {
-        if (ctx.options.mode === 'validate') {
-          // In "validate" mode, we can't modify the input, so we issue an error
-          return ctx.issueInvalidPropertyValue(input, key, [valueResult.value])
-        }
-
-        copy ??= { ...input }
-        copy[key] = valueResult.value
-      }
-    }
-
-    return ctx.success(copy ?? input)
-  }
-}
-
-/**
- * Creates a dictionary schema for validating map-like objects.
- *
- * Validates objects where all keys match the key schema and all values
- * match the value schema. Useful for dynamic key-value mappings.
- *
- * @param key - Schema to validate each key (must be a string validator)
- * @param value - Schema to validate each value
- * @returns A new {@link DictSchema} instance
- *
- * @example
- * ```ts
- * // String to number mapping
- * const scoresSchema = l.dict(l.string(), l.integer())
- * scoresSchema.parse({ alice: 100, bob: 85 })
- *
- * // Constrained keys
- * const langSchema = l.dict(
- *   l.string({ minLength: 2, maxLength: 5 }), // Language codes
- *   l.string() // Translations
- * )
- *
- * // Complex values
- * const usersById = l.dict(
- *   l.string({ format: 'did' }),
- *   l.object({ name: l.string(), age: l.integer() })
- * )
- * ```
- */
-/*@__NO_SIDE_EFFECTS__*/
-export function dict<
-  const TKey extends Validator<string>,
-  const TValue extends Validator,
->(key: TKey, value: TValue) {
-  return new DictSchema<TKey, TValue>(key, value)
-}