@atproto/lexicon 0.4.6 → 0.4.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atproto/lexicon",
-  "version": "0.4.6",
+  "version": "0.4.8",
   "license": "MIT",
   "description": "atproto Lexicon schema language library",
   "keywords": [
@@ -20,7 +20,7 @@
     "multiformats": "^9.9.0",
     "zod": "^3.23.8",
     "@atproto/common-web": "^0.4.0",
-    "@atproto/syntax": "^0.3.2"
+    "@atproto/syntax": "^0.3.4"
   },
   "devDependencies": {
     "jest": "^28.1.2",

package/src/lexicons.ts

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

package/src/types.ts

@@ -447,23 +447,13 @@ export function isValidLexiconDoc(v: unknown): v is LexiconDoc {
   return lexiconDoc.safeParse(v).success
 }
 
-export function isObj(obj: unknown): obj is Record<string, unknown> {
-  return obj !== null && typeof obj === 'object'
+export function isObj<V>(v: V): v is V & object {
+  return v != null && typeof v === 'object'
 }
 
-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 type DiscriminatedObject = { $type: string }
+export function isDiscriminatedObject(v: unknown): v is DiscriminatedObject {
+  return isObj(v) && '$type' in v && typeof v.$type === 'string'
 }
 
 export function parseLexiconDoc(v: unknown): LexiconDoc {
@@ -471,10 +461,10 @@ export function parseLexiconDoc(v: unknown): LexiconDoc {
   return v as LexiconDoc
 }
 
-export type ValidationResult =
+export type ValidationResult<V = unknown> =
   | {
       success: true
-      value: unknown
+      value: V
     }
   | {
       success: false

package/src/util.ts

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

package/src/validators/formats.ts

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

package/src/validators/primitives.ts

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