@atproto/lexicon 0.4.6-next.5 → 0.4.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atproto/lexicon",
-  "version": "0.4.6-next.5",
+  "version": "0.4.6",
   "license": "MIT",
   "description": "atproto Lexicon schema language library",
   "keywords": [
@@ -19,8 +19,8 @@
     "iso-datestring-validator": "^2.2.2",
     "multiformats": "^9.9.0",
     "zod": "^3.23.8",
-    "@atproto/common-web": "^0.3.2",
-    "@atproto/syntax": "^0.3.1"
+    "@atproto/common-web": "^0.4.0",
+    "@atproto/syntax": "^0.3.2"
   },
   "devDependencies": {
     "jest": "^28.1.2",

package/src/lexicons.ts

@@ -6,6 +6,7 @@ import {
   LexiconDoc,
   ValidationError,
   ValidationResult,
+  hasProp,
   isObj,
 } from './types'
 import { toLexUri } from './util'
@@ -16,7 +17,7 @@ import {
   assertValidXrpcOutput,
   assertValidXrpcParams,
 } from './validation'
-import { object as validateObject } from './validators/complex'
+import * as ComplexValidators from './validators/complex'
 
 /**
  * A collection of compiled lexicons.
@@ -126,17 +127,15 @@ export class Lexicons implements Iterable<LexiconDoc> {
    * Validate a record or object.
    */
   validate(lexUri: string, value: unknown): ValidationResult {
+    lexUri = toLexUri(lexUri)
+    const def = this.getDefOrThrow(lexUri, ['record', 'object'])
     if (!isObj(value)) {
       throw new ValidationError(`Value must be an object`)
     }
-
-    const lexUriNormalized = toLexUri(lexUri)
-    const def = this.getDefOrThrow(lexUriNormalized, ['record', 'object'])
-
     if (def.type === 'record') {
-      return validateObject(this, 'Record', def.record, value)
+      return ComplexValidators.object(this, 'Record', def.record, value)
     } else if (def.type === 'object') {
-      return validateObject(this, 'Object', def, value)
+      return ComplexValidators.object(this, 'Object', def, value)
     } else {
       // shouldn't happen
       throw new InvalidLexiconError('Definition must be a record or object')
@@ -147,25 +146,20 @@ export class Lexicons implements Iterable<LexiconDoc> {
    * Validate a record and throw on any error.
    */
   assertValidRecord(lexUri: string, value: unknown) {
+    lexUri = toLexUri(lexUri)
+    const def = this.getDefOrThrow(lexUri, ['record'])
     if (!isObj(value)) {
       throw new ValidationError(`Record must be an object`)
     }
-    if (!('$type' in value)) {
+    if (!hasProp(value, '$type') || typeof value.$type !== 'string') {
       throw new ValidationError(`Record/$type must be a string`)
     }
-    const { $type } = value
-    if (typeof $type !== 'string') {
-      throw new ValidationError(`Record/$type must be a string`)
-    }
-
-    const lexUriNormalized = toLexUri(lexUri)
-    if (toLexUri($type) !== lexUriNormalized) {
+    const $type = (value as Record<string, string>).$type || ''
+    if (toLexUri($type) !== lexUri) {
       throw new ValidationError(
-        `Invalid $type: must be ${lexUriNormalized}, got ${$type}`,
+        `Invalid $type: must be ${lexUri}, got ${$type}`,
       )
     }
-
-    const def = this.getDefOrThrow(lexUriNormalized, ['record'])
     return assertValidRecord(this, def as LexRecord, value)
   }
 

package/src/types.ts

@@ -447,13 +447,23 @@ export function isValidLexiconDoc(v: unknown): v is LexiconDoc {
   return lexiconDoc.safeParse(v).success
 }
 
-export function isObj<V>(v: V): v is V & object {
-  return v != null && typeof v === 'object'
+export function isObj(obj: unknown): obj is Record<string, unknown> {
+  return obj !== null && typeof obj === 'object'
 }
 
-export type DiscriminatedObject = { $type: string }
-export function isDiscriminatedObject(v: unknown): v is DiscriminatedObject {
-  return isObj(v) && '$type' in v && typeof v.$type === 'string'
+export function hasProp<K extends PropertyKey>(
+  data: object,
+  prop: K,
+): data is Record<K, unknown> {
+  return prop in data
+}
+
+export const discriminatedObject = z.object({ $type: z.string() })
+export type DiscriminatedObject = z.infer<typeof discriminatedObject>
+export function isDiscriminatedObject(
+  value: unknown,
+): value is DiscriminatedObject {
+  return discriminatedObject.safeParse(value).success
 }
 
 export function parseLexiconDoc(v: unknown): LexiconDoc {
@@ -461,10 +471,10 @@ export function parseLexiconDoc(v: unknown): LexiconDoc {
   return v as LexiconDoc
 }
 
-export type ValidationResult<V = unknown> =
+export type ValidationResult =
   | {
       success: true
-      value: V
+      value: unknown
     }
   | {
       success: false

package/src/util.ts

@@ -1,4 +1,6 @@
 import { z } from 'zod'
+import { Lexicons } from './lexicons'
+import { LexRefVariant, LexUserType } from './types'
 
 export function toLexUri(str: string, baseUri?: string): string {
   if (str.split('#').length > 2) {
@@ -17,6 +19,19 @@ export function toLexUri(str: string, baseUri?: string): string {
   return `lex:${str}`
 }
 
+export function toConcreteTypes(
+  lexicons: Lexicons,
+  def: LexRefVariant | LexUserType,
+): LexUserType[] {
+  if (def.type === 'ref') {
+    return [lexicons.getDefOrThrow(def.ref)]
+  } else if (def.type === 'union') {
+    return def.refs.map((ref) => lexicons.getDefOrThrow(ref)).flat()
+  } else {
+    return [def]
+  }
+}
+
 export function requiredPropertiesRefinement<
   ObjectType extends {
     required?: string[]

package/src/validators/complex.ts

@@ -1,16 +1,16 @@
 import { Lexicons } from '../lexicons'
 import {
   LexArray,
+  LexObject,
   LexRefVariant,
   LexUserType,
   ValidationError,
   ValidationResult,
   isDiscriminatedObject,
-  isObj,
 } from '../types'
-import { toLexUri } from '../util'
+import { toConcreteTypes, toLexUri } from '../util'
 import { blob } from './blob'
-import { validate as validatePrimitive } from './primitives'
+import { boolean, bytes, cidLink, integer, string, unknown } from './primitives'
 
 export function validate(
   lexicons: Lexicons,
@@ -19,6 +19,18 @@ export function validate(
   value: unknown,
 ): ValidationResult {
   switch (def.type) {
+    case 'boolean':
+      return boolean(lexicons, path, def, value)
+    case 'integer':
+      return integer(lexicons, path, def, value)
+    case 'string':
+      return string(lexicons, path, def, value)
+    case 'bytes':
+      return bytes(lexicons, path, def, value)
+    case 'cid-link':
+      return cidLink(lexicons, path, def, value)
+    case 'unknown':
+      return unknown(lexicons, path, def, value)
     case 'object':
       return object(lexicons, path, def, value)
     case 'array':
@@ -26,7 +38,10 @@ export function validate(
     case 'blob':
       return blob(lexicons, path, def, value)
     default:
-      return validatePrimitive(lexicons, path, def, value)
+      return {
+        success: false,
+        error: new ValidationError(`Unexpected lexicon type: ${def.type}`),
+      }
   }
 }
 
@@ -88,31 +103,35 @@ export function object(
   def: LexUserType,
   value: unknown,
 ): ValidationResult {
+  def = def as LexObject
+
   // type
-  if (!isObj(value)) {
+  if (!value || typeof value !== 'object') {
     return {
       success: false,
       error: new ValidationError(`${path} must be an object`),
     }
   }
 
+  const requiredProps = new Set(def.required)
+  const nullableProps = new Set(def.nullable)
+
   // properties
   let resultValue = value
-  if ('properties' in def && def.properties != null) {
+  if (typeof def.properties === 'object') {
     for (const key in def.properties) {
-      const keyValue = value[key]
-      if (keyValue === null && def.nullable?.includes(key)) {
+      if (value[key] === null && nullableProps.has(key)) {
         continue
       }
       const propDef = def.properties[key]
-      if (keyValue === undefined && !def.required?.includes(key)) {
+      if (typeof value[key] === 'undefined' && !requiredProps.has(key)) {
         // Fast path for non-required undefined props.
         if (
           propDef.type === 'integer' ||
           propDef.type === 'boolean' ||
           propDef.type === 'string'
         ) {
-          if (propDef.default === undefined) {
+          if (typeof propDef.default === 'undefined') {
             continue
           }
         } else {
@@ -121,27 +140,20 @@ export function object(
         }
       }
       const propPath = `${path}/${key}`
-      const validated = validateOneOf(lexicons, propPath, propDef, keyValue)
-      const propValue = validated.success ? validated.value : keyValue
-
+      const validated = validateOneOf(lexicons, propPath, propDef, value[key])
+      const propValue = validated.success ? validated.value : value[key]
+      const propIsUndefined = typeof propValue === 'undefined'
       // Return error for bad validation, giving required rule precedence
-      if (propValue === undefined) {
-        if (def.required?.includes(key)) {
-          return {
-            success: false,
-            error: new ValidationError(
-              `${path} must have the property "${key}"`,
-            ),
-          }
-        }
-      } else {
-        if (!validated.success) {
-          return validated
+      if (propIsUndefined && requiredProps.has(key)) {
+        return {
+          success: false,
+          error: new ValidationError(`${path} must have the property "${key}"`),
         }
+      } else if (!propIsUndefined && !validated.success) {
+        return validated
       }
-
       // Adjust value based on e.g. applied defaults, cloning shallowly if there was a changed value
-      if (propValue !== keyValue) {
+      if (propValue !== value[key]) {
         if (resultValue === value) {
           // Lazy shallow clone
           resultValue = { ...value }
@@ -161,8 +173,9 @@ export function validateOneOf(
   value: unknown,
   mustBeObj = false, // this is the only type constraint we need currently (used by xrpc body schema validators)
 ): ValidationResult {
-  let concreteDef: LexUserType
+  let error
 
+  let concreteDefs
   if (def.type === 'union') {
     if (!isDiscriminatedObject(value)) {
       return {
@@ -183,17 +196,33 @@ export function validateOneOf(
       }
       return { success: true, value }
     } else {
-      concreteDef = lexicons.getDefOrThrow(value.$type)
+      concreteDefs = toConcreteTypes(lexicons, {
+        type: 'ref',
+        ref: value.$type,
+      })
     }
-  } else if (def.type === 'ref') {
-    concreteDef = lexicons.getDefOrThrow(def.ref)
   } else {
-    concreteDef = def
+    concreteDefs = toConcreteTypes(lexicons, def)
   }
 
-  return mustBeObj
-    ? object(lexicons, path, concreteDef, value)
-    : validate(lexicons, path, concreteDef, value)
+  for (const concreteDef of concreteDefs) {
+    const result = mustBeObj
+      ? object(lexicons, path, concreteDef, value)
+      : validate(lexicons, path, concreteDef, value)
+    if (result.success) {
+      return result
+    }
+    error ??= result.error
+  }
+  if (concreteDefs.length > 1) {
+    return {
+      success: false,
+      error: new ValidationError(
+        `${path} did not match any of the expected definitions`,
+      ),
+    }
+  }
+  return { success: false, error }
 }
 
 // to avoid bugs like #0189 this needs to handle both
@@ -205,7 +234,7 @@ const refsContainType = (refs: string[], type: string) => {
   }
 
   if (lexUri.endsWith('#main')) {
-    return refs.includes(lexUri.slice(0, -5))
+    return refs.includes(lexUri.replace('#main', ''))
   } else {
     return refs.includes(lexUri + '#main')
   }

package/src/validators/formats.ts

@@ -7,7 +7,7 @@ import {
   ensureValidHandle,
   ensureValidNsid,
   ensureValidRecordKey,
-  isValidTid,
+  ensureValidTid,
 } from '@atproto/syntax'
 import { ValidationError, ValidationResult } from '../types'
 
@@ -131,14 +131,17 @@ export function language(path: string, value: string): ValidationResult {
 }
 
 export function tid(path: string, value: string): ValidationResult {
-  if (isValidTid(value)) {
-    return { success: true, value }
-  }
-
-  return {
-    success: false,
-    error: new ValidationError(`${path} must be a valid TID`),
+  try {
+    ensureValidTid(value)
+  } catch {
+    return {
+      success: false,
+      error: new ValidationError(
+        `${path} must be a valid TID (timestamp identifier)`,
+      ),
+    }
   }
+  return { success: true, value }
 }
 
 export function recordKey(path: string, value: string): ValidationResult {

package/src/validators/primitives.ts

@@ -39,7 +39,7 @@ export function validate(
   }
 }
 
-function boolean(
+export function boolean(
   lexicons: Lexicons,
   path: string,
   def: LexUserType,
@@ -77,7 +77,7 @@ function boolean(
   return { success: true, value }
 }
 
-function integer(
+export function integer(
   lexicons: Lexicons,
   path: string,
   def: LexUserType,
@@ -151,7 +151,7 @@ function integer(
   return { success: true, value }
 }
 
-function string(
+export function string(
   lexicons: Lexicons,
   path: string,
   def: LexUserType,
@@ -340,7 +340,7 @@ function string(
   return { success: true, value }
 }
 
-function bytes(
+export function bytes(
   lexicons: Lexicons,
   path: string,
   def: LexUserType,
@@ -382,7 +382,7 @@ function bytes(
   return { success: true, value }
 }
 
-function cidLink(
+export function cidLink(
   lexicons: Lexicons,
   path: string,
   def: LexUserType,
@@ -398,7 +398,7 @@ function cidLink(
   return { success: true, value }
 }
 
-function unknown(
+export function unknown(
   lexicons: Lexicons,
   path: string,
   def: LexUserType,