@sanity/validation 2.21.12-shopify.7 → 2.22.3-reference-updates.78

package/dist/dts/Rule.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Rule.d.ts","sourceRoot":"","sources":["../../src/Rule.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,SAAS,EAUV,MAAM,eAAe,CAAA;AA0DtB,QAAA,MAAM,IAAI,EAAE,SAwVX,CAAA;AAED,eAAe,IAAI,CAAA"}
+{"version":3,"file":"Rule.d.ts","sourceRoot":"","sources":["../../src/Rule.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,SAAS,EAUV,MAAM,eAAe,CAAA;AA0DtB,QAAA,MAAM,IAAI,EAAE,SA2VX,CAAA;AAED,eAAe,IAAI,CAAA"}

package/dist/dts/util/normalizeValidationRules.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"normalizeValidationRules.d.ts","sourceRoot":"","sources":["../../../src/util/normalizeValidationRules.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAE,IAAI,EAAqB,MAAM,eAAe,CAAA;AA+ElE;;GAEG;AACH,MAAM,CAAC,OAAO,UAAU,wBAAwB,CAAC,OAAO,EAAE,UAAU,GAAG,SAAS,GAAG,IAAI,EAAE,CAqCxF"}
+{"version":3,"file":"normalizeValidationRules.d.ts","sourceRoot":"","sources":["../../../src/util/normalizeValidationRules.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAE,IAAI,EAAqB,MAAM,eAAe,CAAA;AA6ElE;;GAEG;AACH,MAAM,CAAC,OAAO,UAAU,wBAAwB,CAAC,OAAO,EAAE,UAAU,GAAG,SAAS,GAAG,IAAI,EAAE,CAqCxF"}

package/dist/dts/validateDocument.d.ts

@@ -3,7 +3,7 @@ import { SanityDocument, Schema, SchemaType, ValidationContext, ValidationMarker
  * @internal
  */
 export declare function resolveTypeForArrayItem(item: unknown, candidates: SchemaType[]): SchemaType | undefined;
-export default function validateDocument(doc: SanityDocument, schema: Schema): Promise<ValidationMarker[]>;
+export default function validateDocument(doc: SanityDocument, schema: Schema, context?: Pick<ValidationContext, 'getDocumentExists'>): Promise<ValidationMarker[]>;
 /**
  * this is used make optional properties required by replacing optionals with
  * `T[P] | undefined`. this is used to prevent errors in `validateItem` where

package/dist/dts/validateDocument.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validateDocument.d.ts","sourceRoot":"","sources":["../../src/validateDocument.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,MAAM,EACN,UAAU,EACV,iBAAiB,EACjB,gBAAgB,EAGjB,MAAM,eAAe,CAAA;AAYtB;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,OAAO,EACb,UAAU,EAAE,UAAU,EAAE,GACvB,UAAU,GAAG,SAAS,CAiBxB;AAED,wBAA8B,gBAAgB,CAC5C,GAAG,EAAE,cAAc,EACnB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,gBAAgB,EAAE,CAAC,CA0B7B;AAED;;;;;;GAMG;AACH,aAAK,iBAAiB,CAAC,CAAC,IAAI;KACzB,CAAC,IAAI,MAAM,QAAQ,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,SAAS;CAC5F,CAAA;AAED,aAAK,mBAAmB,GAAG;IACzB,KAAK,EAAE,OAAO,CAAA;CACf,GAAG,iBAAiB,CAAC,iBAAiB,CAAC,CAAA;AAExC,wBAAsB,YAAY,CAAC,EACjC,KAAK,EACL,IAAI,EACJ,IAAS,EACT,MAAM,EACN,GAAG,aAAa,EACjB,EAAE,mBAAmB,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CA8FnD"}
+{"version":3,"file":"validateDocument.d.ts","sourceRoot":"","sources":["../../src/validateDocument.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,MAAM,EACN,UAAU,EACV,iBAAiB,EACjB,gBAAgB,EAMjB,MAAM,eAAe,CAAA;AAYtB;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,OAAO,EACb,UAAU,EAAE,UAAU,EAAE,GACvB,UAAU,GAAG,SAAS,CAiBxB;AAED,wBAA8B,gBAAgB,CAC5C,GAAG,EAAE,cAAc,EACnB,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,IAAI,CAAC,iBAAiB,EAAE,mBAAmB,CAAC,GACrD,OAAO,CAAC,gBAAgB,EAAE,CAAC,CA2B7B;AAED;;;;;;GAMG;AACH,aAAK,iBAAiB,CAAC,CAAC,IAAI;KACzB,CAAC,IAAI,MAAM,QAAQ,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,SAAS;CAC5F,CAAA;AAED,aAAK,mBAAmB,GAAG;IACzB,KAAK,EAAE,OAAO,CAAA;CACf,GAAG,iBAAiB,CAAC,iBAAiB,CAAC,CAAA;AAExC,wBAAsB,YAAY,CAAC,EACjC,KAAK,EACL,IAAI,EACJ,IAAS,EACT,MAAM,EACN,GAAG,aAAa,EACjB,EAAE,mBAAmB,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CA4HnD"}

package/dist/dts/validators/objectValidator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"objectValidator.d.ts","sourceRoot":"","sources":["../../../src/validators/objectValidator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAC,MAAM,eAAe,CAAA;AAKxC,QAAA,MAAM,gBAAgB,EAAE,UA8CvB,CAAA;AAED,eAAe,gBAAgB,CAAA"}
+{"version":3,"file":"objectValidator.d.ts","sourceRoot":"","sources":["../../../src/validators/objectValidator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAc,MAAM,eAAe,CAAA;AAKrD,QAAA,MAAM,gBAAgB,EAAE,UAwDvB,CAAA;AAED,eAAe,gBAAgB,CAAA"}

package/lib/Rule.js

@@ -232,6 +232,17 @@ var Rule = (_temp = _class = class Rule {
       constraint: fn
     }]);
   }
+  /**
+   * @deprecated use `Rule.custom` instead
+   */
+
+
+  block(fn) {
+    return this.cloneWithRules([{
+      flag: 'custom',
+      constraint: fn
+    }]);
+  }
 
   min(len) {
     return this.cloneWithRules([{
@@ -383,13 +394,6 @@ var Rule = (_temp = _class = class Rule {
     }]);
   }
 
-  block(blockValidator) {
-    return this.cloneWithRules([{
-      flag: 'block',
-      constraint: blockValidator
-    }]);
-  }
-
   fields(rules) {
     if (this._type !== 'Object') {
       throw new Error('fields() can only be called on an object type');

package/lib/util/normalizeValidationRules.js

@@ -7,8 +7,6 @@ exports.default = normalizeValidationRules;
 
 var _Rule = _interopRequireDefault(require("../Rule"));
 
-var _blockValidator = require("../validators/blockValidator");
-
 var _slugValidator = require("../validators/slugValidator");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
@@ -61,7 +59,6 @@ function baseRuleReducer(inputRule, type) {
   if (type.name === 'slug') return baseRule.custom(_slugValidator.slugValidator);
   if (type.name === 'reference') return baseRule.reference();
   if (type.name === 'email') return baseRule.email();
-  if (type.name === 'block') return baseRule.block(_blockValidator.blockValidator);
   return baseRule;
 }
 

package/lib/validateDocument.js

@@ -74,7 +74,7 @@ function resolveTypeForArrayItem(item, candidates) {
   }) || candidates.find(candidate => candidate.name === itemType) || candidates.find(candidate => candidate.name === 'object' && primitive === 'object');
 }
 
-function validateDocument(_x, _x2) {
+function validateDocument(_x, _x2, _x3) {
   return _validateDocument.apply(this, arguments);
 }
 /**
@@ -87,7 +87,7 @@ function validateDocument(_x, _x2) {
 
 
 function _validateDocument() {
-  _validateDocument = _asyncToGenerator(function* (doc, schema) {
+  _validateDocument = _asyncToGenerator(function* (doc, schema, context) {
     var documentType = schema.get(doc._type);
 
     if (!documentType) {
@@ -101,7 +101,8 @@ function _validateDocument() {
         value: doc,
         path: [],
         document: doc,
-        type: documentType
+        type: documentType,
+        getDocumentExists: context === null || context === void 0 ? void 0 : context.getDocumentExists
       });
     } catch (err) {
       console.error(err);
@@ -116,7 +117,7 @@ function _validateDocument() {
   return _validateDocument.apply(this, arguments);
 }
 
-function validateItem(_x3) {
+function validateItem(_x4) {
   return _validateItem.apply(this, arguments);
 }
 
@@ -192,9 +193,32 @@ function _validateItem() {
         } : value.indexOf(item)),
         type: resolveTypeForArrayItem(item, type.of)
       }))));
+    } // markDefs also do no run nested validation if the parent object is undefined
+    // for a similar reason to arrays
+
+
+    var shouldRunNestedValidationForMarkDefs = (0, _types.isBlock)(value) && value.markDefs.length && (0, _types.isBlockSchemaType)(type);
+
+    if (shouldRunNestedValidationForMarkDefs) {
+      var _type$fields = _slicedToArray(type.fields, 1),
+          spanChildrenField = _type$fields[0];
+
+      var spanType = spanChildrenField.type.of.find(_types.isSpanSchemaType);
+      var annotations = ((spanType === null || spanType === void 0 ? void 0 : spanType.annotations) || []).reduce((map, annotationType) => {
+        map.set(annotationType.name, annotationType);
+        return map;
+      }, new Map());
+      nestedChecks = nestedChecks.concat(value.markDefs.map(markDef => validateItem(_objectSpread(_objectSpread({}, restOfContext), {}, {
+        parent: value,
+        value: markDef,
+        path: path.concat(['markDefs', {
+          _key: markDef._key
+        }]),
+        type: annotations.get(markDef._type)
+      }))));
     }
 
-    var results = (yield Promise.all([...selfChecks, ...nestedChecks])).flat(); // run `dedupeValidationMarkers` if `_fieldRules` are present because they can
+    var results = (yield Promise.all([...selfChecks, ...nestedChecks])).flat(); // run `uniqBy` if `_fieldRules` are present because they can
     // cause repeat markers
 
     if (rules.some(rule => rule._fieldRules)) {

package/lib/validators/objectValidator.js

@@ -5,6 +5,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
+var _types = require("@sanity/types");
+
 var _genericValidator = _interopRequireDefault(require("./genericValidator"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
@@ -35,33 +37,47 @@ var objectValidators = _objectSpread(_objectSpread({}, _genericValidator.default
 
     return true;
   },
-  reference: (_unused, value, message) => {
-    if (!value) {
-      return true;
-    }
+  reference: function () {
+    var _reference = _asyncToGenerator(function* (_unused, value, message, context) {
+      if (!value) {
+        return true;
+      }
 
-    if (typeof value._ref !== 'string') {
-      return message || 'Must be a reference to a document';
-    }
+      if (!(0, _types.isReference)(value)) {
+        return message || 'Must be a reference to a document';
+      }
 
-    return true;
-  },
-  block: function () {
-    var _block = _asyncToGenerator(function* (validateBlock, value, message, context) {
-      var result = yield validateBlock(value, context);
+      var type = context.type,
+          getDocumentExists = context.getDocumentExists;
 
-      if (typeof result === 'string') {
-        return message || result;
+      if (!type) {
+        throw new Error("`type` was not provided in validation context");
       }
 
-      return result;
+      if ('weak' in type && type.weak) {
+        return true;
+      }
+
+      if (!getDocumentExists) {
+        throw new Error("`getDocumentExists` was not provided in validation context");
+      }
+
+      var exists = yield getDocumentExists({
+        id: value._ref
+      });
+
+      if (!exists) {
+        return 'This reference must be published';
+      }
+
+      return true;
     });
 
-    function block(_x, _x2, _x3, _x4) {
-      return _block.apply(this, arguments);
+    function reference(_x, _x2, _x3, _x4) {
+      return _reference.apply(this, arguments);
     }
 
-    return block;
+    return reference;
   }(),
   assetRequired: (flag, value, message) => {
     if (!value || !value.asset || !value.asset._ref) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/validation",
-  "version": "2.21.12-shopify.7+43c0621a9",
+  "version": "2.22.3-reference-updates.78+f6f3095b1c",
   "description": "Validation and warning infrastructure for Sanity projects",
   "main": "./lib/index.js",
   "types": "./dist/dts",
@@ -32,8 +32,8 @@
     "directory": "packages/@sanity/validation"
   },
   "devDependencies": {
-    "@sanity/client": "2.21.12-shopify.7+43c0621a9",
-    "@sanity/schema": "2.21.12-shopify.7+43c0621a9"
+    "@sanity/client": "2.22.3-reference-updates.78+f6f3095b1c",
+    "@sanity/schema": "2.22.3-reference-updates.78+f6f3095b1c"
   },
   "peerDependencies": {
     "@sanity/client": "^2.0.0"
@@ -44,9 +44,9 @@
     }
   },
   "dependencies": {
-    "@sanity/types": "2.21.12-shopify.7+43c0621a9",
+    "@sanity/types": "2.22.3-reference-updates.78+f6f3095b1c",
     "date-fns": "^2.16.1",
     "lodash": "^4.17.15"
   },
-  "gitHead": "43c0621a981601c64af5fec68da8cda9d4d6d4e7"
+  "gitHead": "f6f3095b1c482db616c36f54320e1d970fecea5a"
 }

package/src/Rule.ts

@@ -4,13 +4,13 @@ import {
   RuleClass,
   CustomValidator,
   RuleSpecConstraint,
-  BlockValidator,
   FieldRules,
   ValidationContext,
   RuleSpec,
   ValidationMarker,
   RuleTypeConstraint,
   Validator,
+  Block,
 } from '@sanity/types'
 import {cloneDeep, get} from 'lodash'
 import ValidationErrorClass from './ValidationError'
@@ -219,6 +219,13 @@ const Rule: RuleClass = class Rule implements IRule {
     return this.cloneWithRules([{flag: 'custom', constraint: fn as CustomValidator}])
   }
 
+  /**
+   * @deprecated use `Rule.custom` instead
+   */
+  block(fn: CustomValidator<Block>): Rule {
+    return this.cloneWithRules([{flag: 'custom', constraint: fn as CustomValidator}])
+  }
+
   min(len: number): Rule {
     return this.cloneWithRules([{flag: 'min', constraint: len}])
   }
@@ -336,10 +343,6 @@ const Rule: RuleClass = class Rule implements IRule {
     return this.cloneWithRules([{flag: 'reference'}])
   }
 
-  block(blockValidator: BlockValidator): Rule {
-    return this.cloneWithRules([{flag: 'block', constraint: blockValidator}])
-  }
-
   fields(rules: FieldRules): Rule {
     if (this._type !== 'Object') {
       throw new Error('fields() can only be called on an object type')

package/src/util/normalizeValidationRules.ts

@@ -1,6 +1,5 @@
 import {SchemaType, Rule, RuleTypeConstraint} from '@sanity/types'
 import RuleClass from '../Rule'
-import {blockValidator} from '../validators/blockValidator'
 import {slugValidator} from '../validators/slugValidator'
 
 const ruleConstraintTypes: {[P in Lowercase<RuleTypeConstraint>]: true} = {
@@ -54,7 +53,6 @@ function baseRuleReducer(inputRule: Rule, type: SchemaType) {
   if (type.name === 'slug') return baseRule.custom(slugValidator)
   if (type.name === 'reference') return baseRule.reference()
   if (type.name === 'email') return baseRule.email()
-  if (type.name === 'block') return baseRule.block(blockValidator)
   return baseRule
 }
 

package/src/validateDocument.test.ts

@@ -1,6 +1,6 @@
 /// <reference types="@sanity/types/parts" />
 
-import {Rule, SchemaType, SanityDocument, Schema, ArraySchemaType} from '@sanity/types'
+import {Rule, SchemaType, SanityDocument, Schema, ArraySchemaType, Block} from '@sanity/types'
 import createSchema from 'part:@sanity/base/schema-creator'
 import validateDocument, {resolveTypeForArrayItem, validateItem} from './validateDocument'
 import convertToValidationMarker from './util/convertToValidationMarker'
@@ -149,14 +149,17 @@ describe('validateItem', () => {
             },
           ],
         },
-        {name: 'registeredString', 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({
@@ -165,6 +168,7 @@ describe('validateItem', () => {
         path: [],
         parent: undefined,
         type: schema.get('testObj'),
+        getDocumentExists: undefined,
       })
     ).resolves.toMatchObject([
       {
@@ -228,6 +232,9 @@ describe('validateItem', () => {
       ],
     })
 
+    // ensures there are no schema formatting issues
+    expect(schema._validation).toHaveLength(0)
+
     await expect(
       validateItem({
         document: undefined,
@@ -235,6 +242,7 @@ describe('validateItem', () => {
         path: undefined,
         type: schema.get('testObj'),
         value: {foo: 5},
+        getDocumentExists: undefined,
       })
     ).resolves.toMatchObject([
       {
@@ -252,17 +260,232 @@ describe('validateItem', () => {
     ])
   })
 
+  it('runs nested validation for markDefs', async () => {
+    const linkValidationSpy = jest.fn(() => true as const)
+    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: [
+                {
+                  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) => rule.custom(linkValidationSpy),
+                      },
+                      {
+                        name: 'internalLink',
+                        type: 'object',
+                        title: 'Internal link',
+                        fields: [{name: 'reference', type: 'reference', to: [{type: 'post'}]}],
+                        validation: (rule: Rule) => rule.custom(internalLinkSpy),
+                      },
+                      {name: 'nestedEditor', type: 'registeredEditor'},
+                    ],
+                  },
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    })
+
+    expect(schema._validation).toHaveLength(0)
+
+    const nestedBlock: Block = {
+      _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: 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: SanityDocument = {
+      _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({
+      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'}],
+        type: 'validation',
+      },
+      // 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',
+        ],
+        type: 'validation',
+      },
+    ])
+
+    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) => rule.required(),
         },
         {
+          title: 'Array Item',
           name: 'arrayItem',
           type: 'object',
           fields: [{name: 'title', type: 'string'}],
@@ -270,6 +493,9 @@ describe('validateItem', () => {
       ],
     })
 
+    // ensures there are no schema formatting issues
+    expect(schema._validation).toHaveLength(0)
+
     const values = [
       {
         // note how this doesn't have a _type
@@ -285,6 +511,7 @@ describe('validateItem', () => {
         path: [],
         type: schema.get('values'),
         value: values,
+        getDocumentExists: undefined,
       })
     ).resolves.toEqual([
       {
@@ -305,6 +532,7 @@ describe('validateItem', () => {
         {
           name: 'root',
           type: 'object',
+          title: 'Root',
           fields: [
             {
               name: 'level1Object',
@@ -341,6 +569,10 @@ describe('validateItem', () => {
       ],
     })
 
+    // ensures there are no schema formatting issues
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    expect((schema as any)._validation).toHaveLength(0)
+
     const value = {
       level1Object: {level3String: 'a string'},
       level1Array: [{level2Number: 5}],
@@ -377,6 +609,7 @@ describe('validateItem', () => {
         document,
         parent: document,
         path: undefined,
+        getDocumentExists: undefined,
       })
     ).resolves.toMatchObject([
       {
@@ -517,6 +750,7 @@ describe('validateItem', () => {
       parent: undefined,
       path: undefined,
       type: schema.get('root'),
+      getDocumentExists: undefined,
     })
 
     // after `validateItem(...)` has been initiated, all of the custom

package/src/validateDocument.ts

@@ -6,6 +6,9 @@ import {
   ValidationMarker,
   isKeyedObject,
   isTypedObject,
+  isBlock,
+  isBlockSchemaType,
+  isSpanSchemaType,
 } from '@sanity/types'
 import {uniqBy} from 'lodash'
 import typeString from './util/typeString'
@@ -45,7 +48,8 @@ export function resolveTypeForArrayItem(
 
 export default async function validateDocument(
   doc: SanityDocument,
-  schema: Schema
+  schema: Schema,
+  context?: Pick<ValidationContext, 'getDocumentExists'>
 ): Promise<ValidationMarker[]> {
   const documentType = schema.get(doc._type)
   if (!documentType) {
@@ -60,6 +64,7 @@ export default async function validateDocument(
       path: [],
       document: doc,
       type: documentType,
+      getDocumentExists: context?.getDocumentExists,
     })
   } catch (err) {
     console.error(err)
@@ -180,9 +185,39 @@ export async function validateItem({
     )
   }
 
+  // markDefs also do no run nested validation if the parent object is undefined
+  // for a similar reason to arrays
+  const shouldRunNestedValidationForMarkDefs =
+    isBlock(value) && value.markDefs.length && isBlockSchemaType(type)
+
+  if (shouldRunNestedValidationForMarkDefs) {
+    const [spanChildrenField] = type.fields
+    const spanType = spanChildrenField.type.of.find(isSpanSchemaType)
+
+    const annotations = (spanType?.annotations || []).reduce<Map<string, SchemaType>>(
+      (map, annotationType) => {
+        map.set(annotationType.name, annotationType)
+        return map
+      },
+      new Map()
+    )
+
+    nestedChecks = nestedChecks.concat(
+      value.markDefs.map((markDef) =>
+        validateItem({
+          ...restOfContext,
+          parent: value,
+          value: markDef,
+          path: path.concat(['markDefs', {_key: markDef._key}]),
+          type: annotations.get(markDef._type),
+        })
+      )
+    )
+  }
+
   const results = (await Promise.all([...selfChecks, ...nestedChecks])).flat()
 
-  // run `dedupeValidationMarkers` if `_fieldRules` are present because they can
+  // run `uniqBy` if `_fieldRules` are present because they can
   // cause repeat markers
   if (rules.some((rule) => rule._fieldRules)) {
     return uniqBy(results, (rule) => JSON.stringify(rule))

package/src/validators/objectValidator.ts

@@ -1,4 +1,4 @@
-import {Validators} from '@sanity/types'
+import {Validators, isReference} from '@sanity/types'
 import genericValidator from './genericValidator'
 
 const metaKeys = ['_key', '_type', '_weak']
@@ -20,25 +20,35 @@ const objectValidators: Validators = {
     return true
   },
 
-  reference: (_unused, value, message) => {
+  reference: async (_unused, value: unknown, message, context) => {
     if (!value) {
       return true
     }
 
-    if (typeof value._ref !== 'string') {
+    if (!isReference(value)) {
       return message || 'Must be a reference to a document'
     }
 
-    return 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
+    }
 
-  block: async (validateBlock, value, message, context) => {
-    const result = await validateBlock(value, context)
-    if (typeof result === 'string') {
-      return message || result
+    if (!getDocumentExists) {
+      throw new Error(`\`getDocumentExists\` was not provided in validation context`)
     }
 
-    return result
+    const exists = await getDocumentExists({id: value._ref})
+    if (!exists) {
+      return 'This reference must be published'
+    }
+
+    return true
   },
 
   assetRequired: (flag, value, message) => {

package/dist/dts/validators/blockValidator.d.ts

@@ -1,3 +0,0 @@
-import { BlockValidator } from '@sanity/types';
-export declare const blockValidator: BlockValidator;
-//# sourceMappingURL=blockValidator.d.ts.map

package/dist/dts/validators/blockValidator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"blockValidator.d.ts","sourceRoot":"","sources":["../../../src/validators/blockValidator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,cAAc,EAAC,MAAM,eAAe,CAAA;AAG9D,eAAO,MAAM,cAAc,EAAE,cAkD5B,CAAA"}

package/lib/validators/blockValidator.js

@@ -1,65 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.blockValidator = void 0;
-
-var _validateDocument = require("../validateDocument");
-
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
-
-function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
-
-var blockValidator = /*#__PURE__*/function () {
-  var _ref = _asyncToGenerator(function* (value, context) {
-    var _type$fields, _type$fields$find;
-
-    if (value.markDefs.length === 0) return [];
-    var type = context.type;
-
-    if (!type) {
-      throw new Error("Schema `type` was not provided in validation context");
-    }
-
-    if (type.jsonType !== 'object') {
-      throw new Error("Expected schema type with jsonType `object` but found `".concat(type.jsonType, "` instead."));
-    }
-
-    var childrenType = (_type$fields = type.fields) === null || _type$fields === void 0 ? void 0 : (_type$fields$find = _type$fields.find(field => field.name === 'children')) === null || _type$fields$find === void 0 ? void 0 : _type$fields$find.type;
-    var spanType = (childrenType === null || childrenType === void 0 ? void 0 : childrenType.jsonType) === 'array' ? childrenType === null || childrenType === void 0 ? void 0 : childrenType.of.find(ofType => ofType.name === 'span') : null; // Validate every markDef (annotation) value
-    // eslint-disable-next-line no-warning-comments
-    // @ts-expect-error TODO (eventually): fix these types
-
-    var activeAnnotationTypes = spanType === null || spanType === void 0 ? void 0 : spanType.annotations.filter(annotation => // eslint-disable-next-line no-warning-comments
-    // @ts-expect-error TODO (eventually): fix these types
-    value.markDefs.map(def => def._type).includes(annotation.name));
-    var annotationValidations = [];
-    value.markDefs.forEach(markDef => {
-      var annotationType = activeAnnotationTypes.find(aType => aType.name === markDef._type);
-      var validations = (0, _validateDocument.validateItem)({
-        document: context.document,
-        value: markDef,
-        type: annotationType,
-        path: (context.path || []).concat(['markDefs', {
-          _key: markDef._key
-        }]),
-        parent: value
-      });
-      annotationValidations.push(validations);
-    });
-    var results = yield Promise.all(annotationValidations);
-    var flattened = results.flat();
-    if (!flattened.length) return [];
-    return flattened.map(res => {
-      res.item.paths = [res.path];
-      return res.item;
-    });
-  });
-
-  return function blockValidator(_x, _x2) {
-    return _ref.apply(this, arguments);
-  };
-}();
-
-exports.blockValidator = blockValidator;

package/src/validators/blockValidator.ts

@@ -1,54 +0,0 @@
-import {ValidationMarker, BlockValidator} from '@sanity/types'
-import {validateItem} from '../validateDocument'
-
-export const blockValidator: BlockValidator = async (value, context) => {
-  if (value.markDefs.length === 0) return []
-
-  const {type} = context
-
-  if (!type) {
-    throw new Error(`Schema \`type\` was not provided in validation context`)
-  }
-  if (type.jsonType !== 'object') {
-    throw new Error(
-      `Expected schema type with jsonType \`object\` but found \`${type.jsonType}\` instead.`
-    )
-  }
-
-  const childrenType = type.fields?.find((field) => field.name === 'children')?.type
-  const spanType =
-    childrenType?.jsonType === 'array'
-      ? childrenType?.of.find((ofType) => ofType.name === 'span')
-      : null
-
-  // Validate every markDef (annotation) value
-  // eslint-disable-next-line no-warning-comments
-  // @ts-expect-error TODO (eventually): fix these types
-  const activeAnnotationTypes: any[] = spanType?.annotations.filter((annotation) =>
-    // eslint-disable-next-line no-warning-comments
-    // @ts-expect-error TODO (eventually): fix these types
-    value.markDefs.map((def) => def._type).includes(annotation.name)
-  )
-  const annotationValidations: Promise<ValidationMarker[]>[] = []
-  value.markDefs.forEach((markDef: any) => {
-    const annotationType = activeAnnotationTypes.find((aType) => aType.name === markDef._type)
-    const validations = validateItem({
-      document: context.document,
-      value: markDef,
-      type: annotationType,
-      path: (context.path || []).concat(['markDefs', {_key: markDef._key}]),
-      parent: value,
-    })
-    annotationValidations.push(validations)
-  })
-
-  const results = await Promise.all(annotationValidations)
-  const flattened = results.flat()
-
-  if (!flattened.length) return []
-
-  return flattened.map((res) => {
-    res.item.paths = [res.path]
-    return res.item
-  })
-}