@atproto/lexicon 0.0.4 → 0.2.0

package/src/validation.ts

@@ -1,5 +1,10 @@
 import { Lexicons } from './lexicons'
-import { LexRecord, LexXrpcProcedure, LexXrpcQuery } from './types'
+import {
+  LexRecord,
+  LexXrpcProcedure,
+  LexXrpcQuery,
+  LexXrpcSubscription,
+} from './types'
 import { assertValidOneOf } from './util'
 
 import * as ComplexValidators from './validators/complex'
@@ -12,16 +17,18 @@ export function assertValidRecord(
 ) {
   const res = ComplexValidators.object(lexicons, 'Record', def.record, value)
   if (!res.success) throw res.error
+  return res.value
 }
 
 export function assertValidXrpcParams(
   lexicons: Lexicons,
-  def: LexXrpcProcedure | LexXrpcQuery,
+  def: LexXrpcProcedure | LexXrpcQuery | LexXrpcSubscription,
   value: unknown,
 ) {
   if (def.parameters) {
     const res = XrpcValidators.params(lexicons, 'Params', def.parameters, value)
     if (!res.success) throw res.error
+    return res.value
   }
 }
 
@@ -32,7 +39,7 @@ export function assertValidXrpcInput(
 ) {
   if (def.input?.schema) {
     // loop: all input schema definitions
-    assertValidOneOf(lexicons, 'Input', def.input.schema, value, true)
+    return assertValidOneOf(lexicons, 'Input', def.input.schema, value, true)
   }
 }
 
@@ -43,6 +50,23 @@ export function assertValidXrpcOutput(
 ) {
   if (def.output?.schema) {
     // loop: all output schema definitions
-    assertValidOneOf(lexicons, 'Output', def.output.schema, value, true)
+    return assertValidOneOf(lexicons, 'Output', def.output.schema, value, true)
+  }
+}
+
+export function assertValidXrpcMessage(
+  lexicons: Lexicons,
+  def: LexXrpcSubscription,
+  value: unknown,
+) {
+  if (def.message?.schema) {
+    // loop: all output schema definitions
+    return assertValidOneOf(
+      lexicons,
+      'Message',
+      def.message.schema,
+      value,
+      true,
+    )
   }
 }

package/src/validators/blob.ts

@@ -1,6 +1,6 @@
+import { BlobRef } from '../blob-refs'
 import { Lexicons } from '../lexicons'
 import { LexUserType, ValidationResult, ValidationError } from '../types'
-import { isObj, hasProp } from '../types'
 
 export function blob(
   lexicons: Lexicons,
@@ -8,50 +8,12 @@ export function blob(
   def: LexUserType,
   value: unknown,
 ): ValidationResult {
-  if (!isObj(value)) {
+  // check
+  if (!value || !(value instanceof BlobRef)) {
     return {
       success: false,
-      error: new ValidationError(`${path} should be an object`),
+      error: new ValidationError(`${path} should be a blob ref`),
     }
   }
-  if (!hasProp(value, 'cid') || typeof value.cid !== 'string') {
-    return {
-      success: false,
-      error: new ValidationError(`${path}/cid should be a string`),
-    }
-  }
-  if (!hasProp(value, 'mimeType') || typeof value.mimeType !== 'string') {
-    return {
-      success: false,
-      error: new ValidationError(`${path}/mimeType should be a string`),
-    }
-  }
-  return { success: true }
-}
-
-export function image(
-  lexicons: Lexicons,
-  path: string,
-  def: LexUserType,
-  value: unknown,
-): ValidationResult {
-  return blob(lexicons, path, def, value)
-}
-
-export function video(
-  lexicons: Lexicons,
-  path: string,
-  def: LexUserType,
-  value: unknown,
-): ValidationResult {
-  return blob(lexicons, path, def, value)
-}
-
-export function audio(
-  lexicons: Lexicons,
-  path: string,
-  def: LexUserType,
-  value: unknown,
-): ValidationResult {
-  return blob(lexicons, path, def, value)
+  return { success: true, value }
 }

package/src/validators/complex.ts

@@ -20,14 +20,14 @@ export function validate(
   switch (def.type) {
     case 'boolean':
       return Primitives.boolean(lexicons, path, def, value)
-    case 'number':
-      return Primitives.number(lexicons, path, def, value)
     case 'integer':
       return Primitives.integer(lexicons, path, def, value)
     case 'string':
       return Primitives.string(lexicons, path, def, value)
-    case 'datetime':
-      return Primitives.datetime(lexicons, path, def, value)
+    case 'bytes':
+      return Primitives.bytes(lexicons, path, def, value)
+    case 'cid-link':
+      return Primitives.cidLink(lexicons, path, def, value)
     case 'unknown':
       return Primitives.unknown(lexicons, path, def, value)
     case 'object':
@@ -36,12 +36,6 @@ export function validate(
       return array(lexicons, path, def, value)
     case 'blob':
       return Blob.blob(lexicons, path, def, value)
-    case 'image':
-      return Blob.image(lexicons, path, def, value)
-    case 'video':
-      return Blob.video(lexicons, path, def, value)
-    case 'audio':
-      return Blob.audio(lexicons, path, def, value)
     default:
       return {
         success: false,
@@ -53,11 +47,9 @@ export function validate(
 export function array(
   lexicons: Lexicons,
   path: string,
-  def: LexUserType,
+  def: LexArray,
   value: unknown,
 ): ValidationResult {
-  def = def as LexArray
-
   // type
   if (!Array.isArray(value)) {
     return {
@@ -101,7 +93,7 @@ export function array(
     }
   }
 
-  return { success: true }
+  return { success: true, value }
 }
 
 export function object(
@@ -120,33 +112,40 @@ export function object(
     }
   }
 
-  // required
-  if (Array.isArray(def.required)) {
-    for (const key of def.required) {
-      if (!(key in value)) {
-        return {
-          success: false,
-          error: new ValidationError(`${path} must have the property "${key}"`),
-        }
-      }
-    }
-  }
+  const requiredProps = new Set(def.required)
+  const nullableProps = new Set(def.nullable)
 
   // properties
+  let resultValue = value
   if (typeof def.properties === 'object') {
     for (const key in def.properties) {
-      const propValue = value[key]
-      if (typeof propValue === 'undefined') {
-        continue // skip- if required, will have already failed
+      if (value[key] === null && nullableProps.has(key)) {
+        continue
       }
       const propDef = def.properties[key]
       const propPath = `${path}/${key}`
-      const res = validateOneOf(lexicons, propPath, propDef, propValue)
-      if (!res.success) {
-        return res
+      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 (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 !== value[key]) {
+        if (resultValue === value) {
+          // Lazy shallow clone
+          resultValue = { ...value }
+        }
+        resultValue[key] = propValue
       }
     }
   }
 
-  return { success: true }
+  return { success: true, value: resultValue }
 }

package/src/validators/formats.ts

@@ -0,0 +1,121 @@
+import { ensureValidAtUri } from '@atproto/uri'
+import { isValidISODateString } from 'iso-datestring-validator'
+import { CID } from 'multiformats/cid'
+import { ValidationResult, ValidationError } from '../types'
+import { ensureValidDid, ensureValidHandle } from '@atproto/identifier'
+import { ensureValidNsid } from '@atproto/nsid'
+import { validateLanguage } from '@atproto/common-web'
+
+export function datetime(path: string, value: string): ValidationResult {
+  try {
+    if (!isValidISODateString(value)) {
+      throw new Error()
+    }
+  } catch {
+    return {
+      success: false,
+      error: new ValidationError(
+        `${path} must be an iso8601 formatted datetime`,
+      ),
+    }
+  }
+  return { success: true, value }
+}
+
+export function uri(path: string, value: string): ValidationResult {
+  const isUri = value.match(/^\w+:(?:\/\/)?[^\s/][^\s]*$/) !== null
+  if (!isUri) {
+    return {
+      success: false,
+      error: new ValidationError(`${path} must be a uri`),
+    }
+  }
+  return { success: true, value }
+}
+
+export function atUri(path: string, value: string): ValidationResult {
+  try {
+    ensureValidAtUri(value)
+  } catch {
+    return {
+      success: false,
+      error: new ValidationError(`${path} must be a valid at-uri`),
+    }
+  }
+  return { success: true, value }
+}
+
+export function did(path: string, value: string): ValidationResult {
+  try {
+    ensureValidDid(value)
+  } catch {
+    return {
+      success: false,
+      error: new ValidationError(`${path} must be a valid did`),
+    }
+  }
+  return { success: true, value }
+}
+
+export function handle(path: string, value: string): ValidationResult {
+  try {
+    ensureValidHandle(value)
+  } catch {
+    return {
+      success: false,
+      error: new ValidationError(`${path} must be a valid handle`),
+    }
+  }
+  return { success: true, value }
+}
+
+export function atIdentifier(path: string, value: string): ValidationResult {
+  const isDid = did(path, value)
+  if (!isDid.success) {
+    const isHandle = handle(path, value)
+    if (!isHandle.success) {
+      return {
+        success: false,
+        error: new ValidationError(`${path} must be a valid did or a handle`),
+      }
+    }
+  }
+  return { success: true, value }
+}
+
+export function nsid(path: string, value: string): ValidationResult {
+  try {
+    ensureValidNsid(value)
+  } catch {
+    return {
+      success: false,
+      error: new ValidationError(`${path} must be a valid nsid`),
+    }
+  }
+  return { success: true, value }
+}
+
+export function cid(path: string, value: string): ValidationResult {
+  try {
+    CID.parse(value)
+  } catch {
+    return {
+      success: false,
+      error: new ValidationError(`${path} must be a cid string`),
+    }
+  }
+  return { success: true, value }
+}
+
+// The language format validates well-formed BCP 47 language tags: https://www.rfc-editor.org/info/bcp47
+export function language(path: string, value: string): ValidationResult {
+  if (validateLanguage(value)) {
+    return { success: true, value }
+  }
+  return {
+    success: false,
+    error: new ValidationError(
+      `${path} must be a well-formed BCP 47 language tag`,
+    ),
+  }
+}

package/src/validators/primitives.ts

@@ -1,14 +1,15 @@
-import { isValidISODateString } from 'iso-datestring-validator'
+import { utf8Len, graphemeLen } from '@atproto/common-web'
+import { CID } from 'multiformats/cid'
 import { Lexicons } from '../lexicons'
+import * as formats from './formats'
 import {
   LexUserType,
   LexBoolean,
-  LexNumber,
   LexInteger,
   LexString,
-  LexDatetime,
   ValidationResult,
   ValidationError,
+  LexBytes,
 } from '../types'
 
 export function validate(
@@ -20,14 +21,14 @@ export function validate(
   switch (def.type) {
     case 'boolean':
       return boolean(lexicons, path, def, value)
-    case 'number':
-      return number(lexicons, path, def, value)
     case 'integer':
       return integer(lexicons, path, def, value)
     case 'string':
       return string(lexicons, path, def, value)
-    case 'datetime':
-      return datetime(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)
     default:
@@ -48,9 +49,9 @@ export function boolean(
 
   // type
   const type = typeof value
-  if (type == 'undefined') {
+  if (type === 'undefined') {
     if (typeof def.default === 'boolean') {
-      return { success: true }
+      return { success: true, value: def.default }
     }
     return {
       success: false,
@@ -73,31 +74,31 @@ export function boolean(
     }
   }
 
-  return { success: true }
+  return { success: true, value }
 }
 
-export function number(
+export function integer(
   lexicons: Lexicons,
   path: string,
   def: LexUserType,
   value: unknown,
 ): ValidationResult {
-  def = def as LexNumber
+  def = def as LexInteger
 
   // type
   const type = typeof value
-  if (type == 'undefined') {
+  if (type === 'undefined') {
     if (typeof def.default === 'number') {
-      return { success: true }
+      return { success: true, value: def.default }
     }
     return {
       success: false,
-      error: new ValidationError(`${path} must be a number`),
+      error: new ValidationError(`${path} must be an integer`),
     }
-  } else if (type !== 'number') {
+  } else if (!Number.isInteger(value)) {
     return {
       success: false,
-      error: new ValidationError(`${path} must be a number`),
+      error: new ValidationError(`${path} must be an integer`),
     }
   }
 
@@ -147,32 +148,7 @@ export function number(
     }
   }
 
-  return { success: true }
-}
-
-export function integer(
-  lexicons: Lexicons,
-  path: string,
-  def: LexUserType,
-  value: unknown,
-): ValidationResult {
-  def = def as LexInteger
-
-  // run number validation
-  const numRes = number(lexicons, path, def, value)
-  if (!numRes.success) {
-    return numRes
-  }
-
-  // whole numbers only
-  if (!Number.isInteger(value)) {
-    return {
-      success: false,
-      error: new ValidationError(`${path} must be an integer`),
-    }
-  }
-
-  return { success: true }
+  return { success: true, value }
 }
 
 export function string(
@@ -184,16 +160,15 @@ export function string(
   def = def as LexString
 
   // type
-  const type = typeof value
-  if (type == 'undefined') {
+  if (typeof value === 'undefined') {
     if (typeof def.default === 'string') {
-      return { success: true }
+      return { success: true, value: def.default }
     }
     return {
       success: false,
       error: new ValidationError(`${path} must be a string`),
     }
-  } else if (type !== 'string') {
+  } else if (typeof value !== 'string') {
     return {
       success: false,
       error: new ValidationError(`${path} must be a string`),
@@ -224,7 +199,7 @@ export function string(
 
   // maxLength
   if (typeof def.maxLength === 'number') {
-    if ((value as string).length > def.maxLength) {
+    if (utf8Len(value) > def.maxLength) {
       return {
         success: false,
         error: new ValidationError(
@@ -236,7 +211,7 @@ export function string(
 
   // minLength
   if (typeof def.minLength === 'number') {
-    if ((value as string).length < def.minLength) {
+    if (utf8Len(value) < def.minLength) {
       return {
         success: false,
         error: new ValidationError(
@@ -246,40 +221,112 @@ export function string(
     }
   }
 
-  return { success: true }
+  // maxGraphemes
+  if (typeof def.maxGraphemes === 'number') {
+    if (graphemeLen(value) > def.maxGraphemes) {
+      return {
+        success: false,
+        error: new ValidationError(
+          `${path} must not be longer than ${def.maxGraphemes} graphemes`,
+        ),
+      }
+    }
+  }
+
+  // minGraphemes
+  if (typeof def.minGraphemes === 'number') {
+    if (graphemeLen(value) < def.minGraphemes) {
+      return {
+        success: false,
+        error: new ValidationError(
+          `${path} must not be shorter than ${def.minGraphemes} graphemes`,
+        ),
+      }
+    }
+  }
+
+  if (typeof def.format === 'string') {
+    switch (def.format) {
+      case 'datetime':
+        return formats.datetime(path, value)
+      case 'uri':
+        return formats.uri(path, value)
+      case 'at-uri':
+        return formats.atUri(path, value)
+      case 'did':
+        return formats.did(path, value)
+      case 'handle':
+        return formats.handle(path, value)
+      case 'at-identifier':
+        return formats.atIdentifier(path, value)
+      case 'nsid':
+        return formats.nsid(path, value)
+      case 'cid':
+        return formats.cid(path, value)
+      case 'language':
+        return formats.language(path, value)
+    }
+  }
+
+  return { success: true, value }
 }
 
-export function datetime(
+export function bytes(
   lexicons: Lexicons,
   path: string,
   def: LexUserType,
   value: unknown,
 ): ValidationResult {
-  def = def as LexDatetime
+  def = def as LexBytes
 
-  // type
-  const type = typeof value
-  if (type !== 'string') {
+  if (!value || !(value instanceof Uint8Array)) {
     return {
       success: false,
-      error: new ValidationError(`${path} must be a string`),
+      error: new ValidationError(`${path} must be a byte array`),
+    }
+  }
+
+  // maxLength
+  if (typeof def.maxLength === 'number') {
+    if (value.byteLength > def.maxLength) {
+      return {
+        success: false,
+        error: new ValidationError(
+          `${path} must not be larger than ${def.maxLength} bytes`,
+        ),
+      }
     }
   }
 
-  // valid iso-8601
-  {
-    try {
-      if (typeof value !== 'string' || !isValidISODateString(value)) {
-        throw new ValidationError(
-          `${path} must be an iso8601 formatted datetime`,
-        )
+  // minLength
+  if (typeof def.minLength === 'number') {
+    if (value.byteLength < def.minLength) {
+      return {
+        success: false,
+        error: new ValidationError(
+          `${path} must not be smaller than ${def.minLength} bytes`,
+        ),
       }
-    } catch {
-      throw new ValidationError(`${path} must be an iso8601 formatted datetime`)
     }
   }
 
-  return { success: true }
+  return { success: true, value }
+}
+
+export function cidLink(
+  lexicons: Lexicons,
+  path: string,
+  def: LexUserType,
+  value: unknown,
+): ValidationResult {
+  if (CID.asCID(value) === null) {
+    return {
+      success: false,
+      error: new ValidationError(`${path} must be a CID`),
+    }
+  }
+
+  return { success: true, value }
 }
 
 export function unknown(
@@ -296,5 +343,5 @@ export function unknown(
     }
   }
 
-  return { success: true }
+  return { success: true, value }
 }