@sanity/validation 3.14.4 → 6.12.0-next.46

package/src/validators/objectValidator.ts

@@ -1,64 +0,0 @@
-import {Validators, isReference} from '@sanity/types'
-import genericValidator from './genericValidator'
-
-const metaKeys = ['_key', '_type', '_weak']
-
-const objectValidators: Validators = {
-  ...genericValidator,
-
-  presence: (expected, value, message) => {
-    if (expected !== 'required') {
-      return true
-    }
-
-    const keys = value && Object.keys(value).filter((key) => !metaKeys.includes(key))
-
-    if (value === undefined || (keys && keys.length === 0)) {
-      return message || 'Required'
-    }
-
-    return true
-  },
-
-  reference: async (_unused, value: unknown, message, context) => {
-    if (!value) {
-      return true
-    }
-
-    if (!isReference(value)) {
-      return message || 'Must be a reference to a document'
-    }
-
-    const {type, getDocumentExists} = context
-
-    if (!type) {
-      throw new Error(`\`type\` was not provided in validation context`)
-    }
-
-    if ('weak' in type && type.weak) {
-      return true
-    }
-
-    if (!getDocumentExists) {
-      throw new Error(`\`getDocumentExists\` was not provided in validation context`)
-    }
-
-    const exists = await getDocumentExists({id: value._ref})
-    if (!exists) {
-      return 'This reference must be published'
-    }
-
-    return true
-  },
-
-  assetRequired: (flag, value, message) => {
-    if (!value || !value.asset || !value.asset._ref) {
-      const assetType = flag.assetType || 'Asset'
-      return message || `${assetType} required`
-    }
-
-    return true
-  },
-}
-
-export default objectValidators

package/src/validators/slugValidator.ts

@@ -1,117 +0,0 @@
-import {
-  SlugIsUniqueValidator,
-  Path,
-  CustomValidator,
-  isKeyedObject,
-  SlugValidationContext,
-  SlugParent,
-  SlugSchemaType,
-} from '@sanity/types'
-import {memoize} from 'lodash'
-// import getClient from '../getClient'
-
-const memoizedWarnOnArraySlug = memoize(warnOnArraySlug)
-
-function getDocumentIds(id: string) {
-  const isDraft = id.indexOf('drafts.') === 0
-  return {
-    published: isDraft ? id.slice('drafts.'.length) : id,
-    draft: isDraft ? id : `drafts.${id}`,
-  }
-}
-
-function serializePath(path: Path): string {
-  return path.reduce<string>((target, part, i) => {
-    const isIndex = typeof part === 'number'
-    const isKey = isKeyedObject(part)
-    const separator = i === 0 ? '' : '.'
-    const add = isIndex || isKey ? '[]' : `${separator}${part}`
-    return `${target}${add}`
-  }, '')
-}
-
-const defaultIsUnique: SlugIsUniqueValidator = (slug, context) => {
-  const {getClient, document, path, type} = context
-  const schemaOptions = type?.options as {disableArrayWarning?: boolean} | undefined
-
-  if (!document) {
-    throw new Error(`\`document\` was not provided in validation context.`)
-  }
-  if (!path) {
-    throw new Error(`\`path\` was not provided in validation context.`)
-  }
-
-  const disableArrayWarning = schemaOptions?.disableArrayWarning || false
-  const {published, draft} = getDocumentIds(document._id)
-  const docType = document._type
-  const atPath = serializePath(path.concat('current'))
-
-  if (!disableArrayWarning && atPath.includes('[]')) {
-    memoizedWarnOnArraySlug(serializePath(path))
-  }
-
-  const constraints = [
-    '_type == $docType',
-    `!(_id in [$draft, $published])`,
-    `${atPath} == $slug`,
-  ].join(' && ')
-
-  return getClient({apiVersion: '2022-09-09'}).fetch<boolean>(
-    `!defined(*[${constraints}][0]._id)`,
-    {
-      docType,
-      draft,
-      published,
-      slug,
-    },
-    {tag: 'validation.slug-is-unique'}
-  )
-}
-
-function warnOnArraySlug(serializedPath: string) {
-  /* eslint-disable no-console */
-  console.warn(
-    [
-      `Slug field at path ${serializedPath} is within an array and cannot be automatically checked for uniqueness`,
-      `If you need to check for uniqueness, provide your own "isUnique" method`,
-      `To disable this message, set \`disableArrayWarning: true\` on the slug \`options\` field`,
-    ].join('\n')
-  )
-  /* eslint-enable no-console */
-}
-
-/**
- * Validates slugs values by querying for uniqueness from the client.
- *
- * This is a custom rule implementation (e.g. `Rule.custom(slugValidator)`)
- * that's populated in `inferFromSchemaType` when the type name is `slug`
- */
-export const slugValidator: CustomValidator = async (value, context) => {
-  if (!value) {
-    return true
-  }
-  if (typeof value !== 'object') {
-    return 'Slug must be an object'
-  }
-
-  const slugValue = (value as {current?: string}).current
-  if (!slugValue) {
-    return 'Slug must have a value'
-  }
-
-  const options = context?.type?.options as {isUnique?: SlugIsUniqueValidator} | undefined
-  const isUnique = options?.isUnique || defaultIsUnique
-
-  const slugContext: SlugValidationContext = {
-    ...context,
-    parent: context.parent as SlugParent,
-    type: context.type as SlugSchemaType,
-    defaultIsUnique,
-  }
-  const wasUnique = await isUnique(slugValue, slugContext)
-  if (wasUnique) {
-    return true
-  }
-
-  return 'Slug is already in use'
-}

package/src/validators/stringValidator.ts

@@ -1,120 +0,0 @@
-import {Validators} from '@sanity/types'
-import genericValidator from './genericValidator'
-
-const DUMMY_ORIGIN = 'http://sanity'
-const emailRegex =
-  /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/
-const isRelativeUrl = (url: string) => /^\.*\//.test(url)
-
-const stringValidators: Validators = {
-  ...genericValidator,
-
-  min: (minLength, value, message) => {
-    if (!value || value.length >= minLength) {
-      return true
-    }
-
-    return message || `Must be at least ${minLength} characters long`
-  },
-
-  max: (maxLength, value, message) => {
-    if (!value || value.length <= maxLength) {
-      return true
-    }
-
-    return message || `Must be at most ${maxLength} characters long`
-  },
-
-  length: (wantedLength, value, message) => {
-    const strValue = value || ''
-    if (strValue.length === wantedLength) {
-      return true
-    }
-
-    return message || `Must be exactly ${wantedLength} characters long`
-  },
-
-  uri: (constraints, value, message) => {
-    const strValue = value || ''
-    const {options} = constraints
-    const {allowCredentials, relativeOnly} = options
-    const allowRelative = options.allowRelative || relativeOnly
-
-    let url
-    try {
-      // WARNING: Safari checks for a given `base` param by looking at the length of arguments passed
-      // to new URL(str, base), and will fail if invoked with new URL(strValue, undefined)
-      url = allowRelative ? new URL(strValue, DUMMY_ORIGIN) : new URL(strValue)
-    } catch (err) {
-      return message || 'Not a valid URL'
-    }
-
-    if (relativeOnly && url.origin !== DUMMY_ORIGIN) {
-      return message || 'Only relative URLs are allowed'
-    }
-
-    if (!allowRelative && url.origin === DUMMY_ORIGIN && isRelativeUrl(strValue)) {
-      return message || 'Relative URLs are not allowed'
-    }
-
-    if (!allowCredentials && (url.username || url.password)) {
-      return message || `Username/password not allowed`
-    }
-
-    const urlScheme = url.protocol.replace(/:$/, '')
-    const matchesAllowedScheme = options.scheme.some((scheme) => scheme.test(urlScheme))
-    if (!matchesAllowedScheme) {
-      return message || 'Does not match allowed protocols/schemes'
-    }
-
-    return true
-  },
-
-  stringCasing: (casing, value, message) => {
-    const strValue = value || ''
-    if (casing === 'uppercase' && strValue !== strValue.toLocaleUpperCase()) {
-      return message || `Must be all uppercase letters`
-    }
-
-    if (casing === 'lowercase' && strValue !== strValue.toLocaleLowerCase()) {
-      return message || `Must be all lowercase letters`
-    }
-
-    return true
-  },
-
-  presence: (flag, value, message) => {
-    if (flag === 'required' && !value) {
-      return message || 'Required'
-    }
-
-    return true
-  },
-
-  regex: (options, value, message) => {
-    const {pattern, name, invert} = options
-    const regName = name || `"${pattern.toString()}"`
-    const strValue = value || ''
-    const matches = pattern.test(strValue)
-    if ((!invert && !matches) || (invert && matches)) {
-      const defaultMessage = invert
-        ? `Should not match ${regName}-pattern`
-        : `Does not match ${regName}-pattern`
-
-      return message || defaultMessage
-    }
-
-    return true
-  },
-
-  email: (_unused, value, message) => {
-    const strValue = `${value || ''}`.trim()
-    if (!strValue || emailRegex.test(strValue)) {
-      return true
-    }
-
-    return message || 'Must be a valid email address'
-  },
-}
-
-export default stringValidators