@sanity/validation 2.30.1-purple-unicorn.964 → 3.0.0-dev-preview.0

package/lib/dts/src/validators/objectValidator.js

@@ -1,48 +1,48 @@
-import {isReference} from '@sanity/types'
-import genericValidator from './genericValidator'
-const metaKeys = ['_key', '_type', '_weak']
+import { isReference } from '@sanity/types';
+import genericValidator from './genericValidator';
+const metaKeys = ['_key', '_type', '_weak'];
 const objectValidators = {
-  ...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, message, context) => {
-    if (!value) {
-      return true
-    }
-    if (!isReference(value)) {
-      return message || true
-    }
-    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
-//# sourceMappingURL=objectValidator.js.map
+    ...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, message, context) => {
+        if (!value) {
+            return true;
+        }
+        if (!isReference(value)) {
+            return message || true;
+        }
+        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;
+//# sourceMappingURL=objectValidator.js.map

package/lib/dts/src/validators/slugValidator.js

@@ -1,65 +1,59 @@
-import {isKeyedObject} from '@sanity/types'
-import {memoize} from 'lodash'
+import { isKeyedObject } from '@sanity/types';
+import { memoize } from 'lodash';
 // import getClient from '../getClient'
-const memoizedWarnOnArraySlug = memoize(warnOnArraySlug)
+const memoizedWarnOnArraySlug = memoize(warnOnArraySlug);
 function getDocumentIds(id) {
-  const isDraft = id.indexOf('drafts.') === 0
-  return {
-    published: isDraft ? id.slice('drafts.'.length) : id,
-    draft: isDraft ? id : `drafts.${id}`,
-  }
+    const isDraft = id.indexOf('drafts.') === 0;
+    return {
+        published: isDraft ? id.slice('drafts.'.length) : id,
+        draft: isDraft ? id : `drafts.${id}`,
+    };
 }
 function serializePath(path) {
-  return path.reduce((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}`
-  }, '')
+    return path.reduce((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 = (slug, context) => {
-  const {client, document, path, type} = context
-  const schemaOptions = type?.options
-  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 client.fetch(
-    `!defined(*[${constraints}][0]._id)`,
-    {
-      docType,
-      draft,
-      published,
-      slug,
-    },
-    {tag: 'validation.slug-is-unique'}
-  )
-}
+    const { client, document, path, type } = context;
+    const schemaOptions = type?.options;
+    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 client.fetch(`!defined(*[${constraints}][0]._id)`, {
+        docType,
+        draft,
+        published,
+        slug,
+    }, { tag: 'validation.slug-is-unique' });
+};
 function warnOnArraySlug(serializedPath) {
-  /* 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 */
+    /* 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.
@@ -68,22 +62,22 @@ function warnOnArraySlug(serializedPath) {
  * that's populated in `inferFromSchemaType` when the type name is `slug`
  */
 export const slugValidator = async (value, context) => {
-  if (!value) {
-    return true
-  }
-  if (typeof value !== 'object') {
-    return 'Slug must be an object'
-  }
-  const slugValue = value.current
-  if (!slugValue) {
-    return 'Slug must have a value'
-  }
-  const options = context?.type?.options
-  const isUnique = options?.isUnique || defaultIsUnique
-  const wasUnique = await isUnique(slugValue, {...context, defaultIsUnique})
-  if (wasUnique) {
-    return true
-  }
-  return 'Slug is already in use'
-}
-//# sourceMappingURL=slugValidator.js.map
+    if (!value) {
+        return true;
+    }
+    if (typeof value !== 'object') {
+        return 'Slug must be an object';
+    }
+    const slugValue = value.current;
+    if (!slugValue) {
+        return 'Slug must have a value';
+    }
+    const options = context?.type?.options;
+    const isUnique = options?.isUnique || defaultIsUnique;
+    const wasUnique = await isUnique(slugValue, { ...context, defaultIsUnique });
+    if (wasUnique) {
+        return true;
+    }
+    return 'Slug is already in use';
+};
+//# sourceMappingURL=slugValidator.js.map

package/lib/dts/src/validators/stringValidator.js

@@ -1,94 +1,94 @@
-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) => /^\.*\//.test(url)
+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) => /^\.*\//.test(url);
 const stringValidators = {
-  ...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
-//# sourceMappingURL=stringValidator.js.map
+    ...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;
+//# sourceMappingURL=stringValidator.js.map

package/lib/dts/test/array.test.d.ts

@@ -1,2 +1,2 @@
-export {}
-//# sourceMappingURL=array.test.d.ts.map
+export {};
+//# sourceMappingURL=array.test.d.ts.map

package/lib/dts/test/array.test.js

@@ -1,79 +1,55 @@
-import {Rule} from '../src'
-const context = {client: {}}
+import { Rule } from '../src';
+const context = { client: {} };
 describe('array', () => {
-  test('required constraint', async () => {
-    const rule = Rule.array().required()
-    await expect(rule.validate(null, context)).resolves.toMatchSnapshot('required: null')
-    await expect(rule.validate(undefined, context)).resolves.toMatchSnapshot('required: undefined')
-    await expect(rule.validate([], context)).resolves.toMatchSnapshot('required: empty array')
-    await expect(rule.validate(['hei'], context)).resolves.toMatchSnapshot('required: valid')
-  })
-  test('min length constraint', async () => {
-    const rule = Rule.array().min(2)
-    await expect(rule.validate(['a'], context)).resolves.toMatchSnapshot('min length: too short')
-    await expect(rule.validate(['a', 'b', 'c'], context)).resolves.toMatchSnapshot(
-      'min length: valid'
-    )
-  })
-  test('max length constraint', async () => {
-    const rule = Rule.array().max(2)
-    await expect(rule.validate(['a', 'b', 'c', 'd'], context)).resolves.toMatchSnapshot(
-      'max length: too long'
-    )
-    await expect(rule.validate(['a'], context)).resolves.toMatchSnapshot('max length: valid')
-  })
-  test('exact length constraint', async () => {
-    const rule = Rule.array().length(2)
-    await expect(rule.validate(['a', 'b', 'c'], context)).resolves.toMatchSnapshot(
-      'exact length: too long'
-    )
-    await expect(rule.validate(['a'], context)).resolves.toMatchSnapshot('exact length: too short')
-    await expect(rule.validate(['a', 'b'], context)).resolves.toMatchSnapshot('exact length: valid')
-  })
-  test('unique constraint (default, simple values)', async () => {
-    const rule = Rule.array().unique()
-    await expect(rule.validate(['a', 'b', 'c', 'd'], context)).resolves.toMatchSnapshot(
-      'simple unique: valid'
-    )
-    await expect(rule.validate(['a', 'b', 'c', 'a'], context)).resolves.toMatchSnapshot(
-      'simple unique: duplicates'
-    )
-  })
-  test('unique constraint (default, object values)', async () => {
-    const rule = Rule.array().unique()
-    const ref = (id) => ({_ref: id, _type: 'reference'})
-    await expect(rule.validate(['a', 'b', 'c', 'd'].map(ref), context)).resolves.toMatchSnapshot(
-      'object unique: valid'
-    )
-    await expect(rule.validate(['a', 'b', 'c', 'a'].map(ref), context)).resolves.toMatchSnapshot(
-      'object unique: duplicates'
-    )
-  })
-  test('unique constraint (default, array values)', async () => {
-    const rule = Rule.array().unique()
-    const refArr = (id) => [{_ref: id, _type: 'reference'}]
-    await expect(rule.validate(['a', 'b', 'c', 'd'].map(refArr), context)).resolves.toMatchSnapshot(
-      'array unique: valid'
-    )
-    await expect(rule.validate(['a', 'a', 'c', 'd'].map(refArr), context)).resolves.toMatchSnapshot(
-      'array unique: duplicates'
-    )
-  })
-  test('unique constraint (default, bool values)', async () => {
-    const rule = Rule.array().unique()
-    await expect(rule.validate([true, false], context)).resolves.toMatchSnapshot(
-      'boolean unique: valid'
-    )
-    await expect(rule.validate([false, true, false], context)).resolves.toMatchSnapshot(
-      'boolean unique: duplicates'
-    )
-  })
-  test('unique constraint (default, numeric values)', async () => {
-    const rule = Rule.array().unique()
-    await expect(rule.validate([1, 3], context)).resolves.toMatchSnapshot('numeric unique: valid')
-    await expect(rule.validate([3, 1, 3], context)).resolves.toMatchSnapshot(
-      'numeric unique: duplicates'
-    )
-  })
-})
-//# sourceMappingURL=array.test.js.map
+    test('required constraint', async () => {
+        const rule = Rule.array().required();
+        await expect(rule.validate(null, context)).resolves.toMatchSnapshot('required: null');
+        await expect(rule.validate(undefined, context)).resolves.toMatchSnapshot('required: undefined');
+        await expect(rule.validate([], context)).resolves.toMatchSnapshot('required: empty array');
+        await expect(rule.validate(['hei'], context)).resolves.toMatchSnapshot('required: valid');
+    });
+    test('min length constraint', async () => {
+        const rule = Rule.array().min(2);
+        await expect(rule.validate(['a'], context)).resolves.toMatchSnapshot('min length: too short');
+        await expect(rule.validate(['a', 'b', 'c'], context)).resolves.toMatchSnapshot('min length: valid');
+    });
+    test('max length constraint', async () => {
+        const rule = Rule.array().max(2);
+        await expect(rule.validate(['a', 'b', 'c', 'd'], context)).resolves.toMatchSnapshot('max length: too long');
+        await expect(rule.validate(['a'], context)).resolves.toMatchSnapshot('max length: valid');
+    });
+    test('exact length constraint', async () => {
+        const rule = Rule.array().length(2);
+        await expect(rule.validate(['a', 'b', 'c'], context)).resolves.toMatchSnapshot('exact length: too long');
+        await expect(rule.validate(['a'], context)).resolves.toMatchSnapshot('exact length: too short');
+        await expect(rule.validate(['a', 'b'], context)).resolves.toMatchSnapshot('exact length: valid');
+    });
+    test('unique constraint (default, simple values)', async () => {
+        const rule = Rule.array().unique();
+        await expect(rule.validate(['a', 'b', 'c', 'd'], context)).resolves.toMatchSnapshot('simple unique: valid');
+        await expect(rule.validate(['a', 'b', 'c', 'a'], context)).resolves.toMatchSnapshot('simple unique: duplicates');
+    });
+    test('unique constraint (default, object values)', async () => {
+        const rule = Rule.array().unique();
+        const ref = (id) => ({ _ref: id, _type: 'reference' });
+        await expect(rule.validate(['a', 'b', 'c', 'd'].map(ref), context)).resolves.toMatchSnapshot('object unique: valid');
+        await expect(rule.validate(['a', 'b', 'c', 'a'].map(ref), context)).resolves.toMatchSnapshot('object unique: duplicates');
+    });
+    test('unique constraint (default, array values)', async () => {
+        const rule = Rule.array().unique();
+        const refArr = (id) => [{ _ref: id, _type: 'reference' }];
+        await expect(rule.validate(['a', 'b', 'c', 'd'].map(refArr), context)).resolves.toMatchSnapshot('array unique: valid');
+        await expect(rule.validate(['a', 'a', 'c', 'd'].map(refArr), context)).resolves.toMatchSnapshot('array unique: duplicates');
+    });
+    test('unique constraint (default, bool values)', async () => {
+        const rule = Rule.array().unique();
+        await expect(rule.validate([true, false], context)).resolves.toMatchSnapshot('boolean unique: valid');
+        await expect(rule.validate([false, true, false], context)).resolves.toMatchSnapshot('boolean unique: duplicates');
+    });
+    test('unique constraint (default, numeric values)', async () => {
+        const rule = Rule.array().unique();
+        await expect(rule.validate([1, 3], context)).resolves.toMatchSnapshot('numeric unique: valid');
+        await expect(rule.validate([3, 1, 3], context)).resolves.toMatchSnapshot('numeric unique: duplicates');
+    });
+});
+//# sourceMappingURL=array.test.js.map

package/lib/dts/test/children.test.d.ts

@@ -1,2 +1,2 @@
-export {}
-//# sourceMappingURL=children.test.d.ts.map
+export {};
+//# sourceMappingURL=children.test.d.ts.map