@sanity/validation 3.14.3 → 6.12.0-next.112

package/src/validateDocument.ts

@@ -1,240 +0,0 @@
-import {
-  SanityDocument,
-  Schema,
-  SchemaType,
-  ValidationContext,
-  ValidationMarker,
-  isKeyedObject,
-  isTypedObject,
-  isBlockSchemaType,
-  isSpanSchemaType,
-  isPortableTextTextBlock,
-} from '@sanity/types'
-import {concat, defer, lastValueFrom, merge, Observable, of} from 'rxjs'
-import {catchError, map, mergeAll, mergeMap, toArray} from 'rxjs/operators'
-import {flatten, uniqBy} from 'lodash'
-import typeString from './util/typeString'
-import {cancelIdleCallback, requestIdleCallback} from './util/requestIdleCallback'
-import ValidationErrorClass from './ValidationError'
-import normalizeValidationRules from './util/normalizeValidationRules'
-
-const isRecord = (maybeRecord: unknown): maybeRecord is Record<string, unknown> =>
-  typeof maybeRecord === 'object' && maybeRecord !== null && !Array.isArray(maybeRecord)
-
-const isNonNullable = <T>(value: T): value is NonNullable<T> =>
-  value !== null && value !== undefined
-
-/**
- * @internal
- */
-export function resolveTypeForArrayItem(
-  item: unknown,
-  candidates: SchemaType[]
-): SchemaType | undefined {
-  // if there is only one type available, assume that it's the correct one
-  if (candidates.length === 1) return candidates[0]
-
-  const itemType = isTypedObject(item) && item._type
-  const primitive =
-    item === undefined || item === null || (!itemType && typeString(item).toLowerCase())
-
-  if (primitive && primitive !== 'object') {
-    return candidates.find((candidate) => candidate.jsonType === primitive)
-  }
-
-  return (
-    candidates.find((candidate) => candidate.type?.name === itemType) ||
-    candidates.find((candidate) => candidate.name === itemType) ||
-    candidates.find((candidate) => candidate.name === 'object' && primitive === 'object')
-  )
-}
-const EMPTY_MARKERS: ValidationMarker[] = []
-
-export default async function validateDocument(
-  getClient: ValidateItemOptions['getClient'],
-  doc: SanityDocument,
-  schema: Schema,
-  context?: Pick<ValidationContext, 'getDocumentExists'>
-): Promise<ValidationMarker[]> {
-  return lastValueFrom(validateDocumentObservable(getClient, doc, schema, context))
-}
-
-export function validateDocumentObservable(
-  getClient: ValidateItemOptions['getClient'],
-  doc: SanityDocument,
-  schema: Schema,
-  context?: Pick<ValidationContext, 'getDocumentExists'>
-): Observable<ValidationMarker[]> {
-  const documentType = schema.get(doc._type)
-  if (!documentType) {
-    console.warn('Schema type for object type "%s" not found, skipping validation', doc._type)
-    return of(EMPTY_MARKERS)
-  }
-
-  const validationOptions: ValidateItemOptions = {
-    getClient,
-    schema,
-    parent: undefined,
-    value: doc,
-    path: [],
-    document: doc,
-    type: documentType,
-    getDocumentExists: context?.getDocumentExists,
-  }
-
-  return validateItemObservable(validationOptions).pipe(
-    catchError((err) => {
-      console.error(err)
-      return of([
-        {
-          type: 'validation' as const,
-          level: 'error' as const,
-          path: [],
-          item: new ValidationErrorClass(err?.message),
-        },
-      ])
-    })
-  )
-}
-
-/**
- * this is used make optional properties required by replacing optionals with
- * `T[P] | undefined`. this is used to prevent errors in `validateItem` where
- * an option from a previous invocation would be incorrectly passed down.
- *
- * https://medium.com/terria/typescript-transforming-optional-properties-to-required-properties-that-may-be-undefined-7482cb4e1585
- */
-type ExplicitUndefined<T> = {
-  [P in keyof Required<T>]: Pick<T, P> extends Required<Pick<T, P>> ? T[P] : T[P] | undefined
-}
-
-type ValidateItemOptions = {
-  value: unknown
-} & ExplicitUndefined<ValidationContext>
-
-export function validateItem(opts: ValidateItemOptions): Promise<ValidationMarker[]> {
-  return lastValueFrom(validateItemObservable(opts))
-}
-
-function validateItemObservable({
-  value,
-  type,
-  path = [],
-  parent,
-  ...restOfContext
-}: ValidateItemOptions): Observable<ValidationMarker[]> {
-  const rules = normalizeValidationRules(type)
-  // run validation for the current value
-  const selfChecks = rules.map((rule) =>
-    defer(() =>
-      rule.validate(value, {
-        ...restOfContext,
-        parent,
-        path,
-        type,
-      })
-    )
-  )
-
-  // run validation for nested values (conditionally)
-  let nestedChecks: Array<Observable<ValidationMarker[]>> = []
-
-  const selfIsRequired = rules.some((rule) => rule.isRequired())
-  const shouldRunNestedObjectValidation =
-    // run nested validation for objects
-    type?.jsonType === 'object' &&
-    // if the value is truthy
-    (!!value || // or
-      // (the value is null or undefined) and the top-level value is required
-      ((value === null || value === undefined) && selfIsRequired))
-
-  if (shouldRunNestedObjectValidation) {
-    const fieldTypes = type.fields.reduce<Record<string, SchemaType>>((acc, field) => {
-      acc[field.name] = field.type
-      return acc
-    }, {})
-
-    // Validation for rules set at the object level with `Rule.fields({/* ... */})`
-    nestedChecks = nestedChecks.concat(
-      rules
-        .map((rule) => rule._fieldRules)
-        .filter(isNonNullable)
-        .flatMap((fieldResults) => Object.entries(fieldResults))
-        .flatMap(([name, validation]) => {
-          const fieldType = fieldTypes[name]
-          return normalizeValidationRules({...fieldType, validation}).map((subRule) => {
-            const nestedValue = isRecord(value) ? value[name] : undefined
-            return defer(() =>
-              subRule.validate(nestedValue, {
-                ...restOfContext,
-                parent: value,
-                path: path.concat(name),
-                type: fieldType,
-              })
-            )
-          })
-        })
-    )
-
-    // Validation from each field's schema `validation: Rule => {/* ... */}` function
-    nestedChecks = nestedChecks.concat(
-      type.fields.map((field) =>
-        validateItemObservable({
-          ...restOfContext,
-          parent: value,
-          value: isRecord(value) ? value[field.name] : undefined,
-          path: path.concat(field.name),
-          type: field.type,
-        })
-      )
-    )
-  }
-
-  // note: unlike objects, arrays should not run nested validation for undefined
-  // values because we won't have a valid path to put a marker (i.e. missing the
-  // key or index in the path) and the downstream form builder won't have a
-  // valid target component
-  const shouldRunNestedValidationForArrays = type?.jsonType === 'array' && Array.isArray(value)
-
-  if (shouldRunNestedValidationForArrays) {
-    nestedChecks = nestedChecks.concat(
-      value.map((item, index) =>
-        validateItemObservable({
-          ...restOfContext,
-          parent: value,
-          value: item,
-          path: path.concat(isKeyedObject(item) ? {_key: item._key} : index),
-          type: resolveTypeForArrayItem(item, type.of),
-        })
-      )
-    )
-  }
-
-  return defer(() => merge([...selfChecks, ...nestedChecks])).pipe(
-    mergeMap((validateNode) => concat(idle(), validateNode), 40),
-    mergeAll(),
-    toArray(),
-    map(flatten),
-    map((results) => {
-      // run `uniqBy` if `_fieldRules` are present because they can
-      // cause repeat markers
-      if (rules.some((rule) => rule._fieldRules)) {
-        return uniqBy(results, (rule) => JSON.stringify(rule))
-      }
-      return results
-    })
-  )
-}
-
-function idle(timeout?: number): Observable<never> {
-  return new Observable<never>((observer) => {
-    const handle = requestIdleCallback(
-      () => {
-        observer.complete()
-      },
-      timeout ? {timeout} : undefined
-    )
-
-    return () => cancelIdleCallback(handle)
-  })
-}

package/src/validators/arrayValidator.ts

@@ -1,100 +0,0 @@
-import {Path, PathSegment, Validators} from '@sanity/types'
-import deepEquals from '../util/deepEquals'
-import ValidationErrorClass from '../ValidationError'
-import genericValidator from './genericValidator'
-
-const arrayValidators: Validators = {
-  ...genericValidator,
-
-  min: (minLength, value, message) => {
-    if (!value || value.length >= minLength) {
-      return true
-    }
-
-    return message || `Must have at least ${minLength} items`
-  },
-
-  max: (maxLength, value, message) => {
-    if (!value || value.length <= maxLength) {
-      return true
-    }
-
-    return message || `Must have at most ${maxLength} items`
-  },
-
-  length: (wantedLength, value, message) => {
-    if (!value || value.length === wantedLength) {
-      return true
-    }
-
-    return message || `Must have exactly ${wantedLength} items`
-  },
-
-  presence: (flag, value, message) => {
-    if (flag === 'required' && !value) {
-      return message || 'Required'
-    }
-
-    return true
-  },
-
-  valid: (allowedValues, values, message) => {
-    const valueType = typeof values
-    if (valueType === 'undefined') {
-      return true
-    }
-
-    const paths: Path[] = []
-    for (let i = 0; i < values.length; i++) {
-      const value = values[i]
-      if (allowedValues.some((expected) => deepEquals(expected, value))) {
-        continue
-      }
-
-      const pathSegment: PathSegment = value && value._key ? {_key: value._key} : i
-      paths.push([pathSegment])
-    }
-
-    return paths.length === 0
-      ? true
-      : new ValidationErrorClass(message || 'Value did not match any allowed values', {paths})
-  },
-
-  unique: (_unused, value, message) => {
-    const dupeIndices = []
-    if (!value) {
-      return true
-    }
-
-    for (let x = 0; x < value.length; x++) {
-      for (let y = x + 1; y < value.length; y++) {
-        const itemA = value[x]
-        const itemB = value[y]
-
-        if (!deepEquals(itemA, itemB)) {
-          continue
-        }
-
-        if (dupeIndices.indexOf(x) === -1) {
-          dupeIndices.push(x)
-        }
-
-        if (dupeIndices.indexOf(y) === -1) {
-          dupeIndices.push(y)
-        }
-      }
-    }
-
-    const paths = dupeIndices.map((idx) => {
-      const item = value[idx]
-      const pathSegment = item && item._key ? {_key: item._key} : idx
-      return [pathSegment]
-    })
-
-    return dupeIndices.length > 0
-      ? new ValidationErrorClass(message || `Can't be a duplicate`, {paths})
-      : true
-  },
-}
-
-export default arrayValidators

package/src/validators/booleanValidator.ts

@@ -1,16 +0,0 @@
-import {Validators} from '@sanity/types'
-import genericValidator from './genericValidator'
-
-const booleanValidators: Validators = {
-  ...genericValidator,
-
-  presence: (flag, value, message) => {
-    if (flag === 'required' && typeof value !== 'boolean') {
-      return message || 'Required'
-    }
-
-    return true
-  },
-}
-
-export default booleanValidators

package/src/validators/dateValidator.ts

@@ -1,113 +0,0 @@
-import {Validators} from '@sanity/types'
-import formatDate from 'date-fns/format'
-import genericValidator from './genericValidator'
-
-export function isRecord(obj: unknown): obj is Record<string, unknown> {
-  return typeof obj === 'object' && obj !== null && !Array.isArray(obj)
-}
-
-const isoDate =
-  /^(?:[-+]\d{2})?(?:\d{4}(?!\d{2}\b))(?:(-?)(?:(?:0[1-9]|1[0-2])(?:\1(?:[12]\d|0[1-9]|3[01]))?|W(?:[0-4]\d|5[0-2])(?:-?[1-7])?|(?:00[1-9]|0[1-9]\d|[12]\d{2}|3(?:[0-5]\d|6[1-6])))(?![T]$|[T][\d]+Z$)(?:[T\s](?:(?:(?:[01]\d|2[0-3])(?:(:?)[0-5]\d)?|24:?00)(?:[.,]\d+(?!:))?)(?:\2[0-5]\d(?:[.,]\d+)?)?(?:[Z]|(?:[+-])(?:[01]\d|2[0-3])(?::?[0-5]\d)?)?)?)?$/
-
-// eslint-disable-next-line no-warning-comments
-// TODO (eventually): move these to schema type package
-interface DateTimeOptions {
-  dateFormat?: string
-  timeFormat?: string
-}
-
-const getFormattedDate = (type = '', value: string | number | Date, options?: DateTimeOptions) => {
-  let format = 'yyyy-MM-dd'
-  if (options && options.dateFormat) {
-    format = options.dateFormat
-  }
-
-  if (type === 'date') {
-    // If the type is date only
-    return formatDate(new Date(value), format)
-  }
-
-  // If the type is datetime
-  if (options && options.timeFormat) {
-    format += ` ${options.timeFormat}`
-  } else {
-    format += ' HH:mm'
-  }
-
-  return formatDate(new Date(value), format)
-}
-
-function parseDate(date: unknown): Date | null
-function parseDate(date: unknown, throwOnError: true): Date
-function parseDate(date: unknown, throwOnError = false): Date | null {
-  if (!date) return null
-  if (date === 'now') return new Date()
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const parsed = new Date(date as any)
-  const isInvalid = isNaN(parsed.getTime())
-  if (isInvalid && throwOnError) {
-    throw new Error(`Unable to parse "${date}" to a date`)
-  }
-
-  return isInvalid ? null : parsed
-}
-
-const dateValidators: Validators = {
-  ...genericValidator,
-
-  type: (_unused, value, message) => {
-    const strVal = `${value}`
-    if (!strVal || isoDate.test(value)) {
-      return true
-    }
-
-    return message || 'Must be a valid ISO-8601 formatted date string'
-  },
-
-  min: (minDate, value, message, context) => {
-    const dateVal = parseDate(value)
-    if (!dateVal) {
-      return true // `type()` should catch parse errors
-    }
-
-    if (!value || dateVal >= parseDate(minDate, true)) {
-      return true
-    }
-    if (!context.type) {
-      throw new Error(`\`type\` was not provided in validation context.`)
-    }
-
-    const dateTimeOptions: DateTimeOptions = isRecord(context.type.options)
-      ? (context.type.options as DateTimeOptions)
-      : {}
-
-    const date = getFormattedDate(context.type.name, minDate, dateTimeOptions)
-
-    return message || `Must be at or after ${date}`
-  },
-
-  max: (maxDate, value, message, context) => {
-    const dateVal = parseDate(value)
-    if (!dateVal) {
-      return true // `type()` should catch parse errors
-    }
-
-    if (!value || dateVal <= parseDate(maxDate, true)) {
-      return true
-    }
-
-    if (!context.type) {
-      throw new Error(`\`type\` was not provided in validation context.`)
-    }
-
-    const dateTimeOptions: DateTimeOptions = isRecord(context.type.options)
-      ? (context.type.options as DateTimeOptions)
-      : {}
-
-    const date = getFormattedDate(context.type.name, maxDate, dateTimeOptions)
-    return message || `Must be at or before ${date}`
-  },
-}
-
-export default dateValidators

package/src/validators/genericValidator.ts

@@ -1,117 +0,0 @@
-import {ValidationMarker, Validators} from '@sanity/types'
-import typeString from '../util/typeString'
-import deepEquals from '../util/deepEquals'
-import pathToString from '../util/pathToString'
-import ValidationErrorClass from '../ValidationError'
-
-const SLOW_VALIDATOR_TIMEOUT = 5000
-
-const formatValidationErrors = (options: {
-  message: string | undefined
-  results: ValidationMarker[]
-  operation: 'AND' | 'OR'
-}) => {
-  let message
-
-  if (options.message) {
-    message = options.message
-  } else if (options.results.length === 1) {
-    message = options.results[0]?.item.message
-  } else {
-    message = `[${options.results
-      .map((err) => err.item.message)
-      .join(` - ${options.operation} - `)}]`
-  }
-
-  return new ValidationErrorClass(message, {
-    children: options.results.length > 1 ? options.results : undefined,
-    operation: options.operation,
-  })
-}
-
-const genericValidators: Validators = {
-  type: (expected, value, message) => {
-    const actualType = typeString(value)
-    if (actualType !== expected && actualType !== 'undefined') {
-      return message || `Expected type "${expected}", got "${actualType}"`
-    }
-
-    return true
-  },
-
-  presence: (expected, value, message) => {
-    if (value === undefined && expected === 'required') {
-      return message || 'Value is required'
-    }
-
-    return true
-  },
-
-  all: async (children, value, message, context) => {
-    const resolved = await Promise.all(children.map((child) => child.validate(value, context)))
-    const results = resolved.flat()
-
-    if (!results.length) return true
-
-    return formatValidationErrors({
-      message,
-      results,
-      operation: 'AND',
-    })
-  },
-
-  either: async (children, value, message, context) => {
-    const resolved = await Promise.all(children.map((child) => child.validate(value, context)))
-    const results = resolved.flat()
-
-    // Read: There is at least one rule that matched
-    if (results.length < children.length) return true
-
-    return formatValidationErrors({
-      message,
-      results,
-      operation: 'OR',
-    })
-  },
-
-  valid: (allowedValues, actual, message) => {
-    const valueType = typeof actual
-    if (valueType === 'undefined') {
-      return true
-    }
-
-    const value = (valueType === 'number' || valueType === 'string') && `${actual}`
-    const strValue = value && value.length > 30 ? `${value.slice(0, 30)}…` : value
-
-    const defaultMessage = value
-      ? `Value "${strValue}" did not match any allowed values`
-      : 'Value did not match any allowed values'
-
-    return allowedValues.some((expected) => deepEquals(expected, actual))
-      ? true
-      : message || defaultMessage
-  },
-
-  custom: async (fn, value, message, context) => {
-    const slowTimer = setTimeout(() => {
-      // eslint-disable-next-line no-console
-      console.warn(
-        `Custom validator at ${pathToString(
-          context.path
-        )} has taken more than ${SLOW_VALIDATOR_TIMEOUT}ms to respond`
-      )
-    }, SLOW_VALIDATOR_TIMEOUT)
-
-    let result
-    try {
-      result = await fn(value, context)
-    } finally {
-      clearTimeout(slowTimer)
-    }
-
-    if (typeof result === 'string') return message || result
-    return result
-  },
-}
-
-export default genericValidators

package/src/validators/numberValidator.ts

@@ -1,66 +0,0 @@
-import {Validators} from '@sanity/types'
-import genericValidator from './genericValidator'
-
-const precisionRx = /(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/
-
-const numberValidators: Validators = {
-  ...genericValidator,
-
-  integer: (_unused, value, message) => {
-    if (!Number.isInteger(value)) {
-      return message || 'Must be an integer'
-    }
-
-    return true
-  },
-
-  precision: (limit, value, message) => {
-    if (value === undefined) return true
-
-    const places = value.toString().match(precisionRx)
-    const decimals = Math.max(
-      (places[1] ? places[1].length : 0) - (places[2] ? parseInt(places[2], 10) : 0),
-      0
-    )
-
-    if (decimals > limit) {
-      return message || `Max precision is ${limit}`
-    }
-
-    return true
-  },
-
-  min: (minNum, value, message) => {
-    if (value >= minNum) {
-      return true
-    }
-
-    return message || `Must be greater than or equal ${minNum}`
-  },
-
-  max: (maxNum, value, message) => {
-    if (value <= maxNum) {
-      return true
-    }
-
-    return message || `Must be less than or equal ${maxNum}`
-  },
-
-  greaterThan: (num, value, message) => {
-    if (value > num) {
-      return true
-    }
-
-    return message || `Must be greater than ${num}`
-  },
-
-  lessThan: (maxNum, value, message) => {
-    if (value < maxNum) {
-      return true
-    }
-
-    return message || `Must be less than ${maxNum}`
-  },
-}
-
-export default numberValidators