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

package/lib/dts/test/infer.test.js

@@ -1,292 +1,243 @@
-import SchemaBuilder from '@sanity/schema'
-import inferFromSchema from '../src/inferFromSchema'
-import validateDocument from '../src/validateDocument'
-import {createSchema} from './createSchema'
-import {createMockSanityClient} from './mocks/mockSanityClient'
-const client = createMockSanityClient()
+import SchemaBuilder from '@sanity/schema';
+import inferFromSchema from '../src/inferFromSchema';
+import validateDocument from '../src/validateDocument';
+import { createSchema } from './createSchema';
+import { createMockSanityClient } from './mocks/mockSanityClient';
+const client = createMockSanityClient();
 describe('schema validation inference', () => {
-  describe('object with `options.list` and `value` field', () => {
-    const listOptions = [
-      {value: '#f00', title: 'Red'},
-      {value: '#0f0', title: 'Green'},
-      {value: '#00f', title: 'Blue'},
-    ]
-    const schema = SchemaBuilder.compile({
-      types: [
-        {
-          name: 'colorList',
-          type: 'object',
-          fields: [
-            {name: 'value', type: 'string'},
-            {name: 'title', type: 'string'},
-          ],
-          options: {
-            list: listOptions,
-          },
-        },
-      ],
-    })
-    test('allowed value', async () => {
-      const type = inferFromSchema(schema).get('colorList')
-      await expectNoError(type.validation, listOptions[0])
-    })
-    test('disallowed value', async () => {
-      const type = inferFromSchema(schema).get('colorList')
-      await expectError(
-        type.validation,
-        {value: '#ccc', title: 'Gray'},
-        'Value did not match any allowed value'
-      )
-    })
-  })
-  describe('field validations', () => {
-    const fieldValidationInferReproDoc = {
-      name: 'fieldValidationInferReproDoc',
-      type: 'document',
-      title: 'FieldValidationRepro',
-      // eslint-disable-next-line @typescript-eslint/no-shadow
-      validation: (Rule) =>
-        Rule.fields({
-          stringField: (fieldRule) => fieldRule.required(),
-        }),
-      fields: [
-        {
-          name: 'stringField',
-          type: 'string',
-          title: 'Field of someObjectType with validation',
-          description: 'First field should be required',
-        },
-      ],
-    }
-    const schema = SchemaBuilder.compile({
-      types: [fieldValidationInferReproDoc],
-    })
-    test('field validations defined on an object type does not affect the field type validation', () => {
-      const documentType = inferFromSchema(schema).get('fieldValidationInferReproDoc')
-      const fieldWithoutValidation = documentType.fields.find(
-        (field) => field.name === 'stringField'
-      )
-      // The first field should only have the validation rules that comes with its type
-      expect(
-        fieldWithoutValidation?.type.validation.flatMap(
-          // eslint-disable-next-line dot-notation
-          (validation) => validation['_rules']
-        )
-      ).toEqual([{flag: 'type', constraint: 'String'}])
-    })
-  })
-  describe('slug validation', () => {
-    const slugField = {
-      type: 'document',
-      name: 'documentWithSlug',
-      title: 'Document with Slug',
-      fields: [
-        {
-          name: 'slugField',
-          type: 'slug',
-        },
-      ],
+    describe('object with `options.list` and `value` field', () => {
+        const listOptions = [
+            { value: '#f00', title: 'Red' },
+            { value: '#0f0', title: 'Green' },
+            { value: '#00f', title: 'Blue' },
+        ];
+        const schema = SchemaBuilder.compile({
+            types: [
+                {
+                    name: 'colorList',
+                    type: 'object',
+                    fields: [
+                        { name: 'value', type: 'string' },
+                        { name: 'title', type: 'string' },
+                    ],
+                    options: {
+                        list: listOptions,
+                    },
+                },
+            ],
+        });
+        test('allowed value', async () => {
+            const type = inferFromSchema(schema).get('colorList');
+            await expectNoError(type.validation, listOptions[0]);
+        });
+        test('disallowed value', async () => {
+            const type = inferFromSchema(schema).get('colorList');
+            await expectError(type.validation, { value: '#ccc', title: 'Gray' }, 'Value did not match any allowed value');
+        });
+    });
+    describe('field validations', () => {
+        const fieldValidationInferReproDoc = {
+            name: 'fieldValidationInferReproDoc',
+            type: 'document',
+            title: 'FieldValidationRepro',
+            // eslint-disable-next-line @typescript-eslint/no-shadow
+            validation: (Rule) => Rule.fields({
+                stringField: (fieldRule) => fieldRule.required(),
+            }),
+            fields: [
+                {
+                    name: 'stringField',
+                    type: 'string',
+                    title: 'Field of someObjectType with validation',
+                    description: 'First field should be required',
+                },
+            ],
+        };
+        const schema = SchemaBuilder.compile({
+            types: [fieldValidationInferReproDoc],
+        });
+        test('field validations defined on an object type does not affect the field type validation', () => {
+            const documentType = inferFromSchema(schema).get('fieldValidationInferReproDoc');
+            const fieldWithoutValidation = documentType.fields.find((field) => field.name === 'stringField');
+            // The first field should only have the validation rules that comes with its type
+            expect(fieldWithoutValidation?.type.validation.flatMap(
+            // eslint-disable-next-line dot-notation
+            (validation) => validation['_rules'])).toEqual([{ flag: 'type', constraint: 'String' }]);
+        });
+    });
+    describe('slug validation', () => {
+        const slugField = {
+            type: 'document',
+            name: 'documentWithSlug',
+            title: 'Document with Slug',
+            fields: [
+                {
+                    name: 'slugField',
+                    type: 'slug',
+                },
+            ],
+        };
+        const schema = createSchema({
+            types: [slugField],
+        });
+        const mockDocument = {
+            _id: 'mockDocument',
+            _type: 'documentWithSlug',
+            slugField: { current: 'example-value' },
+            _createdAt: '2021-08-26T18:47:55.497Z',
+            _updatedAt: '2021-08-26T18:47:55.497Z',
+            _rev: 'example-rev',
+        };
+        afterEach(() => {
+            client.fetch.mockReset();
+        });
+        test('slug is valid if uniqueness queries returns true', async () => {
+            client.fetch.mockImplementation(() => Promise.resolve(
+            // return true to mock a unique result (valid)
+            true));
+            await expect(validateDocument(client, mockDocument, schema)).resolves.toEqual([]);
+            expect(client.fetch).toHaveBeenCalledTimes(1);
+            expect(client.fetch.mock.calls[0]).toEqual([
+                '!defined(*[_type == $docType && !(_id in [$draft, $published]) && slugField.current == $slug][0]._id)',
+                {
+                    docType: 'documentWithSlug',
+                    draft: 'drafts.mockDocument',
+                    published: 'mockDocument',
+                    slug: 'example-value',
+                },
+                {
+                    tag: 'validation.slug-is-unique',
+                },
+            ]);
+        });
+        test('slug is invalid if uniqueness queries returns false', async () => {
+            client.fetch.mockReset();
+            client.fetch.mockImplementation(() => Promise.resolve(
+            // return false to mock a non-unique result (invalid)
+            false));
+            await expect(validateDocument(client, mockDocument, schema)).resolves.toMatchObject([
+                {
+                    path: ['slugField'],
+                    level: 'error',
+                    item: { message: 'Slug is already in use', paths: [] },
+                },
+            ]);
+            expect(client.fetch).toHaveBeenCalledTimes(1);
+            expect(client.fetch.mock.calls[0]).toEqual([
+                '!defined(*[_type == $docType && !(_id in [$draft, $published]) && slugField.current == $slug][0]._id)',
+                {
+                    docType: 'documentWithSlug',
+                    draft: 'drafts.mockDocument',
+                    published: 'mockDocument',
+                    slug: 'example-value',
+                },
+                {
+                    tag: 'validation.slug-is-unique',
+                },
+            ]);
+        });
+    });
+    describe('reference validation', () => {
+        const documentWithReference = {
+            type: 'document',
+            name: 'documentWithReference',
+            title: 'Document with Reference',
+            fields: [
+                {
+                    name: 'referenceField',
+                    type: 'reference',
+                    to: [{ type: 'documentWithReference' }],
+                },
+                {
+                    name: 'referenceFieldWeak',
+                    type: 'reference',
+                    weak: true,
+                    to: [{ type: 'documentWithReference' }],
+                },
+            ],
+        };
+        const schema = createSchema({
+            types: [documentWithReference],
+        });
+        const mockDocument = {
+            _id: 'mockDocument',
+            _type: 'documentWithReference',
+            _createdAt: '2021-08-26T18:47:55.497Z',
+            _updatedAt: '2021-08-26T18:47:55.497Z',
+            _rev: 'example-rev',
+        };
+        afterEach(() => {
+            client.fetch.mockReset();
+        });
+        test('referenced document must exist (unless weak)', async () => {
+            const mockGetDocumentExists = jest.fn(() => Promise.resolve(false));
+            await expect(validateDocument(client, {
+                ...mockDocument,
+                referenceField: {
+                    _ref: 'example-id',
+                },
+            }, schema, { getDocumentExists: mockGetDocumentExists })).resolves.toMatchObject([
+                {
+                    item: { message: /.+/ },
+                    level: 'error',
+                    path: ['referenceField'],
+                },
+            ]);
+            expect(mockGetDocumentExists.mock.calls).toMatchObject([[{ id: 'example-id' }]]);
+        });
+        test('reference is valid if schema type is marked as weak', async () => {
+            await expect(validateDocument(client, {
+                ...mockDocument,
+                referenceFieldWeak: { _ref: 'example-id' },
+            }, schema)).resolves.toEqual([]);
+        });
+        test('throws if `getDocumentExists` is not present', async () => {
+            const result = await validateDocument(client, {
+                ...mockDocument,
+                referenceField: {
+                    _ref: 'example-id',
+                },
+            }, schema, { getDocumentExists: undefined });
+            expect(result).toHaveLength(1);
+            expect(result[0].item.message.includes('`getDocumentExists` was not provided in validation context')).toBe(true);
+        });
+        test('reference is valid if schema type is strong and document does exists', async () => {
+            const mockGetDocumentExists = jest.fn(() => Promise.resolve(true));
+            await expect(validateDocument(client, {
+                ...mockDocument,
+                referenceField: {
+                    _ref: 'example-id',
+                },
+            }, schema, { getDocumentExists: mockGetDocumentExists })).resolves.toEqual([]);
+            expect(mockGetDocumentExists.mock.calls).toMatchObject([[{ id: 'example-id' }]]);
+        });
+    });
+});
+async function expectNoError(validations, value) {
+    const errors = (await Promise.all(validations.map((rule) => rule.validate(value, { client: {} })))).flat();
+    if (errors.length === 0) {
+        // This shouldn't actually be needed, but counts against an assertion in jest-terms
+        expect(errors).toHaveLength(0);
+        return;
     }
-    const schema = createSchema({
-      types: [slugField],
-    })
-    const mockDocument = {
-      _id: 'mockDocument',
-      _type: 'documentWithSlug',
-      slugField: {current: 'example-value'},
-      _createdAt: '2021-08-26T18:47:55.497Z',
-      _updatedAt: '2021-08-26T18:47:55.497Z',
-      _rev: 'example-rev',
+    const messages = errors.map((err) => err.item && err.item.message).join('\n\n- ');
+    throw new Error(`Expected no errors, but found ${errors.length}:\n- ${messages}`);
+}
+async function expectError(validations, value, message, level = 'error') {
+    const errors = (await Promise.all(validations.map((rule) => rule.validate(value, { client: {} })))).flat();
+    if (!errors.length) {
+        throw new Error(`Expected error matching "${message}", but no errors were returned.`);
     }
-    afterEach(() => {
-      client.fetch.mockReset()
-    })
-    test('slug is valid if uniqueness queries returns true', async () => {
-      client.fetch.mockImplementation(() =>
-        Promise.resolve(
-          // return true to mock a unique result (valid)
-          true
-        )
-      )
-      await expect(validateDocument(client, mockDocument, schema)).resolves.toEqual([])
-      expect(client.fetch).toHaveBeenCalledTimes(1)
-      expect(client.fetch.mock.calls[0]).toEqual([
-        '!defined(*[_type == $docType && !(_id in [$draft, $published]) && slugField.current == $slug][0]._id)',
-        {
-          docType: 'documentWithSlug',
-          draft: 'drafts.mockDocument',
-          published: 'mockDocument',
-          slug: 'example-value',
-        },
-        {
-          tag: 'validation.slug-is-unique',
-        },
-      ])
-    })
-    test('slug is invalid if uniqueness queries returns false', async () => {
-      client.fetch.mockReset()
-      client.fetch.mockImplementation(() =>
-        Promise.resolve(
-          // return false to mock a non-unique result (invalid)
-          false
-        )
-      )
-      await expect(validateDocument(client, mockDocument, schema)).resolves.toMatchObject([
-        {
-          path: ['slugField'],
-          level: 'error',
-          item: {message: 'Slug is already in use', paths: []},
-        },
-      ])
-      expect(client.fetch).toHaveBeenCalledTimes(1)
-      expect(client.fetch.mock.calls[0]).toEqual([
-        '!defined(*[_type == $docType && !(_id in [$draft, $published]) && slugField.current == $slug][0]._id)',
-        {
-          docType: 'documentWithSlug',
-          draft: 'drafts.mockDocument',
-          published: 'mockDocument',
-          slug: 'example-value',
-        },
-        {
-          tag: 'validation.slug-is-unique',
-        },
-      ])
-    })
-  })
-  describe('reference validation', () => {
-    const documentWithReference = {
-      type: 'document',
-      name: 'documentWithReference',
-      title: 'Document with Reference',
-      fields: [
-        {
-          name: 'referenceField',
-          type: 'reference',
-          to: [{type: 'documentWithReference'}],
-        },
-        {
-          name: 'referenceFieldWeak',
-          type: 'reference',
-          weak: true,
-          to: [{type: 'documentWithReference'}],
-        },
-      ],
+    const matches = errors.filter((err) => err.item && err.item.message.includes(message));
+    if (matches.length === 0) {
+        const messages = errors.map((err) => err.item && err.item.message).join('\n\n- ');
+        throw new Error(`Expected error matching "${message}" not found. Errors found:\n- ${messages}`);
     }
-    const schema = createSchema({
-      types: [documentWithReference],
-    })
-    const mockDocument = {
-      _id: 'mockDocument',
-      _type: 'documentWithReference',
-      _createdAt: '2021-08-26T18:47:55.497Z',
-      _updatedAt: '2021-08-26T18:47:55.497Z',
-      _rev: 'example-rev',
+    const levelMatch = matches.find((err) => err.level === level);
+    if (!levelMatch) {
+        throw new Error(`Expected error to have level "${level}", got ${matches[0].level}`);
     }
-    afterEach(() => {
-      client.fetch.mockReset()
-    })
-    test('referenced document must exist (unless weak)', async () => {
-      const mockGetDocumentExists = jest.fn(() => Promise.resolve(false))
-      await expect(
-        validateDocument(
-          client,
-          {
-            ...mockDocument,
-            referenceField: {
-              _ref: 'example-id',
-            },
-          },
-          schema,
-          {getDocumentExists: mockGetDocumentExists}
-        )
-      ).resolves.toMatchObject([
-        {
-          item: {message: /.+/},
-          level: 'error',
-          path: ['referenceField'],
-        },
-      ])
-      expect(mockGetDocumentExists.mock.calls).toMatchObject([[{id: 'example-id'}]])
-    })
-    test('reference is valid if schema type is marked as weak', async () => {
-      await expect(
-        validateDocument(
-          client,
-          {
-            ...mockDocument,
-            referenceFieldWeak: {_ref: 'example-id'},
-          },
-          schema
-        )
-      ).resolves.toEqual([])
-    })
-    test('throws if `getDocumentExists` is not present', async () => {
-      const result = await validateDocument(
-        client,
-        {
-          ...mockDocument,
-          referenceField: {
-            _ref: 'example-id',
-          },
-        },
-        schema,
-        {getDocumentExists: undefined}
-      )
-      expect(result).toHaveLength(1)
-      expect(
-        result[0].item.message.includes(
-          '`getDocumentExists` was not provided in validation context'
-        )
-      ).toBe(true)
-    })
-    test('reference is valid if schema type is strong and document does exists', async () => {
-      const mockGetDocumentExists = jest.fn(() => Promise.resolve(true))
-      await expect(
-        validateDocument(
-          client,
-          {
-            ...mockDocument,
-            referenceField: {
-              _ref: 'example-id',
-            },
-          },
-          schema,
-          {getDocumentExists: mockGetDocumentExists}
-        )
-      ).resolves.toEqual([])
-      expect(mockGetDocumentExists.mock.calls).toMatchObject([[{id: 'example-id'}]])
-    })
-  })
-})
-async function expectNoError(validations, value) {
-  const errors = (
-    await Promise.all(validations.map((rule) => rule.validate(value, {client: {}})))
-  ).flat()
-  if (errors.length === 0) {
     // This shouldn't actually be needed, but counts against an assertion in jest-terms
-    expect(errors).toHaveLength(0)
-    return
-  }
-  const messages = errors.map((err) => err.item && err.item.message).join('\n\n- ')
-  throw new Error(`Expected no errors, but found ${errors.length}:\n- ${messages}`)
-}
-async function expectError(validations, value, message, level = 'error') {
-  const errors = (
-    await Promise.all(validations.map((rule) => rule.validate(value, {client: {}})))
-  ).flat()
-  if (!errors.length) {
-    throw new Error(`Expected error matching "${message}", but no errors were returned.`)
-  }
-  const matches = errors.filter((err) => err.item && err.item.message.includes(message))
-  if (matches.length === 0) {
-    const messages = errors.map((err) => err.item && err.item.message).join('\n\n- ')
-    throw new Error(`Expected error matching "${message}" not found. Errors found:\n- ${messages}`)
-  }
-  const levelMatch = matches.find((err) => err.level === level)
-  if (!levelMatch) {
-    throw new Error(`Expected error to have level "${level}", got ${matches[0].level}`)
-  }
-  // This shouldn't actually be needed, but counts against an assertion in jest-terms
-  expect(levelMatch.item.message).toMatch(message)
+    expect(levelMatch.item.message).toMatch(message);
 }
-//# sourceMappingURL=infer.test.js.map
+//# sourceMappingURL=infer.test.js.map

package/lib/dts/test/mocks/mockSanityClient.d.ts

@@ -1,6 +1,5 @@
-/// <reference types="jest" />
 export declare function createMockSanityClient(): {
-  fetch: jest.Mock<Promise<any>, [query: string]>
-  withConfig: () => any
-}
-//# sourceMappingURL=mockSanityClient.d.ts.map
+    fetch: jest.Mock<Promise<any>, [query: string]>;
+    withConfig: () => any;
+};
+//# sourceMappingURL=mockSanityClient.d.ts.map

package/lib/dts/test/mocks/mockSanityClient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mockSanityClient.d.ts","sourceRoot":"","sources":["../../../../test/mocks/mockSanityClient.ts"],"names":[],"mappings":";AAAA,wBAAgB,sBAAsB;;;EAUrC"}
+{"version":3,"file":"mockSanityClient.d.ts","sourceRoot":"","sources":["../../../../test/mocks/mockSanityClient.ts"],"names":[],"mappings":"AAAA,wBAAgB,sBAAsB;;;EAUrC"}

package/lib/dts/test/mocks/mockSanityClient.js

@@ -1,8 +1,8 @@
 export function createMockSanityClient() {
-  const _client = {
-    fetch: jest.fn((query) => Promise.resolve(null)),
-    withConfig: () => _client,
-  }
-  return _client
+    const _client = {
+        fetch: jest.fn((query) => Promise.resolve(null)),
+        withConfig: () => _client,
+    };
+    return _client;
 }
-//# sourceMappingURL=mockSanityClient.js.map
+//# sourceMappingURL=mockSanityClient.js.map

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

@@ -1,3 +1,3 @@
-declare const _default: null
-export default _default
-//# sourceMappingURL=nullExport.d.ts.map
+declare const _default: null;
+export default _default;
+//# sourceMappingURL=nullExport.d.ts.map

package/lib/dts/test/nullExport.js

@@ -1,4 +1,4 @@
 // used to mock out a part
 // see the jest config
-export default null
-//# sourceMappingURL=nullExport.js.map
+export default null;
+//# sourceMappingURL=nullExport.js.map

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

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