@sanity/validation 2.33.4-shopify.8 → 2.34.1-canary.0

package/src/validateDocument.test.ts

@@ -687,81 +687,4 @@ describe('validateItem', () => {
       },
     ])
   })
-
-  it('runs all nested validation checks concurrently', async () => {
-    type Resolver = (value: true) => void
-    const resolvers = new Set<Resolver>()
-    const customValidationFn = () => new Promise<true>((resolve) => resolvers.add(resolve))
-
-    const schema: Schema = createSchema({
-      types: [
-        {
-          name: 'root',
-          type: 'object',
-          fields: [
-            {
-              name: 'level1Object',
-              type: 'object',
-              validation: (rule: Rule) => [
-                rule.custom(customValidationFn),
-                rule.fields({
-                  level2String: (r) => r.custom(customValidationFn),
-                }),
-              ],
-              fields: [
-                {
-                  name: 'level2String',
-                  type: 'string',
-                  validation: (rule: Rule) => rule.custom(customValidationFn),
-                },
-              ],
-            },
-            {
-              name: 'level1Array',
-              type: 'array',
-              validation: (rule: Rule) => rule.custom(customValidationFn),
-              of: [
-                {
-                  type: 'object',
-                  fields: [
-                    {
-                      name: 'level2Number',
-                      type: 'number',
-                      validation: (rule: Rule) => rule.custom(customValidationFn),
-                    },
-                  ],
-                },
-              ],
-            },
-          ],
-          validation: (rule: Rule) => rule.custom(customValidationFn),
-        },
-      ],
-    })
-
-    const value = {
-      level1Object: {level3String: 'a string'},
-      level1Array: [{level2Number: 5}],
-    }
-
-    const resultPromise = validateItem({
-      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
-  })
 })

package/src/validateDocument.ts

@@ -1,17 +1,20 @@
 import {
+  isBlock,
+  isBlockSchemaType,
+  isKeyedObject,
+  isSpanSchemaType,
+  isTypedObject,
   SanityDocument,
   Schema,
   SchemaType,
   ValidationContext,
   ValidationMarker,
-  isKeyedObject,
-  isTypedObject,
-  isBlock,
-  isBlockSchemaType,
-  isSpanSchemaType,
 } from '@sanity/types'
-import {uniqBy} from 'lodash'
+import {concat, defer, merge, Observable, of} from 'rxjs'
+import {catchError, map, mergeAll, mergeMap, toArray} from 'rxjs/operators'
+import {flatten, uniqBy} from 'lodash'
 import typeString from './util/typeString'
+import {requestIdleCallback, cancelIdleCallback} from './util/requestIdleCallback'
 import ValidationErrorClass from './ValidationError'
 import normalizeValidationRules from './util/normalizeValidationRules'
 
@@ -45,38 +48,47 @@ export function resolveTypeForArrayItem(
     candidates.find((candidate) => candidate.name === 'object' && primitive === 'object')
   )
 }
+const EMPTY_MARKERS: ValidationMarker[] = []
 
-export default async function validateDocument(
+export default function validateDocument(
   doc: SanityDocument,
   schema: Schema,
   context?: Pick<ValidationContext, 'getDocumentExists'>
 ): Promise<ValidationMarker[]> {
+  return validateDocumentObservable(doc, schema, context).toPromise()
+}
+
+export function validateDocumentObservable(
+  doc: SanityDocument,
+  schema: Schema,
+  context?: Pick<ValidationContext, 'getDocumentExists'>
+): Observable<ValidationMarker[]> {
   const documentType = schema.get(doc._type)
   if (!documentType) {
     console.warn('Schema type for object type "%s" not found, skipping validation', doc._type)
-    return []
+    return of(EMPTY_MARKERS)
   }
 
-  try {
-    return await validateItem({
-      parent: undefined,
-      value: doc,
-      path: [],
-      document: doc,
-      type: documentType,
-      getDocumentExists: context?.getDocumentExists,
+  return validateItemObservable({
+    parent: undefined,
+    value: doc,
+    path: [],
+    document: doc,
+    type: documentType,
+    getDocumentExists: context?.getDocumentExists,
+  }).pipe(
+    catchError((err) => {
+      console.error(err)
+      return of([
+        {
+          type: 'validation' as const,
+          level: 'error' as const,
+          path: [],
+          item: new ValidationErrorClass(err?.message),
+        },
+      ])
     })
-  } catch (err) {
-    console.error(err)
-    return [
-      {
-        type: 'validation',
-        level: 'error',
-        path: [],
-        item: new ValidationErrorClass(err?.message),
-      },
-    ]
-  }
+  )
 }
 
 /**
@@ -94,27 +106,32 @@ type ValidateItemOptions = {
   value: unknown
 } & ExplicitUndefined<ValidationContext>
 
-export async function validateItem({
+export function validateItem(opts: ValidateItemOptions): Promise<ValidationMarker[]> {
+  return validateItemObservable(opts).toPromise()
+}
+
+function validateItemObservable({
   value,
   type,
   path = [],
   parent,
   ...restOfContext
-}: ValidateItemOptions): Promise<ValidationMarker[]> {
+}: ValidateItemOptions): Observable<ValidationMarker[]> {
   const rules = normalizeValidationRules(type)
-
   // run validation for the current value
   const selfChecks = rules.map((rule) =>
-    rule.validate(value, {
-      ...restOfContext,
-      parent,
-      path,
-      type,
-    })
+    defer(() =>
+      rule.validate(value, {
+        ...restOfContext,
+        parent,
+        path,
+        type,
+      })
+    )
   )
 
   // run validation for nested values (conditionally)
-  let nestedChecks: Array<Promise<ValidationMarker[]>> = []
+  let fieldChecks: Array<Observable<ValidationMarker[]>> = []
 
   const selfIsRequired = rules.some((rule) => rule.isRequired())
   const shouldRunNestedObjectValidation =
@@ -132,7 +149,7 @@ export async function validateItem({
     }, {})
 
     // Validation for rules set at the object level with `Rule.fields({/* ... */})`
-    nestedChecks = nestedChecks.concat(
+    fieldChecks = fieldChecks.concat(
       rules
         .map((rule) => rule._fieldRules)
         .filter(isNonNullable)
@@ -141,20 +158,22 @@ export async function validateItem({
           const fieldType = fieldTypes[name]
           return normalizeValidationRules({...fieldType, validation}).map((subRule) => {
             const nestedValue = isRecord(value) ? value[name] : undefined
-            return subRule.validate(nestedValue, {
-              ...restOfContext,
-              parent: value,
-              path: path.concat(name),
-              type: fieldType,
-            })
+            return defer(() =>
+              subRule.validate(nestedValue, {
+                ...restOfContext,
+                parent: value,
+                path: path.concat(name),
+                type: fieldType,
+              })
+            )
           })
         })
     )
 
     // Validation from each field's schema `validation: Rule => {/* ... */}` function
-    nestedChecks = nestedChecks.concat(
+    fieldChecks = fieldChecks.concat(
       type.fields.map((field) =>
-        validateItem({
+        validateItemObservable({
           ...restOfContext,
           parent: value,
           value: isRecord(value) ? value[field.name] : undefined,
@@ -172,9 +191,9 @@ export async function validateItem({
   const shouldRunNestedValidationForArrays = type?.jsonType === 'array' && Array.isArray(value)
 
   if (shouldRunNestedValidationForArrays) {
-    nestedChecks = nestedChecks.concat(
+    fieldChecks = fieldChecks.concat(
       value.map((item) =>
-        validateItem({
+        validateItemObservable({
           ...restOfContext,
           parent: value,
           value: item,
@@ -195,16 +214,16 @@ export async function validateItem({
     const spanType = spanChildrenField.type.of.find(isSpanSchemaType)
 
     const annotations = (spanType?.annotations || []).reduce<Map<string, SchemaType>>(
-      (map, annotationType) => {
-        map.set(annotationType.name, annotationType)
-        return map
+      (acc, annotationType) => {
+        acc.set(annotationType.name, annotationType)
+        return acc
       },
       new Map()
     )
 
-    nestedChecks = nestedChecks.concat(
+    fieldChecks = fieldChecks.concat(
       value.markDefs.map((markDef) =>
-        validateItem({
+        validateItemObservable({
           ...restOfContext,
           parent: value,
           value: markDef,
@@ -215,13 +234,31 @@ export async function validateItem({
     )
   }
 
-  const results = (await Promise.all([...selfChecks, ...nestedChecks])).flat()
+  return defer(() => merge([...selfChecks, ...fieldChecks])).pipe(
+    mergeMap((validateNode) => concat(idle(), validateNode), 40),
+    mergeAll(),
+    toArray(),
+    map(flatten),
+    map((results) => {
+      // 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))
+      }
+      return results
+    })
+  )
+}
 
-  // 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))
-  }
+function idle(timeout?: number): Observable<never> {
+  return new Observable<never>((observer) => {
+    const handle = requestIdleCallback(
+      () => {
+        observer.complete()
+      },
+      timeout ? {timeout} : undefined
+    )
 
-  return results
+    return () => cancelIdleCallback(handle)
+  })
 }