feat: context available to initialValue function and added schema to …

…validation context

Initial value context contains client, schema, currentUser, projectId and dataset.
Validation context now also contains schema (alongside client and others).

.gitignore

@@ -56,3 +56,7 @@ tsconfig.tsbuildinfo
 
 # Sanity temp folders
 .sanity
+
+#IntelliJ
+.idea
+*.iml

dev/test-studio/sanity.config.ts

@@ -5,13 +5,11 @@ import {createConfig, createPlugin} from 'sanity'
 import {deskTool} from 'sanity/desk'
 import {imageAssetSource} from './assetSources'
 import {Branding} from './components/Branding'
-import {CustomMarkers} from './components/formBuilder/CustomMarkers'
-import {Markers} from './components/formBuilder/Markers'
 import {resolveDocumentActions as documentActions} from './documentActions'
 import {resolveInitialValueTemplates} from './initialValueTemplates'
 import {languageFilter} from './plugins/language-filter'
 import {schemaTypes} from './schema'
-import {defaultDocumentNode, structure, newDocumentOptions} from './structure'
+import {defaultDocumentNode, newDocumentOptions, structure} from './structure'
 import {workshopTool} from './workshop'
 
 const sharedSettings = createPlugin({

dev/test-studio/schema/docs/v3/async-functions/schemaType.ts

@@ -0,0 +1,144 @@
+import {ConfigContext, defineField, defineType} from 'sanity'
+import {structureGroupOptions} from '../../../../structure/groupByOption'
+
+export const validationTest = defineType({
+  type: 'document',
+  name: 'v3-validation',
+  title: 'v3 validation',
+  options: structureGroupOptions({
+    structureGroup: 'v3',
+  }),
+  fields: [
+    defineField({
+      type: 'string',
+      name: 'title',
+      title: 'Title',
+      validation: (Rule) =>
+        Rule.custom(
+          async (value, context) =>
+            new Promise((resolve) => {
+              setTimeout(() => {
+                // eslint-disable-next-line no-console
+                console.log('Context in custom validation function', context)
+                resolve(
+                  `Always async error for. From context client->projectId: ${
+                    context.client.config().projectId
+                  }`
+                )
+              }, 1000)
+            })
+        ),
+      initialValue: async (params: undefined, context: ConfigContext) => {
+        return new Promise((resolve) => {
+          setTimeout(() => {
+            // eslint-disable-next-line no-console
+            console.log('Context in delayed initial value function, string', context)
+            resolve(context.projectId)
+          }, 1000)
+        })
+      },
+    }),
+    {
+      type: 'array',
+      name: 'testArray',
+      title: 'Test array',
+      of: [
+        {
+          type: 'object',
+          fields: [
+            {
+              type: 'string',
+              name: 'title',
+              title: 'Title',
+            },
+          ],
+          initialValue: async (params: undefined, context: ConfigContext) => {
+            return new Promise((resolve) => {
+              setTimeout(() => {
+                // eslint-disable-next-line no-console
+                console.log('Context in delayed initial value function, array object', context)
+                resolve({
+                  title: context.projectId,
+                })
+              }, 1000)
+            })
+          },
+        },
+      ],
+      initialValue: async (params: undefined, context: ConfigContext) => {
+        return new Promise((resolve) => {
+          setTimeout(() => {
+            // eslint-disable-next-line no-console
+            console.log('Context in delayed initial value function, array', context)
+            resolve([
+              {
+                _key: `${Math.random()}`,
+                title: context.projectId,
+              },
+            ])
+          }, 1000)
+        })
+      },
+    },
+    {
+      title: 'Block',
+      name: 'blockText',
+      type: 'array',
+      of: [
+        {type: 'block'},
+        {
+          type: 'object',
+          name: 'testObject',
+          fields: [
+            {
+              type: 'string',
+              name: 'title',
+              title: 'Title',
+            },
+          ],
+          initialValue: async (params: undefined, context: ConfigContext) => {
+            return new Promise((resolve) => {
+              setTimeout(() => {
+                // eslint-disable-next-line no-console
+                console.log(
+                  'Context in delayed initial value function, block array object',
+                  context
+                )
+                resolve({
+                  _type: 'testObject',
+                  title: context.projectId,
+                })
+              }, 1000)
+            })
+          },
+        },
+      ],
+      initialValue: async (params: undefined, context: ConfigContext) => {
+        return new Promise((resolve) => {
+          setTimeout(() => {
+            // eslint-disable-next-line no-console
+            console.log('Context in delayed initial value function, block array', context)
+            resolve([
+              {
+                style: 'normal',
+                _type: 'block',
+                markDefs: [],
+                children: [
+                  {
+                    _type: 'span',
+                    text: context.projectId,
+                    marks: [],
+                  },
+                ],
+              },
+              {
+                _type: 'testObject',
+                title: context.projectId,
+              },
+            ])
+          }, 1000)
+        })
+      },
+    },
+  ],
+})

dev/test-studio/schema/docs/v3/example1/schemaType.ts

@@ -1,10 +1,13 @@
+import {structureGroupOptions} from '../../../../structure/groupByOption'
 import {CodeInput} from './CodeInput'
 
 export const example1SchemaType = {
   type: 'document',
   name: 'v3-example1',
   title: 'v3 example #1',
-
+  options: structureGroupOptions({
+    structureGroup: 'v3',
+  }),
   fields: [
     {
       type: 'string',

dev/test-studio/schema/docs/v3/index.ts

@@ -1,5 +1,6 @@
 import {example1SchemaType} from './example1'
+import {validationTest} from './async-functions/schemaType'
 
 export const v3docs = {
-  types: [example1SchemaType],
+  types: [example1SchemaType, validationTest],
 }

dev/test-studio/structure/groupByOption.ts

@@ -0,0 +1,30 @@
+import type {StructureBuilder} from 'sanity/desk'
+import {Schema} from '@sanity/types'
+
+type StructureGroup = 'v3' // extend with union strings
+
+export interface StructureGroupOption {
+  structureGroup?: StructureGroup
+}
+
+type MaybeStructureOptions = StructureGroupOption | undefined
+
+export function typesInOptionGroup(
+  S: StructureBuilder,
+  schema: Schema,
+  groupName: StructureGroup
+): string[] {
+  return S.documentTypeListItems()
+    .map((item) => item.getId())
+    .filter((id): id is string => {
+      return (
+        !!id && (schema.get(id)?.options as MaybeStructureOptions)?.structureGroup === groupName
+      )
+    })
+}
+
+export function structureGroupOptions<
+  O extends Required<StructureGroupOption> & Schema.ObjectOptions
+>(options: O): O & Schema.ObjectOptions {
+  return options
+}

dev/test-studio/structure/resolveStructure.ts

@@ -8,7 +8,7 @@ import {
   UsersIcon,
 } from '@sanity/icons'
 import {uuid} from '@sanity/uuid'
-import {StructureResolver} from 'sanity/desk'
+import {StructureBuilder, StructureResolver} from 'sanity/desk'
 import {DebugPane} from '../components/panes/debug'
 import {JsonDocumentDump} from '../components/panes/JsonDocumentDump'
 import {_buildTypeGroup} from './_buildTypeGroup'
@@ -22,6 +22,8 @@ import {
   STANDARD_PORTABLE_TEXT_INPUT_TYPES,
 } from './constants'
 import {delayValue} from './_helpers'
+import {Schema} from '@sanity/types'
+import {typesInOptionGroup} from './groupByOption'
 
 export const structure: StructureResolver = (S, {schema}) => {
   return S.list()
@@ -336,6 +338,14 @@ export const structure: StructureResolver = (S, {schema}) => {
 
       S.divider(),
 
+      _buildTypeGroup(S, schema, {
+        id: 'v3',
+        title: 'V3 APIs',
+        types: typesInOptionGroup(S, schema, 'v3'),
+      }),
+
+      S.divider(),
+
       ...S.documentTypeListItems().filter((listItem) => {
         const id = listItem.getId()
 

packages/@sanity/types/src/schema/types.ts

@@ -1,5 +1,6 @@
 // Note: INCOMPLETE, but it's a start
 import type {ComponentType} from 'react'
+import {SanityClient} from '@sanity/client'
 import type {Rule} from '../validation'
 import type {ReferenceOptions} from '../reference'
 import type {AssetSource} from '../assets'
@@ -123,7 +124,7 @@ export namespace Schema {
       preview?: React.ComponentType<any> // @todo: use `PreviewProps` here
     }
     // TODO
-    initialValue?: any
+    initialValue?: InitialValueProperty<any, any>
   }
 
   export type TypeOptions<T extends Type> = T extends 'array'
@@ -450,7 +451,18 @@ export interface ConditionalPropertyCallbackContext {
 export type ConditionalPropertyCallback = (context: ConditionalPropertyCallbackContext) => boolean
 export type ConditionalProperty = boolean | ConditionalPropertyCallback | undefined
 
-export type InitialValueResolver<Params, Value> = (params?: Params) => Promise<Value> | Value
+export interface InitialValueResolverContext {
+  projectId: string
+  dataset: string
+  schema: Schema
+  currentUser: CurrentUser | null
+  client: SanityClient
+}
+
+export type InitialValueResolver<Params, Value> = (
+  params: Params | undefined,
+  context: InitialValueResolverContext
+) => Promise<Value> | Value
 export type InitialValueProperty<Params, Value> =
   | Value
   | InitialValueResolver<Params, Value>

packages/@sanity/types/src/validation/types.ts

@@ -4,6 +4,7 @@ import type {SchemaType, SchemaValidationValue} from '../schema'
 import type {SanityDocument} from '../documents'
 import type {ValidationMarker} from '../markers'
 import type {Block} from '../portableText'
+import {Schema} from '../schema'
 
 export type RuleTypeConstraint = 'Array' | 'Boolean' | 'Date' | 'Number' | 'Object' | 'String'
 export type FieldRules = {[fieldKey: string]: SchemaValidationValue}
@@ -215,6 +216,7 @@ export type RuleSpecConstraint<T extends RuleSpec['flag']> = ConditionalIndexAcc
  */
 export type ValidationContext = {
   client: SanityClient
+  schema: Schema
   parent?: unknown
   type?: SchemaType
   document?: SanityDocument

packages/@sanity/validation/src/validateDocument.test.ts

@@ -168,6 +168,7 @@ describe('validateItem', () => {
     await expect(
       validateItem({
         client: client as any,
+        schema,
         value: {},
         document: undefined,
         path: [],
@@ -237,6 +238,7 @@ describe('validateItem', () => {
     await expect(
       validateItem({
         client: client as any,
+        schema,
         document: undefined,
         parent: undefined,
         path: undefined,
@@ -403,6 +405,7 @@ describe('validateItem', () => {
 
     const result = await validateItem({
       client: client as any,
+      schema,
       document: document,
       parent: undefined,
       path: [],
@@ -505,6 +508,7 @@ describe('validateItem', () => {
     await expect(
       validateItem({
         client: client as any,
+        schema,
         document: undefined,
         parent: undefined,
         path: [],
@@ -603,6 +607,7 @@ describe('validateItem', () => {
     await expect(
       validateItem({
         client: client as any,
+        schema,
         value,
         type: rootType,
         document,
@@ -745,6 +750,7 @@ describe('validateItem', () => {
 
     const resultPromise = validateItem({
       client: client as any,
+      schema,
       value,
       document: undefined,
       parent: undefined,

packages/@sanity/validation/src/validateDocument.ts

@@ -62,6 +62,7 @@ export default async function validateDocument(
   try {
     return await validateItem({
       client,
+      schema,
       parent: undefined,
       value: doc,
       path: [],

packages/@sanity/validation/test/infer.test.ts

@@ -304,7 +304,9 @@ describe('schema validation inference', () => {
 
 async function expectNoError(validations: Rule[], value: unknown) {
   const errors = (
-    await Promise.all(validations.map((rule) => rule.validate(value, {client: {} as any})))
+    await Promise.all(
+      validations.map((rule) => rule.validate(value, {client: {} as any, schema: {} as any}))
+    )
   ).flat()
   if (errors.length === 0) {
     // This shouldn't actually be needed, but counts against an assertion in jest-terms
@@ -323,7 +325,9 @@ async function expectError(
   level = 'error'
 ) {
   const errors = (
-    await Promise.all(validations.map((rule) => rule.validate(value, {client: {} as any})))
+    await Promise.all(
+      validations.map((rule) => rule.validate(value, {client: {} as any, schema: {} as any}))
+    )
   ).flat()
   if (!errors.length) {
     throw new Error(`Expected error matching "${message}", but no errors were returned.`)