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

package/lib/dts/src/validateDocument.test.js

@@ -1,717 +1,703 @@
-import {createSchema} from '../test/createSchema'
-import {createMockSanityClient} from '../test/mocks/mockSanityClient'
-import validateDocument, {resolveTypeForArrayItem, validateItem} from './validateDocument'
-import {convertToValidationMarker} from './util/convertToValidationMarker'
+import { createSchema } from '../test/createSchema';
+import { createMockSanityClient } from '../test/mocks/mockSanityClient';
+import validateDocument, { resolveTypeForArrayItem, validateItem } from './validateDocument';
+import { convertToValidationMarker } from './util/convertToValidationMarker';
 jest.mock('./util/convertToValidationMarker', () => {
-  return {
-    convertToValidationMarker: jest.fn(
-      jest.requireActual('./util/convertToValidationMarker').convertToValidationMarker
-    ),
-  }
-})
+    return {
+        convertToValidationMarker: jest.fn(jest.requireActual('./util/convertToValidationMarker').convertToValidationMarker),
+    };
+});
 beforeEach(() => {
-  convertToValidationMarker.mockClear()
-})
+    ;
+    convertToValidationMarker.mockClear();
+});
 // mock client
-const client = createMockSanityClient()
+const client = createMockSanityClient();
 describe('resolveTypeForArrayItem', () => {
-  const schema = createSchema({
-    types: [
-      {
-        name: 'foo',
-        type: 'object',
-        fields: [{name: 'title', type: 'number'}],
-      },
-      {
-        name: 'bar',
-        type: 'object',
-        fields: [{name: 'title', type: 'string'}],
-      },
-    ],
-  })
-  const fooType = schema.get('foo')
-  const barType = schema.get('bar')
-  it('finds a matching schema type for an array item value given a list of candidate types', () => {
-    const resolved = resolveTypeForArrayItem(
-      {
-        _type: 'bar',
-        _key: 'exampleKey',
-        title: 5,
-      },
-      [fooType, barType]
-    )
-    expect(resolved).toBe(barType)
-  })
-  it('assumes the type if there is only one possible candidate', () => {
-    const resolved = resolveTypeForArrayItem(
-      {
-        // notice no _type
-        _key: 'exampleKey',
-        title: 5,
-      },
-      [fooType]
-    )
-    expect(resolved).toBe(fooType)
-  })
-})
-describe('validateDocument', () => {
-  it('takes in a document + a compiled schema and returns a list of validation markers', async () => {
     const schema = createSchema({
-      types: [
-        {
-          name: 'simpleDoc',
-          type: 'document',
-          title: 'Simple Document',
-          fields: [
+        types: [
+            {
+                name: 'foo',
+                type: 'object',
+                fields: [{ name: 'title', type: 'number' }],
+            },
+            {
+                name: 'bar',
+                type: 'object',
+                fields: [{ name: 'title', type: 'string' }],
+            },
+        ],
+    });
+    const fooType = schema.get('foo');
+    const barType = schema.get('bar');
+    it('finds a matching schema type for an array item value given a list of candidate types', () => {
+        const resolved = resolveTypeForArrayItem({
+            _type: 'bar',
+            _key: 'exampleKey',
+            title: 5,
+        }, [fooType, barType]);
+        expect(resolved).toBe(barType);
+    });
+    it('assumes the type if there is only one possible candidate', () => {
+        const resolved = resolveTypeForArrayItem({
+            // notice no _type
+            _key: 'exampleKey',
+            title: 5,
+        }, [fooType]);
+        expect(resolved).toBe(fooType);
+    });
+});
+describe('validateDocument', () => {
+    it('takes in a document + a compiled schema and returns a list of validation markers', async () => {
+        const schema = createSchema({
+            types: [
+                {
+                    name: 'simpleDoc',
+                    type: 'document',
+                    title: 'Simple Document',
+                    fields: [
+                        {
+                            name: 'title',
+                            type: 'string',
+                            validation: (rule) => rule.required(),
+                        },
+                    ],
+                },
+            ],
+        });
+        const document = {
+            _id: 'testId',
+            _createdAt: '2021-08-27T14:48:51.650Z',
+            _rev: 'exampleRev',
+            _type: 'simpleDoc',
+            _updatedAt: '2021-08-27T14:48:51.650Z',
+            title: null,
+        };
+        const result = await validateDocument(client, document, schema);
+        expect(result).toMatchObject([
+            {
+                level: 'error',
+                item: {
+                    message: 'Expected type "String", got "null"',
+                    paths: [],
+                },
+                path: ['title'],
+            },
             {
-              name: 'title',
-              type: 'string',
-              validation: (rule) => rule.required(),
+                level: 'error',
+                item: {
+                    message: 'Required',
+                    paths: [],
+                },
+                path: ['title'],
             },
-          ],
-        },
-      ],
-    })
-    const document = {
-      _id: 'testId',
-      _createdAt: '2021-08-27T14:48:51.650Z',
-      _rev: 'exampleRev',
-      _type: 'simpleDoc',
-      _updatedAt: '2021-08-27T14:48:51.650Z',
-      title: null,
-    }
-    const result = await validateDocument(client, document, schema)
-    expect(result).toMatchObject([
-      {
-        level: 'error',
-        item: {
-          message: 'Expected type "String", got "null"',
-          paths: [],
-        },
-        path: ['title'],
-      },
-      {
-        level: 'error',
-        item: {
-          message: 'Required',
-          paths: [],
-        },
-        path: ['title'],
-      },
-    ])
-  })
-})
+        ]);
+    });
+});
 describe('validateItem', () => {
-  it("runs nested validation on an undefined value for object types if it's required", async () => {
-    const validation = (rule) => [
-      rule.required().error('This is required!'),
-      rule.max(160).warning('Too long!'),
-    ]
-    const schema = createSchema({
-      types: [
-        {
-          name: 'testObj',
-          type: 'object',
-          title: 'Test Object',
-          fields: [
-            {name: 'registeredString', type: 'registeredString'},
-            {name: 'inlineString', type: 'string', validation},
+    it("runs nested validation on an undefined value for object types if it's required", async () => {
+        const validation = (rule) => [
+            rule.required().error('This is required!'),
+            rule.max(160).warning('Too long!'),
+        ];
+        const schema = createSchema({
+            types: [
+                {
+                    name: 'testObj',
+                    type: 'object',
+                    title: 'Test Object',
+                    fields: [
+                        { name: 'registeredString', type: 'registeredString' },
+                        { name: 'inlineString', type: 'string', validation },
+                        {
+                            name: 'registeredObject',
+                            type: 'registeredObjectField',
+                            validation: (rule) => rule.required(),
+                        },
+                        {
+                            name: 'inlineObject',
+                            type: 'object',
+                            fields: [{ name: 'foo', type: 'string', validation }],
+                            validation: (rule) => rule.required(),
+                        },
+                        {
+                            name: 'notRequiredRegisteredObject',
+                            type: 'registeredObjectField',
+                        },
+                        {
+                            name: 'notRequiredInlineObject',
+                            type: 'object',
+                            fields: [{ name: 'foo', type: 'string', validation }],
+                        },
+                    ],
+                },
+                { name: 'registeredString', title: 'Registered String', type: 'string', validation },
+                {
+                    title: 'Registered Object Field',
+                    name: 'registeredObjectField',
+                    type: 'object',
+                    fields: [{ name: 'foo', type: 'string', validation }],
+                },
+            ],
+        });
+        // ensures there are no schema formatting issues
+        expect(schema._validation).toHaveLength(0);
+        await expect(validateItem({
+            client: client,
+            value: {},
+            document: undefined,
+            path: [],
+            parent: undefined,
+            type: schema.get('testObj'),
+            getDocumentExists: undefined,
+        })).resolves.toMatchObject([
             {
-              name: 'registeredObject',
-              type: 'registeredObjectField',
-              validation: (rule) => rule.required(),
+                level: 'error',
+                item: { message: 'This is required!' },
+                path: ['registeredString'],
             },
             {
-              name: 'inlineObject',
-              type: 'object',
-              fields: [{name: 'foo', type: 'string', validation}],
-              validation: (rule) => rule.required(),
+                level: 'error',
+                item: { message: 'This is required!' },
+                path: ['inlineString'],
             },
             {
-              name: 'notRequiredRegisteredObject',
-              type: 'registeredObjectField',
+                level: 'error',
+                item: { message: 'Required' },
+                path: ['registeredObject'],
             },
             {
-              name: 'notRequiredInlineObject',
-              type: 'object',
-              fields: [{name: 'foo', type: 'string', validation}],
+                level: 'error',
+                item: { message: 'This is required!' },
+                path: ['registeredObject', 'foo'],
             },
-          ],
-        },
-        {name: 'registeredString', title: 'Registered String', type: 'string', validation},
-        {
-          title: 'Registered Object Field',
-          name: 'registeredObjectField',
-          type: 'object',
-          fields: [{name: 'foo', type: 'string', validation}],
-        },
-      ],
-    })
-    // ensures there are no schema formatting issues
-    expect(schema._validation).toHaveLength(0)
-    await expect(
-      validateItem({
-        client: client,
-        value: {},
-        document: undefined,
-        path: [],
-        parent: undefined,
-        type: schema.get('testObj'),
-        getDocumentExists: undefined,
-      })
-    ).resolves.toMatchObject([
-      {
-        level: 'error',
-        item: {message: 'This is required!'},
-        path: ['registeredString'],
-      },
-      {
-        level: 'error',
-        item: {message: 'This is required!'},
-        path: ['inlineString'],
-      },
-      {
-        level: 'error',
-        item: {message: 'Required'},
-        path: ['registeredObject'],
-      },
-      {
-        level: 'error',
-        item: {message: 'This is required!'},
-        path: ['registeredObject', 'foo'],
-      },
-      {
-        level: 'error',
-        item: {message: 'Required'},
-        path: ['inlineObject'],
-      },
-      {
-        level: 'error',
-        item: {message: 'This is required!'},
-        path: ['inlineObject', 'foo'],
-      },
-    ])
-  })
-  it('runs nested validation for object-level rules set via Rule.fields()', async () => {
-    const schema = createSchema({
-      types: [
-        {
-          name: 'testObj',
-          type: 'object',
-          title: 'Test Object',
-          fields: [
-            {name: 'foo', type: 'string'},
-            {name: 'bar', type: 'string'},
-          ],
-          validation: (rule) => [
-            rule.required(),
-            rule.fields({
-              foo: (r) => r.required(),
-              bar: (r) => r.required(),
-            }),
-          ],
-        },
-      ],
-    })
-    // ensures there are no schema formatting issues
-    expect(schema._validation).toHaveLength(0)
-    await expect(
-      validateItem({
-        client: client,
-        document: undefined,
-        parent: undefined,
-        path: undefined,
-        type: schema.get('testObj'),
-        value: {foo: 5},
-        getDocumentExists: undefined,
-      })
-    ).resolves.toMatchObject([
-      {
-        item: {message: 'Expected type "String", got "Number"'},
-        level: 'error',
-        path: ['foo'],
-      },
-      {
-        item: {message: 'Required'},
-        level: 'error',
-        path: ['bar'],
-      },
-    ])
-  })
-  it('runs nested validation for markDefs', async () => {
-    const linkValidationSpy = jest.fn(() => true)
-    const internalLinkSpy = jest.fn(() => 'mock invalid response')
-    const schema = createSchema({
-      types: [
-        {
-          name: 'post',
-          title: 'Post',
-          type: 'document',
-          fields: [
-            {name: 'title', type: 'string'},
-            {name: 'body', type: 'string'},
-          ],
-        },
-        {
-          name: 'registeredEditor',
-          type: 'object',
-          title: 'Registered Editor',
-          fields: [
             {
-              name: 'editor',
-              type: 'array',
-              of: [
+                level: 'error',
+                item: { message: 'Required' },
+                path: ['inlineObject'],
+            },
+            {
+                level: 'error',
+                item: { message: 'This is required!' },
+                path: ['inlineObject', 'foo'],
+            },
+        ]);
+    });
+    it('runs nested validation for object-level rules set via Rule.fields()', async () => {
+        const schema = createSchema({
+            types: [
                 {
-                  type: 'block',
-                  marks: {
-                    annotations: [
-                      {
-                        name: 'exampleAnnotation',
-                        type: 'object',
-                        fields: [{name: 'value', type: 'string'}],
-                      },
+                    name: 'testObj',
+                    type: 'object',
+                    title: 'Test Object',
+                    fields: [
+                        { name: 'foo', type: 'string' },
+                        { name: 'bar', type: 'string' },
+                    ],
+                    validation: (rule) => [
+                        rule.required(),
+                        rule.fields({
+                            foo: (r) => r.required(),
+                            bar: (r) => r.required(),
+                        }),
                     ],
-                  },
                 },
-              ],
+            ],
+        });
+        // ensures there are no schema formatting issues
+        expect(schema._validation).toHaveLength(0);
+        await expect(validateItem({
+            client: client,
+            document: undefined,
+            parent: undefined,
+            path: undefined,
+            type: schema.get('testObj'),
+            value: { foo: 5 },
+            getDocumentExists: undefined,
+        })).resolves.toMatchObject([
+            {
+                item: { message: 'Expected type "String", got "Number"' },
+                level: 'error',
+                path: ['foo'],
             },
-          ],
-        },
-        {
-          name: 'blockTest',
-          type: 'document',
-          title: 'blockTest',
-          fields: [
             {
-              name: 'content',
-              title: 'Content',
-              type: 'array',
-              of: [
+                item: { message: 'Required' },
+                level: 'error',
+                path: ['bar'],
+            },
+        ]);
+    });
+    it('runs nested validation for markDefs', async () => {
+        const linkValidationSpy = jest.fn(() => true);
+        const internalLinkSpy = jest.fn(() => 'mock invalid response');
+        const schema = createSchema({
+            types: [
                 {
-                  type: 'block',
-                  marks: {
-                    annotations: [
-                      {
-                        name: 'link',
-                        type: 'object',
-                        title: 'link',
-                        fields: [{name: 'url', type: 'url'}],
-                        validation: (rule) => rule.custom(linkValidationSpy),
-                      },
-                      {
-                        name: 'internalLink',
-                        type: 'object',
-                        title: 'Internal link',
-                        fields: [{name: 'reference', type: 'reference', to: [{type: 'post'}]}],
-                        validation: (rule) => rule.custom(internalLinkSpy),
-                      },
-                      {name: 'nestedEditor', type: 'registeredEditor'},
+                    name: 'post',
+                    title: 'Post',
+                    type: 'document',
+                    fields: [
+                        { name: 'title', type: 'string' },
+                        { name: 'body', type: 'string' },
                     ],
-                  },
                 },
-              ],
-            },
-          ],
-        },
-      ],
-    })
-    expect(schema._validation).toHaveLength(0)
-    const nestedBlock = {
-      _type: 'block',
-      _key: 'nested-block-key',
-      children: [
-        {
-          _key: 'some-key',
-          _type: 'span',
-          text: 'hey',
-          marks: ['example-annotation-key'],
-        },
-      ],
-      markDefs: [
-        {
-          _type: 'exampleAnnotation',
-          _key: 'example-annotation-key',
-          value: 5,
-        },
-      ],
-      style: 'normal',
-    }
-    const block = {
-      _key: 'block-key',
-      _type: 'block',
-      children: [
-        {
-          _key: 'child-0',
-          _type: 'span',
-          marks: ['0', '1', '2'],
-          text: 'hey',
-        },
-      ],
-      markDefs: [
-        {
-          _key: '0',
-          _type: 'link',
-          url: 'https://example.com',
-        },
-        {
-          _key: '1',
-          _type: 'internalLink',
-          _ref: 'post-id',
-        },
-        {
-          _key: '2',
-          _type: 'nestedEditor',
-          editor: [nestedBlock],
-        },
-      ],
-      style: 'normal',
-    }
-    const document = {
-      _id: 'mock-id',
-      _type: 'blockTest',
-      _createdAt: '2021-11-15T21:06:41.812Z',
-      _rev: 'example-ref',
-      _updatedAt: '2021-11-15T21:06:41.812Z',
-      content: [block],
-    }
-    const result = await validateItem({
-      client: client,
-      document: document,
-      parent: undefined,
-      path: [],
-      type: schema.get('blockTest'),
-      value: document,
-      getDocumentExists: undefined,
-    })
-    expect(result).toMatchObject([
-      {
-        item: {message: 'mock invalid response', paths: []},
-        level: 'error',
-        path: ['content', {_key: 'block-key'}, 'markDefs', {_key: '1'}],
-      },
-      // this tests for nested markDef validation
-      {
-        item: {
-          message: 'Expected type "String", got "Number"',
-          paths: [],
-        },
-        level: 'error',
-        path: [
-          'content',
-          {_key: 'block-key'},
-          'markDefs',
-          {_key: '2'},
-          'editor',
-          {_key: 'nested-block-key'},
-          'markDefs',
-          {_key: 'example-annotation-key'},
-          'value',
-        ],
-      },
-    ])
-    expect(linkValidationSpy.mock.calls).toMatchObject([
-      [
-        {
-          _key: '0',
-          _type: 'link',
-          url: 'https://example.com',
-        },
-        {
-          document: {_id: 'mock-id'},
-          parent: {_key: 'block-key'},
-          path: ['content', {_key: 'block-key'}, 'markDefs', {_key: '0'}],
-          type: {name: 'link'},
-        },
-      ],
-    ])
-    expect(internalLinkSpy.mock.calls).toMatchObject([
-      [
-        {
-          _key: '1',
-          _ref: 'post-id',
-          _type: 'internalLink',
-        },
-        {
-          document: {_id: 'mock-id'},
-          parent: {_key: 'block-key'},
-          path: ['content', {_key: 'block-key'}, 'markDefs', {_key: '1'}],
-          type: {name: 'internalLink'},
-        },
-      ],
-    ])
-  })
-  it('resolves an array item type if there is just one type', async () => {
-    const schema = createSchema({
-      types: [
-        {
-          name: 'values',
-          title: 'Values',
-          type: 'array',
-          // note that there is only one type available
-          of: [{type: 'arrayItem'}],
-          validation: (rule) => rule.required(),
-        },
-        {
-          title: 'Array Item',
-          name: 'arrayItem',
-          type: 'object',
-          fields: [{name: 'title', type: 'string'}],
-        },
-      ],
-    })
-    // ensures there are no schema formatting issues
-    expect(schema._validation).toHaveLength(0)
-    const values = [
-      {
-        // note how this doesn't have a _type
-        title: 5,
-        _key: 'exampleKey',
-      },
-    ]
-    await expect(
-      validateItem({
-        client: client,
-        document: undefined,
-        parent: undefined,
-        path: [],
-        type: schema.get('values'),
-        value: values,
-        getDocumentExists: undefined,
-      })
-    ).resolves.toEqual([
-      {
-        level: 'error',
-        item: {
-          message: 'Expected type "String", got "Number"',
-          paths: [],
-        },
-        path: [{_key: 'exampleKey'}, 'title'],
-      },
-    ])
-  })
-  it('properly passes the nested value, type, and path to rule.validate', async () => {
-    const schema = createSchema({
-      types: [
-        {
-          name: 'root',
-          type: 'object',
-          title: 'Root',
-          fields: [
-            {
-              name: 'level1Object',
-              type: 'object',
-              validation: (rule) => rule.custom(() => 'from level 1 object'),
-              fields: [
                 {
-                  name: 'level2String',
-                  type: 'string',
-                  validation: (rule) => rule.custom(() => 'from level 2 via object'),
+                    name: 'registeredEditor',
+                    type: 'object',
+                    title: 'Registered Editor',
+                    fields: [
+                        {
+                            name: 'editor',
+                            type: 'array',
+                            of: [
+                                {
+                                    type: 'block',
+                                    marks: {
+                                        annotations: [
+                                            {
+                                                name: 'exampleAnnotation',
+                                                type: 'object',
+                                                fields: [{ name: 'value', type: 'string' }],
+                                            },
+                                        ],
+                                    },
+                                },
+                            ],
+                        },
+                    ],
+                },
+                {
+                    name: 'blockTest',
+                    type: 'document',
+                    title: 'blockTest',
+                    fields: [
+                        {
+                            name: 'content',
+                            title: 'Content',
+                            type: 'array',
+                            of: [
+                                {
+                                    type: 'block',
+                                    marks: {
+                                        annotations: [
+                                            {
+                                                name: 'link',
+                                                type: 'object',
+                                                title: 'link',
+                                                fields: [{ name: 'url', type: 'url' }],
+                                                validation: (rule) => rule.custom(linkValidationSpy),
+                                            },
+                                            {
+                                                name: 'internalLink',
+                                                type: 'object',
+                                                title: 'Internal link',
+                                                fields: [{ name: 'reference', type: 'reference', to: [{ type: 'post' }] }],
+                                                validation: (rule) => rule.custom(internalLinkSpy),
+                                            },
+                                            { name: 'nestedEditor', type: 'registeredEditor' },
+                                        ],
+                                    },
+                                },
+                            ],
+                        },
+                    ],
+                },
+            ],
+        });
+        expect(schema._validation).toHaveLength(0);
+        const nestedBlock = {
+            _type: 'block',
+            _key: 'nested-block-key',
+            children: [
+                {
+                    _key: 'some-key',
+                    _type: 'span',
+                    text: 'hey',
+                    marks: ['example-annotation-key'],
                 },
-              ],
+            ],
+            markDefs: [
+                {
+                    _type: 'exampleAnnotation',
+                    _key: 'example-annotation-key',
+                    value: 5,
+                },
+            ],
+            style: 'normal',
+        };
+        const block = {
+            _key: 'block-key',
+            _type: 'block',
+            children: [
+                {
+                    _key: 'child-0',
+                    _type: 'span',
+                    marks: ['0', '1', '2'],
+                    text: 'hey',
+                },
+            ],
+            markDefs: [
+                {
+                    _key: '0',
+                    _type: 'link',
+                    url: 'https://example.com',
+                },
+                {
+                    _key: '1',
+                    _type: 'internalLink',
+                    _ref: 'post-id',
+                },
+                {
+                    _key: '2',
+                    _type: 'nestedEditor',
+                    editor: [nestedBlock],
+                },
+            ],
+            style: 'normal',
+        };
+        const document = {
+            _id: 'mock-id',
+            _type: 'blockTest',
+            _createdAt: '2021-11-15T21:06:41.812Z',
+            _rev: 'example-ref',
+            _updatedAt: '2021-11-15T21:06:41.812Z',
+            content: [block],
+        };
+        const result = await validateItem({
+            client: client,
+            document: document,
+            parent: undefined,
+            path: [],
+            type: schema.get('blockTest'),
+            value: document,
+            getDocumentExists: undefined,
+        });
+        expect(result).toMatchObject([
+            {
+                item: { message: 'mock invalid response', paths: [] },
+                level: 'error',
+                path: ['content', { _key: 'block-key' }, 'markDefs', { _key: '1' }],
             },
+            // this tests for nested markDef validation
             {
-              name: 'level1Array',
-              type: 'array',
-              validation: (rule) => rule.custom(() => 'from level 1 array'),
-              of: [
+                item: {
+                    message: 'Expected type "String", got "Number"',
+                    paths: [],
+                },
+                level: 'error',
+                path: [
+                    'content',
+                    { _key: 'block-key' },
+                    'markDefs',
+                    { _key: '2' },
+                    'editor',
+                    { _key: 'nested-block-key' },
+                    'markDefs',
+                    { _key: 'example-annotation-key' },
+                    'value',
+                ],
+            },
+        ]);
+        expect(linkValidationSpy.mock.calls).toMatchObject([
+            [
+                {
+                    _key: '0',
+                    _type: 'link',
+                    url: 'https://example.com',
+                },
+                {
+                    document: { _id: 'mock-id' },
+                    parent: { _key: 'block-key' },
+                    path: ['content', { _key: 'block-key' }, 'markDefs', { _key: '0' }],
+                    type: { name: 'link' },
+                },
+            ],
+        ]);
+        expect(internalLinkSpy.mock.calls).toMatchObject([
+            [
+                {
+                    _key: '1',
+                    _ref: 'post-id',
+                    _type: 'internalLink',
+                },
                 {
-                  type: 'object',
-                  fields: [
-                    {
-                      name: 'level2Number',
-                      type: 'number',
-                      validation: (rule) => rule.custom(() => 'from level 2 via array'),
-                    },
-                  ],
+                    document: { _id: 'mock-id' },
+                    parent: { _key: 'block-key' },
+                    path: ['content', { _key: 'block-key' }, 'markDefs', { _key: '1' }],
+                    type: { name: 'internalLink' },
                 },
-              ],
+            ],
+        ]);
+    });
+    it('resolves an array item type if there is just one type', async () => {
+        const schema = createSchema({
+            types: [
+                {
+                    name: 'values',
+                    title: 'Values',
+                    type: 'array',
+                    // note that there is only one type available
+                    of: [{ type: 'arrayItem' }],
+                    validation: (rule) => rule.required(),
+                },
+                {
+                    title: 'Array Item',
+                    name: 'arrayItem',
+                    type: 'object',
+                    fields: [{ name: 'title', type: 'string' }],
+                },
+            ],
+        });
+        // ensures there are no schema formatting issues
+        expect(schema._validation).toHaveLength(0);
+        const values = [
+            {
+                // note how this doesn't have a _type
+                title: 5,
+                _key: 'exampleKey',
             },
-          ],
-          validation: (rule) => rule.custom(() => 'from root'),
-        },
-      ],
-    })
-    // ensures there are no schema formatting issues
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    expect(schema._validation).toHaveLength(0)
-    const value = {
-      level1Object: {level3String: 'a string'},
-      level1Array: [{level2Number: 5}],
-    }
-    const document = {
-      value,
-      _type: 'something',
-      _createdAt: '2021-09-05T19:28:30.882Z',
-      _id: 'something.id',
-      _rev: 'exampleRev',
-      _updatedAt: '2021-09-05T19:28:30.882Z',
-    }
-    const getField = ({in: type, name}) => {
-      const result = 'fields' in type && type.fields.find((f) => f.name === name)?.type
-      if (!result) throw new Error(`Could not find field \`${name}\` in \`${type.name}\``)
-      return result
-    }
-    const rootType = schema.get('root')
-    const level1ObjectType = getField({in: rootType, name: 'level1Object'})
-    const level2StringType = getField({in: level1ObjectType, name: 'level2String'})
-    const level1ArrayType = getField({in: rootType, name: 'level1Array'})
-    const level2NumberType = getField({
-      in: level1ArrayType.of[0],
-      name: 'level2Number',
-    })
-    await expect(
-      validateItem({
-        client: client,
-        value,
-        type: rootType,
-        document,
-        parent: document,
-        path: undefined,
-        getDocumentExists: undefined,
-      })
-    ).resolves.toMatchObject([
-      {
-        item: {message: 'from root'},
-        path: [],
-      },
-      {
-        item: {message: 'from level 1 object'},
-        path: ['level1Object'],
-      },
-      {
-        item: {message: 'from level 2 via object'},
-        path: ['level1Object', 'level2String'],
-      },
-      {
-        item: {message: 'from level 1 array'},
-        path: ['level1Array'],
-      },
-      {
-        item: {message: 'from level 2 via array'},
-        path: ['level1Array', 0, 'level2Number'],
-      },
-    ])
-    const calls = convertToValidationMarker.mock.calls
-    expect(calls.find((call) => call[0] === 'from root')).toMatchObject([
-      'from root',
-      'error',
-      {
-        parent: document,
-        document: document,
-        path: [],
-        type: rootType,
-      },
-    ])
-    expect(calls.find((call) => call[0] === 'from level 1 object')).toMatchObject([
-      'from level 1 object',
-      'error',
-      {
-        parent: value,
-        document: document,
-        path: ['level1Object'],
-        type: level1ObjectType,
-      },
-    ])
-    expect(calls.find((call) => call[0] === 'from level 2 via object')).toMatchObject([
-      'from level 2 via object',
-      'error',
-      {
-        parent: value.level1Object,
-        document: document,
-        path: ['level1Object', 'level2String'],
-        type: level2StringType,
-      },
-    ])
-    expect(calls.find((call) => call[0] === 'from level 1 array')).toMatchObject([
-      'from level 1 array',
-      'error',
-      {
-        parent: value,
-        document: document,
-        path: ['level1Array'],
-        type: level1ArrayType,
-      },
-    ])
-    expect(calls.find((call) => call[0] === 'from level 2 via array')).toMatchObject([
-      'from level 2 via array',
-      'error',
-      {
-        parent: value.level1Array[0],
-        document: document,
-        path: ['level1Array', 0, 'level2Number'],
-        type: level2NumberType,
-      },
-    ])
-  })
-  it('runs all nested validation checks concurrently', async () => {
-    const resolvers = new Set()
-    const customValidationFn = () => new Promise((resolve) => resolvers.add(resolve))
-    const schema = createSchema({
-      types: [
-        {
-          name: 'root',
-          type: 'object',
-          fields: [
+        ];
+        await expect(validateItem({
+            client: client,
+            document: undefined,
+            parent: undefined,
+            path: [],
+            type: schema.get('values'),
+            value: values,
+            getDocumentExists: undefined,
+        })).resolves.toEqual([
             {
-              name: 'level1Object',
-              type: 'object',
-              validation: (rule) => [
-                rule.custom(customValidationFn),
-                rule.fields({
-                  level2String: (r) => r.custom(customValidationFn),
-                }),
-              ],
-              fields: [
+                level: 'error',
+                item: {
+                    message: 'Expected type "String", got "Number"',
+                    paths: [],
+                },
+                path: [{ _key: 'exampleKey' }, 'title'],
+            },
+        ]);
+    });
+    it('properly passes the nested value, type, and path to rule.validate', async () => {
+        const schema = createSchema({
+            types: [
                 {
-                  name: 'level2String',
-                  type: 'string',
-                  validation: (rule) => rule.custom(customValidationFn),
+                    name: 'root',
+                    type: 'object',
+                    title: 'Root',
+                    fields: [
+                        {
+                            name: 'level1Object',
+                            type: 'object',
+                            validation: (rule) => rule.custom(() => 'from level 1 object'),
+                            fields: [
+                                {
+                                    name: 'level2String',
+                                    type: 'string',
+                                    validation: (rule) => rule.custom(() => 'from level 2 via object'),
+                                },
+                            ],
+                        },
+                        {
+                            name: 'level1Array',
+                            type: 'array',
+                            validation: (rule) => rule.custom(() => 'from level 1 array'),
+                            of: [
+                                {
+                                    type: 'object',
+                                    fields: [
+                                        {
+                                            name: 'level2Number',
+                                            type: 'number',
+                                            validation: (rule) => rule.custom(() => 'from level 2 via array'),
+                                        },
+                                    ],
+                                },
+                            ],
+                        },
+                    ],
+                    validation: (rule) => rule.custom(() => 'from root'),
                 },
-              ],
+            ],
+        });
+        // ensures there are no schema formatting issues
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        expect(schema._validation).toHaveLength(0);
+        const value = {
+            level1Object: { level3String: 'a string' },
+            level1Array: [{ level2Number: 5 }],
+        };
+        const document = {
+            value,
+            _type: 'something',
+            _createdAt: '2021-09-05T19:28:30.882Z',
+            _id: 'something.id',
+            _rev: 'exampleRev',
+            _updatedAt: '2021-09-05T19:28:30.882Z',
+        };
+        const getField = ({ in: type, name }) => {
+            const result = 'fields' in type && type.fields.find((f) => f.name === name)?.type;
+            if (!result)
+                throw new Error(`Could not find field \`${name}\` in \`${type.name}\``);
+            return result;
+        };
+        const rootType = schema.get('root');
+        const level1ObjectType = getField({ in: rootType, name: 'level1Object' });
+        const level2StringType = getField({ in: level1ObjectType, name: 'level2String' });
+        const level1ArrayType = getField({ in: rootType, name: 'level1Array' });
+        const level2NumberType = getField({
+            in: level1ArrayType.of[0],
+            name: 'level2Number',
+        });
+        await expect(validateItem({
+            client: client,
+            value,
+            type: rootType,
+            document,
+            parent: document,
+            path: undefined,
+            getDocumentExists: undefined,
+        })).resolves.toMatchObject([
+            {
+                item: { message: 'from root' },
+                path: [],
+            },
+            {
+                item: { message: 'from level 1 object' },
+                path: ['level1Object'],
+            },
+            {
+                item: { message: 'from level 2 via object' },
+                path: ['level1Object', 'level2String'],
             },
             {
-              name: 'level1Array',
-              type: 'array',
-              validation: (rule) => rule.custom(customValidationFn),
-              of: [
+                item: { message: 'from level 1 array' },
+                path: ['level1Array'],
+            },
+            {
+                item: { message: 'from level 2 via array' },
+                path: ['level1Array', 0, 'level2Number'],
+            },
+        ]);
+        const calls = convertToValidationMarker.mock.calls;
+        expect(calls.find((call) => call[0] === 'from root')).toMatchObject([
+            'from root',
+            'error',
+            {
+                parent: document,
+                document: document,
+                path: [],
+                type: rootType,
+            },
+        ]);
+        expect(calls.find((call) => call[0] === 'from level 1 object')).toMatchObject([
+            'from level 1 object',
+            'error',
+            {
+                parent: value,
+                document: document,
+                path: ['level1Object'],
+                type: level1ObjectType,
+            },
+        ]);
+        expect(calls.find((call) => call[0] === 'from level 2 via object')).toMatchObject([
+            'from level 2 via object',
+            'error',
+            {
+                parent: value.level1Object,
+                document: document,
+                path: ['level1Object', 'level2String'],
+                type: level2StringType,
+            },
+        ]);
+        expect(calls.find((call) => call[0] === 'from level 1 array')).toMatchObject([
+            'from level 1 array',
+            'error',
+            {
+                parent: value,
+                document: document,
+                path: ['level1Array'],
+                type: level1ArrayType,
+            },
+        ]);
+        expect(calls.find((call) => call[0] === 'from level 2 via array')).toMatchObject([
+            'from level 2 via array',
+            'error',
+            {
+                parent: value.level1Array[0],
+                document: document,
+                path: ['level1Array', 0, 'level2Number'],
+                type: level2NumberType,
+            },
+        ]);
+    });
+    it('runs all nested validation checks concurrently', async () => {
+        const resolvers = new Set();
+        const customValidationFn = () => new Promise((resolve) => resolvers.add(resolve));
+        const schema = createSchema({
+            types: [
                 {
-                  type: 'object',
-                  fields: [
-                    {
-                      name: 'level2Number',
-                      type: 'number',
-                      validation: (rule) => rule.custom(customValidationFn),
-                    },
-                  ],
+                    name: 'root',
+                    type: 'object',
+                    fields: [
+                        {
+                            name: 'level1Object',
+                            type: 'object',
+                            validation: (rule) => [
+                                rule.custom(customValidationFn),
+                                rule.fields({
+                                    level2String: (r) => r.custom(customValidationFn),
+                                }),
+                            ],
+                            fields: [
+                                {
+                                    name: 'level2String',
+                                    type: 'string',
+                                    validation: (rule) => rule.custom(customValidationFn),
+                                },
+                            ],
+                        },
+                        {
+                            name: 'level1Array',
+                            type: 'array',
+                            validation: (rule) => rule.custom(customValidationFn),
+                            of: [
+                                {
+                                    type: 'object',
+                                    fields: [
+                                        {
+                                            name: 'level2Number',
+                                            type: 'number',
+                                            validation: (rule) => rule.custom(customValidationFn),
+                                        },
+                                    ],
+                                },
+                            ],
+                        },
+                    ],
+                    validation: (rule) => rule.custom(customValidationFn),
                 },
-              ],
-            },
-          ],
-          validation: (rule) => rule.custom(customValidationFn),
-        },
-      ],
-    })
-    const value = {
-      level1Object: {level3String: 'a string'},
-      level1Array: [{level2Number: 5}],
-    }
-    const resultPromise = validateItem({
-      client: client,
-      value,
-      document: undefined,
-      parent: undefined,
-      path: undefined,
-      type: schema.get('root'),
-      getDocumentExists: undefined,
-    })
-    // after `validateItem(...)` has been initiated, all of the custom
-    // validation calls should have fired so the resolver size should equal the
-    // amount of total fields
-    expect(resolvers.size).toBe(6)
-    for (const resolver of resolvers) {
-      resolver(true)
-    }
-    await resultPromise
-  })
-})
-//# sourceMappingURL=validateDocument.test.js.map
+            ],
+        });
+        const value = {
+            level1Object: { level3String: 'a string' },
+            level1Array: [{ level2Number: 5 }],
+        };
+        const resultPromise = validateItem({
+            client: client,
+            value,
+            document: undefined,
+            parent: undefined,
+            path: undefined,
+            type: schema.get('root'),
+            getDocumentExists: undefined,
+        });
+        // after `validateItem(...)` has been initiated, all of the custom
+        // validation calls should have fired so the resolver size should equal the
+        // amount of total fields
+        expect(resolvers.size).toBe(6);
+        for (const resolver of resolvers) {
+            resolver(true);
+        }
+        await resultPromise;
+    });
+});
+//# sourceMappingURL=validateDocument.test.js.map