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

package/lib/dts/test/numbers.test.js

@@ -1,63 +1,57 @@
-import {Rule} from '../src'
-const context = {client: {}}
+import { Rule } from '../src';
+const context = { client: {} };
 describe('number', () => {
-  test('required constraint', async () => {
-    const rule = Rule.number().required()
-    await expect(rule.validate(undefined, context)).resolves.toMatchSnapshot('required: undefined')
-    await expect(rule.validate(13, context)).resolves.toMatchSnapshot('required: valid')
-  })
-  test('min constraint', async () => {
-    const rule = Rule.number().min(10)
-    await expect(rule.validate(3, context)).resolves.toMatchSnapshot('min: too low')
-    await expect(rule.validate(10, context)).resolves.toMatchSnapshot('min: valid, at limit')
-    await expect(rule.validate(20, context)).resolves.toMatchSnapshot('min: valid')
-  })
-  test('greater than constraint', async () => {
-    const rule = Rule.number().greaterThan(10)
-    await expect(rule.validate(3, context)).resolves.toMatchSnapshot('gt: too low')
-    await expect(rule.validate(10, context)).resolves.toMatchSnapshot('gt: too low, at limit')
-    await expect(rule.validate(20, context)).resolves.toMatchSnapshot('gt: valid')
-  })
-  test('max constraint', async () => {
-    const rule = Rule.number().max(10)
-    await expect(rule.validate(20, context)).resolves.toMatchSnapshot('max: too large')
-    await expect(rule.validate(10, context)).resolves.toMatchSnapshot('max: valid, at limit')
-    await expect(rule.validate(5, context)).resolves.toMatchSnapshot('max: valid')
-  })
-  test('less than constraint', async () => {
-    const rule = Rule.number().lessThan(10)
-    await expect(rule.validate(20, context)).resolves.toMatchSnapshot('lt: too high')
-    await expect(rule.validate(10, context)).resolves.toMatchSnapshot('lt: too high, at limit')
-    await expect(rule.validate(3, context)).resolves.toMatchSnapshot('lt: valid')
-  })
-  test('integer constraint', async () => {
-    const rule = Rule.number().integer()
-    await expect(rule.validate(31.14, context)).resolves.toMatchSnapshot('integer: invalid (float)')
-    await expect(rule.validate(31, context)).resolves.toMatchSnapshot('integer: valid')
-  })
-  test('precision constraint', async () => {
-    const rule = Rule.number().precision(3)
-    await expect(rule.validate(Math.PI, context)).resolves.toMatchSnapshot(
-      'precision: invalid (pi)'
-    )
-    await expect(rule.validate(31.133, context)).resolves.toMatchSnapshot(
-      'precision: valid (at limit)'
-    )
-    await expect(rule.validate(31.3, context)).resolves.toMatchSnapshot(
-      'precision: valid (below limit)'
-    )
-  })
-  test('positive constraint', async () => {
-    const rule = Rule.number().positive()
-    await expect(rule.validate(-31.14, context)).resolves.toMatchSnapshot('positive: invalid')
-    await expect(rule.validate(0, context)).resolves.toMatchSnapshot('positive: valid (zero)')
-    await expect(rule.validate(13, context)).resolves.toMatchSnapshot('positive: valid')
-  })
-  test('negative constraint', async () => {
-    const rule = Rule.number().negative()
-    await expect(rule.validate(31.14, context)).resolves.toMatchSnapshot('negative: invalid')
-    await expect(rule.validate(0, context)).resolves.toMatchSnapshot('negative: invalid (zero)')
-    await expect(rule.validate(-13, context)).resolves.toMatchSnapshot('negative: valid')
-  })
-})
-//# sourceMappingURL=numbers.test.js.map
+    test('required constraint', async () => {
+        const rule = Rule.number().required();
+        await expect(rule.validate(undefined, context)).resolves.toMatchSnapshot('required: undefined');
+        await expect(rule.validate(13, context)).resolves.toMatchSnapshot('required: valid');
+    });
+    test('min constraint', async () => {
+        const rule = Rule.number().min(10);
+        await expect(rule.validate(3, context)).resolves.toMatchSnapshot('min: too low');
+        await expect(rule.validate(10, context)).resolves.toMatchSnapshot('min: valid, at limit');
+        await expect(rule.validate(20, context)).resolves.toMatchSnapshot('min: valid');
+    });
+    test('greater than constraint', async () => {
+        const rule = Rule.number().greaterThan(10);
+        await expect(rule.validate(3, context)).resolves.toMatchSnapshot('gt: too low');
+        await expect(rule.validate(10, context)).resolves.toMatchSnapshot('gt: too low, at limit');
+        await expect(rule.validate(20, context)).resolves.toMatchSnapshot('gt: valid');
+    });
+    test('max constraint', async () => {
+        const rule = Rule.number().max(10);
+        await expect(rule.validate(20, context)).resolves.toMatchSnapshot('max: too large');
+        await expect(rule.validate(10, context)).resolves.toMatchSnapshot('max: valid, at limit');
+        await expect(rule.validate(5, context)).resolves.toMatchSnapshot('max: valid');
+    });
+    test('less than constraint', async () => {
+        const rule = Rule.number().lessThan(10);
+        await expect(rule.validate(20, context)).resolves.toMatchSnapshot('lt: too high');
+        await expect(rule.validate(10, context)).resolves.toMatchSnapshot('lt: too high, at limit');
+        await expect(rule.validate(3, context)).resolves.toMatchSnapshot('lt: valid');
+    });
+    test('integer constraint', async () => {
+        const rule = Rule.number().integer();
+        await expect(rule.validate(31.14, context)).resolves.toMatchSnapshot('integer: invalid (float)');
+        await expect(rule.validate(31, context)).resolves.toMatchSnapshot('integer: valid');
+    });
+    test('precision constraint', async () => {
+        const rule = Rule.number().precision(3);
+        await expect(rule.validate(Math.PI, context)).resolves.toMatchSnapshot('precision: invalid (pi)');
+        await expect(rule.validate(31.133, context)).resolves.toMatchSnapshot('precision: valid (at limit)');
+        await expect(rule.validate(31.3, context)).resolves.toMatchSnapshot('precision: valid (below limit)');
+    });
+    test('positive constraint', async () => {
+        const rule = Rule.number().positive();
+        await expect(rule.validate(-31.14, context)).resolves.toMatchSnapshot('positive: invalid');
+        await expect(rule.validate(0, context)).resolves.toMatchSnapshot('positive: valid (zero)');
+        await expect(rule.validate(13, context)).resolves.toMatchSnapshot('positive: valid');
+    });
+    test('negative constraint', async () => {
+        const rule = Rule.number().negative();
+        await expect(rule.validate(31.14, context)).resolves.toMatchSnapshot('negative: invalid');
+        await expect(rule.validate(0, context)).resolves.toMatchSnapshot('negative: invalid (zero)');
+        await expect(rule.validate(-13, context)).resolves.toMatchSnapshot('negative: valid');
+    });
+});
+//# sourceMappingURL=numbers.test.js.map

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

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

package/lib/dts/test/strings.test.js

@@ -1,151 +1,100 @@
-import {Rule} from '../src'
-const context = {client: {}}
+import { Rule } from '../src';
+const context = { client: {} };
 describe('string', () => {
-  test('required constraint', async () => {
-    const rule = Rule.string().required()
-    await expect(rule.validate('', context)).resolves.toMatchSnapshot('required: empty string')
-    await expect(rule.validate(null, context)).resolves.toMatchSnapshot('required: null')
-    await expect(rule.validate(undefined, context)).resolves.toMatchSnapshot('required: undefined')
-    await expect(rule.validate('abc', context)).resolves.toMatchSnapshot('required: valid')
-  })
-  test('min length constraint', async () => {
-    const rule = Rule.string().min(2)
-    await expect(rule.validate('a', context)).resolves.toMatchSnapshot('min length: too short')
-    await expect(rule.validate('abc', context)).resolves.toMatchSnapshot('min length: valid')
-  })
-  test('max length constraint', async () => {
-    const rule = Rule.string().max(5)
-    await expect(rule.validate('abcdefg', context)).resolves.toMatchSnapshot('max length: too long')
-    await expect(rule.validate('abc', context)).resolves.toMatchSnapshot('max length: valid')
-  })
-  test('exact length constraint', async () => {
-    const rule = Rule.string().length(5)
-    await expect(rule.validate('abcdefgh', context)).resolves.toMatchSnapshot(
-      'exact length: too long'
-    )
-    await expect(rule.validate('abc', context)).resolves.toMatchSnapshot('exact length: too short')
-    await expect(rule.validate('abcde', context)).resolves.toMatchSnapshot('exact length: valid')
-  })
-  test('uppercase constraint', async () => {
-    const rule = Rule.string().uppercase()
-    await expect(rule.validate('sanity', context)).resolves.toMatchSnapshot(
-      'uppercase: all lowercase'
-    )
-    await expect(rule.validate('Sanity', context)).resolves.toMatchSnapshot(
-      'uppercase: some lowercase'
-    )
-    await expect(rule.validate('Sanity', context)).resolves.toMatchSnapshot(
-      'uppercase: some lowercase'
-    )
-    await expect(rule.validate('SäNITY', context)).resolves.toMatchSnapshot(
-      'uppercase: locale characters'
-    )
-    await expect(rule.validate('SANITY', context)).resolves.toMatchSnapshot('uppercase: valid')
-  })
-  test('lowercase constraint', async () => {
-    const rule = Rule.string().lowercase()
-    await expect(rule.validate('SANITY', context)).resolves.toMatchSnapshot(
-      'lowercase: all uppercase'
-    )
-    await expect(rule.validate('Sanity', context)).resolves.toMatchSnapshot(
-      'lowercase: some uppercase'
-    )
-    await expect(rule.validate('sÄnity', context)).resolves.toMatchSnapshot(
-      'lowercase: locale characters'
-    )
-    await expect(rule.validate('sanity', context)).resolves.toMatchSnapshot('lowercase: valid')
-  })
-  test('regex constraint', async () => {
-    const rule = Rule.string().regex(/^[A-Z][a-z]+$/)
-    await expect(rule.validate('SANITY', context)).resolves.toMatchSnapshot('regex: non-match')
-    await expect(rule.validate('Sanity', context)).resolves.toMatchSnapshot('regex: match')
-  })
-  test('regex constraint (inverted)', async () => {
-    const rule = Rule.string().regex(/^[A-Z][a-z]+$/, {invert: true})
-    await expect(rule.validate('SANITY', context)).resolves.toMatchSnapshot(
-      'regex: inverted non-match'
-    )
-    await expect(rule.validate('Sanity', context)).resolves.toMatchSnapshot('regex: inverted match')
-  })
-  test('regex constraint (custom pattern name)', async () => {
-    const rule = Rule.string().regex(/^[A-Z][a-z]+$/, 'PascalCase')
-    await expect(rule.validate('SANITY', context)).resolves.toMatchSnapshot(
-      'regex: non-match w/ custom pattern name'
-    )
-    await expect(rule.validate('Sanity', context)).resolves.toMatchSnapshot(
-      'regex: match w/ custom pattern name'
-    )
-  })
-  test('regex constraint (custom pattern name, as options)', async () => {
-    const rule = Rule.string().regex(/^[A-Z][a-z]+$/, {name: 'PascalCase'})
-    await expect(rule.validate('SANITY', context)).resolves.toMatchSnapshot(
-      'regex: non-match w/ custom pattern name (opt)'
-    )
-    await expect(rule.validate('Sanity', context)).resolves.toMatchSnapshot(
-      'regex: match w/ custom pattern name (opt)'
-    )
-  })
-  test('uri constraint', async () => {
-    const rule = Rule.string().uri()
-    await expect(rule.validate('SANITY', context)).resolves.toMatchSnapshot('uri: non-match')
-    await expect(rule.validate('https://sanity.io/', context)).resolves.toHaveLength(0)
-  })
-  test('uri constraint (with unicode chars)', async () => {
-    const rule = Rule.string().uri()
-    await expect(rule.validate('Blåbærsyltetøy', context)).resolves.toMatchSnapshot(
-      'uri: non-match'
-    )
-    await expect(
-      rule.validate('https://en.wikipedia.org/wiki/San_&_Søn', context)
-    ).resolves.toHaveLength(0)
-    await expect(
-      rule.validate('https://zh.wikipedia.org/wiki/心形符號', context)
-    ).resolves.toHaveLength(0)
-    await expect(
-      rule.validate('https://ru.wikipedia.org/wiki/Зонтичные', context)
-    ).resolves.toHaveLength(0)
-    await expect(rule.validate('https://påtapp.no/oslo', context)).resolves.toHaveLength(0)
-  })
-  test('uri constraint (invalid protocol)', async () => {
-    const rule = Rule.string().uri({scheme: ['http', 'ftp']})
-    await expect(rule.validate('https://sanity.io/', context)).resolves.toMatchSnapshot(
-      'uri: protocol non-match'
-    )
-    await expect(rule.validate('ftp://code.sanity.io/', context)).resolves.toHaveLength(0)
-  })
-  test('uri constraint (credentials)', async () => {
-    let rule = Rule.string().uri({allowCredentials: true})
-    await expect(rule.validate('http://foo:bar@sanity.io/', context)).resolves.toHaveLength(0)
-    await expect(rule.validate('http://sanity.io/', context)).resolves.toHaveLength(0)
-    rule = Rule.string().uri({allowCredentials: false})
-    await expect(rule.validate('http://sanity.io/', context)).resolves.toHaveLength(0)
-    await expect(rule.validate('http://foo:bar@sanity.io/', context)).resolves.toMatchSnapshot(
-      'uri: credentials specified but not allowed'
-    )
-    await expect(rule.validate('http://espen@sanity.io/', context)).resolves.toMatchSnapshot(
-      'uri: username specified but not allowed'
-    )
-  })
-  test('custom rule with string', async () => {
-    const rule = Rule.string().custom((val) =>
-      val.split('').reverse().join('') === val ? true : 'Must be a palindrome!'
-    )
-    await expect(rule.validate('hei', context)).resolves.toMatchSnapshot('not a palindrome')
-    await expect(rule.validate('madam', context)).resolves.toHaveLength(0)
-  })
-  test('custom async rule with string', async () => {
-    const rule = Rule.string().custom(
-      (val) =>
-        new Promise((resolve) =>
-          setTimeout(
-            () =>
-              resolve(val.split('').reverse().join('') === val ? true : 'Must be a palindrome!'),
-            50
-          )
-        )
-    )
-    await expect(rule.validate('hei', context)).resolves.toMatchSnapshot('not a palindrome')
-    await expect(rule.validate('madam', context)).resolves.toHaveLength(0)
-  })
-})
-//# sourceMappingURL=strings.test.js.map
+    test('required constraint', async () => {
+        const rule = Rule.string().required();
+        await expect(rule.validate('', context)).resolves.toMatchSnapshot('required: empty string');
+        await expect(rule.validate(null, context)).resolves.toMatchSnapshot('required: null');
+        await expect(rule.validate(undefined, context)).resolves.toMatchSnapshot('required: undefined');
+        await expect(rule.validate('abc', context)).resolves.toMatchSnapshot('required: valid');
+    });
+    test('min length constraint', async () => {
+        const rule = Rule.string().min(2);
+        await expect(rule.validate('a', context)).resolves.toMatchSnapshot('min length: too short');
+        await expect(rule.validate('abc', context)).resolves.toMatchSnapshot('min length: valid');
+    });
+    test('max length constraint', async () => {
+        const rule = Rule.string().max(5);
+        await expect(rule.validate('abcdefg', context)).resolves.toMatchSnapshot('max length: too long');
+        await expect(rule.validate('abc', context)).resolves.toMatchSnapshot('max length: valid');
+    });
+    test('exact length constraint', async () => {
+        const rule = Rule.string().length(5);
+        await expect(rule.validate('abcdefgh', context)).resolves.toMatchSnapshot('exact length: too long');
+        await expect(rule.validate('abc', context)).resolves.toMatchSnapshot('exact length: too short');
+        await expect(rule.validate('abcde', context)).resolves.toMatchSnapshot('exact length: valid');
+    });
+    test('uppercase constraint', async () => {
+        const rule = Rule.string().uppercase();
+        await expect(rule.validate('sanity', context)).resolves.toMatchSnapshot('uppercase: all lowercase');
+        await expect(rule.validate('Sanity', context)).resolves.toMatchSnapshot('uppercase: some lowercase');
+        await expect(rule.validate('Sanity', context)).resolves.toMatchSnapshot('uppercase: some lowercase');
+        await expect(rule.validate('SäNITY', context)).resolves.toMatchSnapshot('uppercase: locale characters');
+        await expect(rule.validate('SANITY', context)).resolves.toMatchSnapshot('uppercase: valid');
+    });
+    test('lowercase constraint', async () => {
+        const rule = Rule.string().lowercase();
+        await expect(rule.validate('SANITY', context)).resolves.toMatchSnapshot('lowercase: all uppercase');
+        await expect(rule.validate('Sanity', context)).resolves.toMatchSnapshot('lowercase: some uppercase');
+        await expect(rule.validate('sÄnity', context)).resolves.toMatchSnapshot('lowercase: locale characters');
+        await expect(rule.validate('sanity', context)).resolves.toMatchSnapshot('lowercase: valid');
+    });
+    test('regex constraint', async () => {
+        const rule = Rule.string().regex(/^[A-Z][a-z]+$/);
+        await expect(rule.validate('SANITY', context)).resolves.toMatchSnapshot('regex: non-match');
+        await expect(rule.validate('Sanity', context)).resolves.toMatchSnapshot('regex: match');
+    });
+    test('regex constraint (inverted)', async () => {
+        const rule = Rule.string().regex(/^[A-Z][a-z]+$/, { invert: true });
+        await expect(rule.validate('SANITY', context)).resolves.toMatchSnapshot('regex: inverted non-match');
+        await expect(rule.validate('Sanity', context)).resolves.toMatchSnapshot('regex: inverted match');
+    });
+    test('regex constraint (custom pattern name)', async () => {
+        const rule = Rule.string().regex(/^[A-Z][a-z]+$/, 'PascalCase');
+        await expect(rule.validate('SANITY', context)).resolves.toMatchSnapshot('regex: non-match w/ custom pattern name');
+        await expect(rule.validate('Sanity', context)).resolves.toMatchSnapshot('regex: match w/ custom pattern name');
+    });
+    test('regex constraint (custom pattern name, as options)', async () => {
+        const rule = Rule.string().regex(/^[A-Z][a-z]+$/, { name: 'PascalCase' });
+        await expect(rule.validate('SANITY', context)).resolves.toMatchSnapshot('regex: non-match w/ custom pattern name (opt)');
+        await expect(rule.validate('Sanity', context)).resolves.toMatchSnapshot('regex: match w/ custom pattern name (opt)');
+    });
+    test('uri constraint', async () => {
+        const rule = Rule.string().uri();
+        await expect(rule.validate('SANITY', context)).resolves.toMatchSnapshot('uri: non-match');
+        await expect(rule.validate('https://sanity.io/', context)).resolves.toHaveLength(0);
+    });
+    test('uri constraint (with unicode chars)', async () => {
+        const rule = Rule.string().uri();
+        await expect(rule.validate('Blåbærsyltetøy', context)).resolves.toMatchSnapshot('uri: non-match');
+        await expect(rule.validate('https://en.wikipedia.org/wiki/San_&_Søn', context)).resolves.toHaveLength(0);
+        await expect(rule.validate('https://zh.wikipedia.org/wiki/心形符號', context)).resolves.toHaveLength(0);
+        await expect(rule.validate('https://ru.wikipedia.org/wiki/Зонтичные', context)).resolves.toHaveLength(0);
+        await expect(rule.validate('https://påtapp.no/oslo', context)).resolves.toHaveLength(0);
+    });
+    test('uri constraint (invalid protocol)', async () => {
+        const rule = Rule.string().uri({ scheme: ['http', 'ftp'] });
+        await expect(rule.validate('https://sanity.io/', context)).resolves.toMatchSnapshot('uri: protocol non-match');
+        await expect(rule.validate('ftp://code.sanity.io/', context)).resolves.toHaveLength(0);
+    });
+    test('uri constraint (credentials)', async () => {
+        let rule = Rule.string().uri({ allowCredentials: true });
+        await expect(rule.validate('http://foo:bar@sanity.io/', context)).resolves.toHaveLength(0);
+        await expect(rule.validate('http://sanity.io/', context)).resolves.toHaveLength(0);
+        rule = Rule.string().uri({ allowCredentials: false });
+        await expect(rule.validate('http://sanity.io/', context)).resolves.toHaveLength(0);
+        await expect(rule.validate('http://foo:bar@sanity.io/', context)).resolves.toMatchSnapshot('uri: credentials specified but not allowed');
+        await expect(rule.validate('http://espen@sanity.io/', context)).resolves.toMatchSnapshot('uri: username specified but not allowed');
+    });
+    test('custom rule with string', async () => {
+        const rule = Rule.string().custom((val) => val.split('').reverse().join('') === val ? true : 'Must be a palindrome!');
+        await expect(rule.validate('hei', context)).resolves.toMatchSnapshot('not a palindrome');
+        await expect(rule.validate('madam', context)).resolves.toHaveLength(0);
+    });
+    test('custom async rule with string', async () => {
+        const rule = Rule.string().custom((val) => new Promise((resolve) => setTimeout(() => resolve(val.split('').reverse().join('') === val ? true : 'Must be a palindrome!'), 50)));
+        await expect(rule.validate('hei', context)).resolves.toMatchSnapshot('not a palindrome');
+        await expect(rule.validate('madam', context)).resolves.toHaveLength(0);
+    });
+});
+//# sourceMappingURL=strings.test.js.map