@atproto/lexicon 0.7.3 → 0.7.4

package/src/validation.ts

@@ -1,84 +0,0 @@
-import { Lexicons } from './lexicons.js'
-import {
-  LexRecord,
-  LexRefVariant,
-  LexUserType,
-  LexXrpcProcedure,
-  LexXrpcQuery,
-  LexXrpcSubscription,
-} from './types.js'
-import { object, validateOneOf } from './validators/complex.js'
-import { params } from './validators/xrpc.js'
-
-export function assertValidRecord(
-  lexicons: Lexicons,
-  def: LexRecord,
-  value: unknown,
-) {
-  const res = object(lexicons, 'Record', def.record, value)
-  if (!res.success) throw res.error
-  return res.value
-}
-
-export function assertValidXrpcParams(
-  lexicons: Lexicons,
-  def: LexXrpcProcedure | LexXrpcQuery | LexXrpcSubscription,
-  value: unknown,
-) {
-  if (def.parameters) {
-    const res = params(lexicons, 'Params', def.parameters, value)
-    if (!res.success) throw res.error
-    return res.value
-  }
-}
-
-export function assertValidXrpcInput(
-  lexicons: Lexicons,
-  def: LexXrpcProcedure,
-  value: unknown,
-) {
-  if (def.input?.schema) {
-    // loop: all input schema definitions
-    return assertValidOneOf(lexicons, 'Input', def.input.schema, value, true)
-  }
-}
-
-export function assertValidXrpcOutput(
-  lexicons: Lexicons,
-  def: LexXrpcProcedure | LexXrpcQuery,
-  value: unknown,
-) {
-  if (def.output?.schema) {
-    // loop: all output schema definitions
-    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,
-    )
-  }
-}
-
-function assertValidOneOf(
-  lexicons: Lexicons,
-  path: string,
-  def: LexRefVariant | LexUserType,
-  value: unknown,
-  mustBeObj = false,
-) {
-  const res = validateOneOf(lexicons, path, def, value, mustBeObj)
-  if (!res.success) throw res.error
-  return res.value
-}

package/src/validators/blob.ts

@@ -1,19 +0,0 @@
-import { BlobRef } from '../blob-refs.js'
-import { Lexicons } from '../lexicons.js'
-import { LexUserType, ValidationError, ValidationResult } from '../types.js'
-
-export function blob(
-  lexicons: Lexicons,
-  path: string,
-  def: LexUserType,
-  value: unknown,
-): ValidationResult {
-  // check
-  if (!value || !(value instanceof BlobRef)) {
-    return {
-      success: false,
-      error: new ValidationError(`${path} should be a blob ref`),
-    }
-  }
-  return { success: true, value }
-}

package/src/validators/complex.ts

@@ -1,212 +0,0 @@
-import { Lexicons } from '../lexicons.js'
-import {
-  LexArray,
-  LexRefVariant,
-  LexUserType,
-  ValidationError,
-  ValidationResult,
-  isDiscriminatedObject,
-  isObj,
-} from '../types.js'
-import { toLexUri } from '../util.js'
-import { blob } from './blob.js'
-import { validate as validatePrimitive } from './primitives.js'
-
-export function validate(
-  lexicons: Lexicons,
-  path: string,
-  def: LexUserType,
-  value: unknown,
-): ValidationResult {
-  switch (def.type) {
-    case 'object':
-      return object(lexicons, path, def, value)
-    case 'array':
-      return array(lexicons, path, def, value)
-    case 'blob':
-      return blob(lexicons, path, def, value)
-    default:
-      return validatePrimitive(lexicons, path, def, value)
-  }
-}
-
-export function array(
-  lexicons: Lexicons,
-  path: string,
-  def: LexArray,
-  value: unknown,
-): ValidationResult {
-  // type
-  if (!Array.isArray(value)) {
-    return {
-      success: false,
-      error: new ValidationError(`${path} must be an array`),
-    }
-  }
-
-  // maxLength
-  if (typeof def.maxLength === 'number') {
-    if ((value as Array<unknown>).length > def.maxLength) {
-      return {
-        success: false,
-        error: new ValidationError(
-          `${path} must not have more than ${def.maxLength} elements`,
-        ),
-      }
-    }
-  }
-
-  // minLength
-  if (typeof def.minLength === 'number') {
-    if ((value as Array<unknown>).length < def.minLength) {
-      return {
-        success: false,
-        error: new ValidationError(
-          `${path} must not have fewer than ${def.minLength} elements`,
-        ),
-      }
-    }
-  }
-
-  // items
-  const itemsDef = def.items
-  for (let i = 0; i < (value as Array<unknown>).length; i++) {
-    const itemValue = value[i]
-    const itemPath = `${path}/${i}`
-    const res = validateOneOf(lexicons, itemPath, itemsDef, itemValue)
-    if (!res.success) {
-      return res
-    }
-  }
-
-  return { success: true, value }
-}
-
-export function object(
-  lexicons: Lexicons,
-  path: string,
-  def: LexUserType,
-  value: unknown,
-): ValidationResult {
-  // type
-  if (!isObj(value)) {
-    return {
-      success: false,
-      error: new ValidationError(`${path} must be an object`),
-    }
-  }
-
-  // properties
-  let resultValue = value
-  if ('properties' in def && def.properties != null) {
-    for (const key in def.properties) {
-      const keyValue = value[key]
-      if (keyValue === null && def.nullable?.includes(key)) {
-        continue
-      }
-      const propDef = def.properties[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 (propDef.default === undefined) {
-            continue
-          }
-        } else {
-          // Other types have no defaults.
-          continue
-        }
-      }
-      const propPath = `${path}/${key}`
-      const validated = validateOneOf(lexicons, propPath, propDef, keyValue)
-      const propValue = validated.success ? validated.value : keyValue
-
-      // 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
-        }
-      }
-
-      // Adjust value based on e.g. applied defaults, cloning shallowly if there was a changed value
-      if (propValue !== keyValue) {
-        if (resultValue === value) {
-          // Lazy shallow clone
-          resultValue = { ...value }
-        }
-        resultValue[key] = propValue
-      }
-    }
-  }
-
-  return { success: true, value: resultValue }
-}
-
-export function validateOneOf(
-  lexicons: Lexicons,
-  path: string,
-  def: LexRefVariant | LexUserType,
-  value: unknown,
-  mustBeObj = false, // this is the only type constraint we need currently (used by xrpc body schema validators)
-): ValidationResult {
-  let concreteDef: LexUserType
-
-  if (def.type === 'union') {
-    if (!isDiscriminatedObject(value)) {
-      return {
-        success: false,
-        error: new ValidationError(
-          `${path} must be an object which includes the "$type" property`,
-        ),
-      }
-    }
-    if (!refsContainType(def.refs, value.$type)) {
-      if (def.closed) {
-        return {
-          success: false,
-          error: new ValidationError(
-            `${path} $type must be one of ${def.refs.join(', ')}`,
-          ),
-        }
-      }
-      return { success: true, value }
-    } else {
-      concreteDef = lexicons.getDefOrThrow(value.$type)
-    }
-  } else if (def.type === 'ref') {
-    concreteDef = lexicons.getDefOrThrow(def.ref)
-  } else {
-    concreteDef = def
-  }
-
-  return mustBeObj
-    ? object(lexicons, path, concreteDef, value)
-    : validate(lexicons, path, concreteDef, value)
-}
-
-// to avoid bugs like #0189 this needs to handle both
-// explicit and implicit #main
-const refsContainType = (refs: string[], type: string) => {
-  const lexUri = toLexUri(type)
-  if (refs.includes(lexUri)) {
-    return true
-  }
-
-  if (lexUri.endsWith('#main')) {
-    return refs.includes(lexUri.slice(0, -5))
-  } else {
-    return !lexUri.includes('#') && refs.includes(`${lexUri}#main`)
-  }
-}

package/src/validators/formats.ts

@@ -1,72 +0,0 @@
-import { CID } from 'multiformats/cid'
-import {
-  isAtIdentifierString,
-  isAtUriString,
-  isDatetimeStringLenient,
-  isValidDid,
-  isValidHandle,
-  isValidLanguage,
-  isValidNsid,
-  isValidRecordKey,
-  isValidTid,
-  isValidUri,
-} from '@atproto/syntax'
-import { ValidationError, ValidationResult } from '../types.js'
-
-export const datetime = createValidator(
-  isDatetimeStringLenient,
-  'must be an valid atproto datetime (both RFC-3339 and ISO-8601)',
-)
-export const uri = createValidator(isValidUri, 'must be a uri')
-export const atUri = createValidator(isAtUriString, 'must be a valid at-uri')
-export const did = createValidator(isValidDid, 'must be a valid did')
-export const handle = createValidator(isValidHandle, 'must be a valid handle')
-export const atIdentifier = createValidator(
-  isAtIdentifierString,
-  'must be a valid did or a handle',
-)
-export const nsid = createValidator(isValidNsid, 'must be a valid nsid')
-export const cid = createValidator(isCidString, 'must be a cid string')
-export const language = createValidator(
-  isValidLanguage,
-  'must be a well-formed BCP 47 language tag',
-)
-export const tid = createValidator(isValidTid, 'must be a valid TID')
-export const recordKey = createValidator(
-  isValidRecordKey,
-  'must be a valid Record Key',
-)
-
-// Internal helpers
-
-function createValidator<T extends string>(
-  assertionFn: (value: string) => value is T,
-  errorMessage: string,
-): <V extends string>(path: string, value: V) => ValidationResult<V & T>
-function createValidator(
-  assertionFn: (value: string) => boolean,
-  errorMessage: string,
-): (path: string, value: string) => ValidationResult<string>
-function createValidator(
-  assertionFn: (value: string) => boolean,
-  errorMessage: string,
-) {
-  return (path: string, value: string): ValidationResult => {
-    if (assertionFn(value)) {
-      return { success: true, value }
-    }
-    return {
-      success: false,
-      error: new ValidationError(`${path} ${errorMessage}`),
-    }
-  }
-}
-
-function isCidString(v: string): v is string {
-  try {
-    CID.parse(v)
-    return true
-  } catch {
-    return false
-  }
-}