@sanity/validation 3.14.4 → 6.12.0-next.112

package/src/Rule.ts

@@ -1,424 +0,0 @@
-import {
-  SchemaType,
-  Rule as IRule,
-  RuleClass,
-  CustomValidator,
-  RuleSpecConstraint,
-  FieldRules,
-  ValidationContext,
-  RuleSpec,
-  ValidationMarker,
-  RuleTypeConstraint,
-  Validator,
-} from '@sanity/types'
-import {cloneDeep, get} from 'lodash'
-import ValidationErrorClass from './ValidationError'
-import escapeRegex from './util/escapeRegex'
-import {convertToValidationMarker} from './util/convertToValidationMarker'
-import pathToString from './util/pathToString'
-import genericValidator from './validators/genericValidator'
-import booleanValidator from './validators/booleanValidator'
-import numberValidator from './validators/numberValidator'
-import stringValidator from './validators/stringValidator'
-import arrayValidator from './validators/arrayValidator'
-import objectValidator from './validators/objectValidator'
-import dateValidator from './validators/dateValidator'
-
-const typeValidators = {
-  Boolean: booleanValidator,
-  Number: numberValidator,
-  String: stringValidator,
-  Array: arrayValidator,
-  Object: objectValidator,
-  Date: dateValidator,
-}
-
-const getBaseType = (type: SchemaType | undefined): SchemaType | undefined => {
-  return type && type.type ? getBaseType(type.type) : type
-}
-
-const isFieldRef = (constraint: unknown): constraint is {type: symbol; path: string | string[]} => {
-  if (typeof constraint !== 'object' || !constraint) return false
-  return (constraint as Record<string, unknown>).type === Rule.FIELD_REF
-}
-
-const EMPTY_ARRAY: unknown[] = []
-const FIELD_REF = Symbol('FIELD_REF')
-const ruleConstraintTypes: RuleTypeConstraint[] = [
-  'Array',
-  'Boolean',
-  'Date',
-  'Number',
-  'Object',
-  'String',
-]
-
-// Note: `RuleClass` and `Rule` are split to fit the current `@sanity/types`
-// setup. Classes are a bit weird in the `@sanity/types` package because classes
-// create an actual javascript class while simultaneously creating a type
-// definition.
-//
-// This implicitly creates two types:
-// 1. the instance type — `Rule` and
-// 2. the static/class type - `RuleClass`
-//
-// The `RuleClass` type contains the static methods and the `Rule` instance
-// contains the instance methods.
-//
-// This package exports the RuleClass as a value without implicitly exporting
-// an instance definition. This should help reminder downstream users to import
-// from the `@sanity/types` package.
-const Rule: RuleClass = class Rule implements IRule {
-  static readonly FIELD_REF = FIELD_REF
-  static array = (def?: SchemaType): Rule => new Rule(def).type('Array')
-  static object = (def?: SchemaType): Rule => new Rule(def).type('Object')
-  static string = (def?: SchemaType): Rule => new Rule(def).type('String')
-  static number = (def?: SchemaType): Rule => new Rule(def).type('Number')
-  static boolean = (def?: SchemaType): Rule => new Rule(def).type('Boolean')
-  static dateTime = (def?: SchemaType): Rule => new Rule(def).type('Date')
-  static valueOfField = (path: string | string[]): {type: symbol; path: string | string[]} => ({
-    type: FIELD_REF,
-    path,
-  })
-
-  _type: RuleTypeConstraint | undefined = undefined
-  _level: 'error' | 'warning' | 'info' | undefined = undefined
-  _required: 'required' | 'optional' | undefined = undefined
-  _typeDef: SchemaType | undefined = undefined
-  _message: string | undefined = undefined
-  _rules: RuleSpec[] = []
-  _fieldRules: FieldRules | undefined = undefined
-
-  constructor(typeDef?: SchemaType) {
-    this._typeDef = typeDef
-    this.reset()
-  }
-
-  private _mergeRequired(next: Rule) {
-    if (this._required === 'required' || next._required === 'required') return 'required'
-    if (this._required === 'optional' || next._required === 'optional') return 'optional'
-    return undefined
-  }
-
-  // Alias to static method, since we often have access to an _instance_ of a rule but not the actual Rule class
-  valueOfField = Rule.valueOfField.bind(Rule)
-
-  error(message?: string): Rule {
-    const rule = this.clone()
-    rule._level = 'error'
-    rule._message = message || undefined
-    return rule
-  }
-
-  warning(message?: string): Rule {
-    const rule = this.clone()
-    rule._level = 'warning'
-    rule._message = message || undefined
-    return rule
-  }
-
-  info(message?: string): Rule {
-    const rule = this.clone()
-    rule._level = 'info'
-    rule._message = message || undefined
-    return rule
-  }
-
-  reset(): this {
-    this._type = this._type || undefined
-    this._rules = (this._rules || []).filter((rule) => rule.flag === 'type')
-    this._message = undefined
-    this._required = undefined
-    this._level = 'error'
-    this._fieldRules = undefined
-    return this
-  }
-
-  isRequired(): boolean {
-    return this._required === 'required'
-  }
-
-  clone(): Rule {
-    const rule = new Rule()
-    rule._type = this._type
-    rule._message = this._message
-    rule._required = this._required
-    rule._rules = cloneDeep(this._rules)
-    rule._level = this._level
-    rule._fieldRules = this._fieldRules
-    rule._typeDef = this._typeDef
-    return rule
-  }
-
-  cloneWithRules(rules: RuleSpec[]): Rule {
-    const rule = this.clone()
-    const newRules = new Set()
-    rules.forEach((curr) => {
-      if (curr.flag === 'type') {
-        rule._type = curr.constraint
-      }
-
-      newRules.add(curr.flag)
-    })
-
-    rule._rules = rule._rules
-      .filter((curr) => {
-        const disallowDuplicate = ['type', 'uri', 'email'].includes(curr.flag)
-        const isDuplicate = newRules.has(curr.flag)
-        return !(disallowDuplicate && isDuplicate)
-      })
-      .concat(rules)
-
-    return rule
-  }
-
-  merge(rule: Rule): Rule {
-    if (this._type && rule._type && this._type !== rule._type) {
-      throw new Error('merge() failed: conflicting types')
-    }
-
-    const newRule = this.cloneWithRules(rule._rules)
-    newRule._type = this._type || rule._type
-    newRule._message = this._message || rule._message
-    newRule._required = this._mergeRequired(rule)
-    newRule._level = this._level === 'error' ? rule._level : this._level
-    return newRule
-  }
-
-  // Validation flag setters
-  type(targetType: RuleTypeConstraint | Lowercase<RuleTypeConstraint>): Rule {
-    const type = `${targetType.slice(0, 1).toUpperCase()}${targetType.slice(1)}` as Capitalize<
-      typeof targetType
-    >
-
-    if (!ruleConstraintTypes.includes(type)) {
-      throw new Error(`Unknown type "${targetType}"`)
-    }
-
-    const rule = this.cloneWithRules([{flag: 'type', constraint: type}])
-    rule._type = type
-    return rule
-  }
-
-  all(children: Rule[]): Rule {
-    return this.cloneWithRules([{flag: 'all', constraint: children}])
-  }
-
-  either(children: Rule[]): Rule {
-    return this.cloneWithRules([{flag: 'either', constraint: children}])
-  }
-
-  // Shared rules
-  optional(): Rule {
-    const rule = this.cloneWithRules([{flag: 'presence', constraint: 'optional'}])
-    rule._required = 'optional'
-    return rule
-  }
-
-  required(): Rule {
-    const rule = this.cloneWithRules([{flag: 'presence', constraint: 'required'}])
-    rule._required = 'required'
-    return rule
-  }
-
-  custom<T = unknown>(fn: CustomValidator<T>): Rule {
-    return this.cloneWithRules([{flag: 'custom', constraint: fn as CustomValidator}])
-  }
-
-  min(len: number): Rule {
-    return this.cloneWithRules([{flag: 'min', constraint: len}])
-  }
-
-  max(len: number): Rule {
-    return this.cloneWithRules([{flag: 'max', constraint: len}])
-  }
-
-  length(len: number): Rule {
-    return this.cloneWithRules([{flag: 'length', constraint: len}])
-  }
-
-  valid(value: unknown | unknown[]): Rule {
-    const values = Array.isArray(value) ? value : [value]
-    return this.cloneWithRules([{flag: 'valid', constraint: values}])
-  }
-
-  // Numbers only
-  integer(): Rule {
-    return this.cloneWithRules([{flag: 'integer'}])
-  }
-
-  precision(limit: number): Rule {
-    return this.cloneWithRules([{flag: 'precision', constraint: limit}])
-  }
-
-  positive(): Rule {
-    return this.cloneWithRules([{flag: 'min', constraint: 0}])
-  }
-
-  negative(): Rule {
-    return this.cloneWithRules([{flag: 'lessThan', constraint: 0}])
-  }
-
-  greaterThan(num: number): Rule {
-    return this.cloneWithRules([{flag: 'greaterThan', constraint: num}])
-  }
-
-  lessThan(num: number): Rule {
-    return this.cloneWithRules([{flag: 'lessThan', constraint: num}])
-  }
-
-  // String only
-  uppercase(): Rule {
-    return this.cloneWithRules([{flag: 'stringCasing', constraint: 'uppercase'}])
-  }
-
-  lowercase(): Rule {
-    return this.cloneWithRules([{flag: 'stringCasing', constraint: 'lowercase'}])
-  }
-
-  regex(pattern: RegExp, name: string, options: {name?: string; invert?: boolean}): Rule
-  regex(pattern: RegExp, options: {name?: string; invert?: boolean}): Rule
-  regex(pattern: RegExp, name: string): Rule
-  regex(pattern: RegExp): Rule
-  regex(
-    pattern: RegExp,
-    a?: string | {name?: string; invert?: boolean},
-    b?: {name?: string; invert?: boolean}
-  ): Rule {
-    const name = typeof a === 'string' ? a : a?.name ?? b?.name
-    const invert = typeof a === 'string' ? false : a?.invert ?? b?.invert
-
-    const constraint: RuleSpecConstraint<'regex'> = {
-      pattern,
-      name,
-      invert: invert || false,
-    }
-
-    return this.cloneWithRules([{flag: 'regex', constraint}])
-  }
-
-  email(): Rule {
-    return this.cloneWithRules([{flag: 'email'}])
-  }
-
-  uri(opts?: {
-    scheme?: (string | RegExp) | Array<string | RegExp>
-    allowRelative?: boolean
-    relativeOnly?: boolean
-    allowCredentials?: boolean
-  }): Rule {
-    const optsScheme = opts?.scheme || ['http', 'https']
-    const schemes = Array.isArray(optsScheme) ? optsScheme : [optsScheme]
-
-    if (!schemes.length) {
-      throw new Error('scheme must have at least 1 scheme specified')
-    }
-
-    const constraint: RuleSpecConstraint<'uri'> = {
-      options: {
-        scheme: schemes.map((scheme) => {
-          if (!(scheme instanceof RegExp) && typeof scheme !== 'string') {
-            throw new Error('scheme must be a RegExp or a String')
-          }
-
-          return typeof scheme === 'string' ? new RegExp(`^${escapeRegex(scheme)}$`) : scheme
-        }),
-        allowRelative: opts?.allowRelative || false,
-        relativeOnly: opts?.relativeOnly || false,
-        allowCredentials: opts?.allowCredentials || false,
-      },
-    }
-
-    return this.cloneWithRules([{flag: 'uri', constraint}])
-  }
-
-  // Array only
-  unique(): Rule {
-    return this.cloneWithRules([{flag: 'unique'}])
-  }
-
-  // Objects only
-  reference(): Rule {
-    return this.cloneWithRules([{flag: 'reference'}])
-  }
-
-  fields(rules: FieldRules): Rule {
-    if (this._type !== 'Object') {
-      throw new Error('fields() can only be called on an object type')
-    }
-
-    const rule = this.cloneWithRules([])
-    rule._fieldRules = rules
-    return rule
-  }
-
-  assetRequired(): Rule {
-    const base = getBaseType(this._typeDef)
-    let assetType: 'Asset' | 'Image' | 'File'
-    if (base && ['image', 'file'].includes(base.name)) {
-      assetType = base.name === 'image' ? 'Image' : 'File'
-    } else {
-      assetType = 'Asset'
-    }
-
-    return this.cloneWithRules([{flag: 'assetRequired', constraint: {assetType}}])
-  }
-
-  async validate(value: unknown, context: ValidationContext): Promise<ValidationMarker[]> {
-    if (!context) {
-      throw new Error('missing context')
-    }
-
-    const valueIsEmpty = value === null || value === undefined
-
-    // Short-circuit on optional, empty fields
-    if (valueIsEmpty && this._required === 'optional') {
-      return EMPTY_ARRAY as ValidationMarker[]
-    }
-
-    const rules =
-      // Run only the _custom_ functions if the rule is not set to required or optional
-      this._required === undefined && valueIsEmpty
-        ? this._rules.filter((curr) => curr.flag === 'custom')
-        : this._rules
-
-    const validators = (this._type && typeValidators[this._type]) || genericValidator
-
-    const results = await Promise.all(
-      rules.map(async (curr) => {
-        if (curr.flag === undefined) {
-          throw new Error('Invalid rule, did not contain "flag"-property')
-        }
-
-        const validator: Validator | undefined = validators[curr.flag]
-        if (!validator) {
-          const forType = this._type ? `type "${this._type}"` : 'rule without declared type'
-          throw new Error(`Validator for flag "${curr.flag}" not found for ${forType}`)
-        }
-
-        let specConstraint = 'constraint' in curr ? curr.constraint : null
-        if (isFieldRef(specConstraint)) {
-          specConstraint = get(context.parent, specConstraint.path)
-        }
-
-        let result
-        try {
-          result = await validator(specConstraint, value, this._message, context)
-        } catch (err) {
-          const errorFromException = new ValidationErrorClass(
-            `${pathToString(context.path)}: Exception occurred while validating value: ${
-              err.message
-            }`
-          )
-          return convertToValidationMarker(errorFromException, 'error', context)
-        }
-
-        return convertToValidationMarker(result, this._level, context)
-      })
-    )
-
-    return results.flat()
-  }
-}
-
-export default Rule

package/src/ValidationError.ts

@@ -1,32 +0,0 @@
-import {
-  Path,
-  ValidationMarker,
-  ValidationError as IValidationError,
-  ValidationErrorOptions,
-  ValidationErrorClass,
-} from '@sanity/types'
-
-// Follows the same pattern as Rule and RuleClass. @see Rule
-const ValidationError: ValidationErrorClass = class ValidationError implements IValidationError {
-  message: string
-  paths: Path[]
-  children: ValidationMarker[] | undefined
-  operation: 'AND' | 'OR' | undefined
-
-  constructor(message: string, options: ValidationErrorOptions = {}) {
-    this.message = message
-    this.paths = options.paths || []
-    this.children = options.children
-    this.operation = options.operation
-  }
-
-  cloneWithMessage(msg: string): ValidationError {
-    return new ValidationError(msg, {
-      paths: this.paths,
-      children: this.children,
-      operation: this.operation,
-    })
-  }
-}
-
-export default ValidationError

package/src/index.ts

@@ -1,9 +0,0 @@
-import RuleClass from './Rule'
-import validateDocument from './validateDocument'
-import inferFromSchema from './inferFromSchema'
-import inferFromSchemaType from './inferFromSchemaType'
-
-// export default {Rule: RuleClass, validateDocument, inferFromSchema, inferFromSchemaType}
-export {RuleClass as Rule, validateDocument, inferFromSchema, inferFromSchemaType}
-
-export {validateDocumentObservable} from './validateDocument'

package/src/inferFromSchema.ts

@@ -1,19 +0,0 @@
-import {Schema} from '@sanity/types'
-import inferFromSchemaType from './inferFromSchemaType'
-
-// Note: Mutates schema. Refactor when @sanity/schema supports middlewares
-function inferFromSchema(schema: Schema): Schema {
-  const typeNames = schema.getTypeNames()
-
-  typeNames.forEach((typeName) => {
-    const schemaType = schema.get(typeName)
-
-    if (schemaType) {
-      inferFromSchemaType(schemaType)
-    }
-  })
-
-  return schema
-}
-
-export default inferFromSchema

package/src/inferFromSchemaType.ts

@@ -1,50 +0,0 @@
-import {Schema, SchemaType} from '@sanity/types'
-import normalizeValidationRules from './util/normalizeValidationRules'
-
-function traverse(typeDef: SchemaType, visited: Set<SchemaType>) {
-  if (visited.has(typeDef)) {
-    return
-  }
-
-  visited.add(typeDef)
-
-  typeDef.validation = normalizeValidationRules(typeDef)
-
-  if ('fields' in typeDef) {
-    for (const field of typeDef.fields) {
-      traverse(field.type, visited)
-    }
-  }
-
-  if ('of' in typeDef) {
-    for (const candidate of typeDef.of) {
-      traverse(candidate, visited)
-    }
-  }
-
-  // eslint-disable-next-line no-warning-comments
-  // @ts-expect-error TODO (eventually): `annotations` does not exist on the SchemaType yet
-  if (typeDef.annotations) {
-    // eslint-disable-next-line no-warning-comments
-    // @ts-expect-error TODO (eventually): `annotations` does not exist on the SchemaType yet
-    for (const annotation of typeDef.annotations) {
-      traverse(annotation, visited)
-    }
-  }
-}
-
-// NOTE: this overload is for TS API compatibility with a previous implementation
-function inferFromSchemaType(
-  typeDef: SchemaType,
-  // these are intentionally unused
-  _schema: Schema,
-  _visited?: Set<SchemaType>
-): SchemaType
-// note: this seemingly redundant overload is required
-function inferFromSchemaType(typeDef: SchemaType): SchemaType
-function inferFromSchemaType(typeDef: SchemaType): SchemaType {
-  traverse(typeDef, new Set())
-  return typeDef
-}
-
-export default inferFromSchemaType

package/src/util/convertToValidationMarker.ts

@@ -1,84 +0,0 @@
-import {ValidationMarker, ValidationError, ValidationContext} from '@sanity/types'
-import ValidationErrorClass from '../ValidationError'
-import pathToString from '../util/pathToString'
-
-type ValidationErrorLike = Pick<ValidationError, 'message'> & Partial<ValidationError>
-
-export function isNonNullable<T>(t: T): t is NonNullable<T> {
-  return t !== null || t !== undefined
-}
-
-export function convertToValidationMarker(
-  validatorResult:
-    | true
-    | true[]
-    | string
-    | string[]
-    | ValidationError
-    | ValidationError[]
-    | ValidationErrorLike
-    | ValidationErrorLike[],
-  level: 'error' | 'warning' | 'info' | undefined,
-  context: ValidationContext
-): ValidationMarker[] {
-  if (!context) {
-    throw new Error('missing context')
-  }
-
-  if (validatorResult === true) return []
-
-  if (Array.isArray(validatorResult)) {
-    return validatorResult
-      .flatMap((child) => convertToValidationMarker(child, level, context))
-      .filter(isNonNullable)
-  }
-
-  if (typeof validatorResult === 'string') {
-    return convertToValidationMarker(new ValidationErrorClass(validatorResult), level, context)
-  }
-
-  if (!(validatorResult instanceof ValidationErrorClass)) {
-    // in order to accept the `ValidationErrorLike`, it at least needs to have
-    // a `message` in the object
-    if (typeof validatorResult?.message !== 'string') {
-      throw new Error(
-        `${pathToString(
-          context.path
-        )}: Validator must return 'true' if valid or an error message as a string on errors`
-      )
-    }
-
-    // this is the occurs when an object is returned that wasn't created with the
-    // `ValidationErrorClass`. in this case, we want to convert it to a class
-    return convertToValidationMarker(
-      new ValidationErrorClass(validatorResult.message, validatorResult),
-      level,
-      context
-    )
-  }
-
-  const results: ValidationMarker[] = []
-
-  // the validator result does not include any item-level relative paths,
-  // then just return the top-level path with the validation result
-  if (!validatorResult.paths?.length) {
-    return [
-      {
-        level: level || 'error',
-        item: validatorResult,
-        path: context.path || [],
-      },
-    ]
-  }
-
-  // if the validator result did include item-level relative paths, then for
-  // each item-level relative path, create a validation marker that concatenates
-  // the relative path with the path from the validation context
-  return results.concat(
-    validatorResult.paths.map((path) => ({
-      path: (context.path || []).concat(path),
-      level: level || 'error',
-      item: validatorResult,
-    }))
-  )
-}

package/src/util/deepEquals.ts

@@ -1,77 +0,0 @@
-/**
- * Modified version of fast-deep-equal (https://github.com/epoberezkin/fast-deep-equal)
- * MIT-licensed, copyright (c) 2017 Evgeny Poberezkin
- **/
-
-// NOTE: when converting to typescript, some of the checks were inlined (vs
-// having them in a variable) because the type predicate type narrowing only
-// works when type predicate is called inline in the condition that starts the
-// control flow branch.
-// see here: https://www.typescriptlang.org/docs/handbook/2/narrowing.html
-export default function deepEquals(a: unknown, b: unknown): boolean {
-  if (a === b) {
-    return true
-  }
-
-  if (Array.isArray(a) && Array.isArray(b)) {
-    if (a.length != b.length) return false
-    for (let i = 0; i < a.length; i++) {
-      if (!deepEquals(a[i], b[i])) {
-        return false
-      }
-    }
-    return true
-  }
-
-  if (Array.isArray(a) != Array.isArray(b)) {
-    return false
-  }
-
-  if (a && b && typeof a === 'object' && typeof b === 'object') {
-    const keys = Object.keys(a)
-    if (keys.length !== Object.keys(b).length) {
-      return false
-    }
-
-    if (a instanceof Date && b instanceof Date) {
-      return a.getTime() === b.getTime()
-    }
-
-    if (a instanceof Date != b instanceof Date) {
-      return false
-    }
-
-    if (a instanceof RegExp && b instanceof RegExp) {
-      return a.toString() == b.toString()
-    }
-
-    if (a instanceof RegExp != b instanceof RegExp) {
-      return false
-    }
-
-    for (let i = 0; i < keys.length; i++) {
-      if (keys[i] === '_key') {
-        continue
-      }
-
-      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) {
-        return false
-      }
-    }
-
-    for (let i = 0; i < keys.length; i++) {
-      const key = keys[i] as keyof typeof a
-      if (key === '_key') {
-        continue
-      }
-
-      if (!deepEquals(a[key], b[key])) {
-        return false
-      }
-    }
-
-    return true
-  }
-
-  return false
-}

package/src/util/escapeRegex.ts

@@ -1,5 +0,0 @@
-/* eslint-disable no-useless-escape */
-export default (string: string): string => {
-  // Escape ^$.*+-?=!:|\/()[]{},
-  return string.replace(/[\^\$\.\*\+\-\?\=\!\:\|\\\/\(\)\[\]\{\}\,]/g, '\\$&')
-}