sanity 3.26.2-canary.52 → 3.26.2-canary.69

package/src/_internal/cli/threads/validateSchema.ts

@@ -0,0 +1,73 @@
+import {isMainThread, parentPort, workerData as _workerData} from 'worker_threads'
+import {type SchemaValidationProblem, type SchemaValidationProblemGroup} from '@sanity/types'
+import {validateSchema, groupProblems} from '@sanity/schema/_internal'
+import {getStudioConfig} from '../util/getStudioWorkspaces'
+import {mockBrowserEnvironment} from '../util/mockBrowserEnvironment'
+import {resolveSchemaTypes} from 'sanity'
+
+export interface ValidateSchemaWorkerData {
+  workDir: string
+  workspace?: string
+  level?: SchemaValidationProblem['severity']
+}
+
+export interface ValidateSchemaWorkerResult {
+  validation: SchemaValidationProblemGroup[]
+}
+
+const {
+  workDir,
+  workspace: workspaceName,
+  level = 'warning',
+} = _workerData as ValidateSchemaWorkerData
+
+if (isMainThread || !parentPort) {
+  throw new Error('This module must be run as a worker thread')
+}
+
+const cleanup = mockBrowserEnvironment(workDir)
+
+try {
+  const workspaces = getStudioConfig({basePath: workDir})
+
+  if (!workspaces.length) {
+    throw new Error(`Configuration did not return any workspaces.`)
+  }
+
+  let workspace
+  if (workspaceName) {
+    workspace = workspaces.find((w) => w.name === workspaceName)
+    if (!workspace) {
+      throw new Error(`Could not find any workspaces with name \`${workspaceName}\``)
+    }
+  } else {
+    if (workspaces.length !== 1) {
+      throw new Error(
+        "Multiple workspaces found. Please specify which workspace to use with '--workspace'.",
+      )
+    }
+    workspace = workspaces[0]
+  }
+
+  const schemaTypes = resolveSchemaTypes({
+    config: workspace,
+    context: {dataset: workspace.dataset, projectId: workspace.projectId},
+  })
+
+  const validation = groupProblems(validateSchema(schemaTypes).getTypes())
+
+  const result: ValidateSchemaWorkerResult = {
+    validation: validation
+      .map((group) => ({
+        ...group,
+        problems: group.problems.filter((problem) =>
+          level === 'error' ? problem.severity === 'error' : true,
+        ),
+      }))
+      .filter((group) => group.problems.length),
+  }
+
+  parentPort?.postMessage(result)
+} finally {
+  cleanup()
+}

package/src/_internal/cli/util/{getStudioConfig.ts → getStudioWorkspaces.ts}

@@ -1,10 +1,9 @@
 /* eslint-disable no-sync */
 import fs from 'fs'
 import path from 'path'
-import {first} from 'rxjs/operators'
 import {firstValueFrom} from 'rxjs'
 import {mockBrowserEnvironment} from './mockBrowserEnvironment'
-import {resolveConfig, Config, Workspace} from 'sanity'
+import {resolveConfig, Config, Workspace, WorkspaceOptions} from 'sanity'
 
 const candidates = [
   'sanity.config.js',
@@ -13,15 +12,18 @@ const candidates = [
   'sanity.config.tsx',
 ]
 
-/**
- * Note: Don't run this on the main thread, use it a forked process
- */
-export async function getStudioConfig(options: {
+interface GetStudioWorkspacesOptions {
   configPath?: string
   basePath: string
-}): Promise<Workspace[]> {
-  const {basePath, configPath: cfgPath} = options
+}
 
+/**
+ * Note: Don't run this on the main thread, use it a forked process
+ */
+export function getStudioConfig({
+  basePath,
+  configPath: cfgPath,
+}: GetStudioWorkspacesOptions): WorkspaceOptions[] {
   let cleanup
   try {
     cleanup = mockBrowserEnvironment(basePath)
@@ -51,7 +53,27 @@ export async function getStudioConfig(options: {
     }
 
     if (!config) throw new Error('Configuration did not export expected config shape')
+    const normalized = Array.isArray(config)
+      ? config
+      : [{...config, name: config.name || 'default', basePath: config.basePath || '/'}]
+
+    return normalized
+  } finally {
+    cleanup?.()
+  }
+}
 
+/**
+ * Note: Don't run this on the main thread, use it a forked process
+ */
+export async function getStudioWorkspaces(
+  options: GetStudioWorkspacesOptions,
+): Promise<Workspace[]> {
+  let cleanup
+
+  try {
+    cleanup = mockBrowserEnvironment(options.basePath)
+    const config = getStudioConfig(options)
     const workspaces = await firstValueFrom(resolveConfig(config))
     if (!workspaces) throw new Error('Failed to resolve configuration')
     return workspaces

package/src/_internal/cli/util/tree.ts

@@ -0,0 +1,110 @@
+import {type Path, pathToString} from 'sanity'
+
+interface BaseNode {
+  path: Path
+}
+
+export interface Tree<Node extends BaseNode> {
+  nodes?: Node[]
+  children?: Record<string, Tree<Node>>
+}
+
+/**
+ * Recursively calculates the max length of all the keys in the given validation
+ * tree respecting extra length due to indentation depth. Used to calculate the
+ * padding for the rest of the tree.
+ */
+export const maxKeyLength = (children: Record<string, Tree<BaseNode>> = {}, depth = 0): number => {
+  return Object.entries(children)
+    .map(([key, child]) =>
+      Math.max(key.length + depth * 2, maxKeyLength(child.children, depth + 1)),
+    )
+    .reduce((max, next) => (next > max ? next : max), 0)
+}
+
+interface Options<Node extends BaseNode> {
+  node?: Record<string, Tree<Node>>
+  paddingLength: number
+  indent?: string
+  getNodes?: (node: Tree<Node>) => Node[] | undefined
+  getMessage: (node: Node) => string
+}
+
+/**
+ * Recursively formats a given tree into a printed user-friendly tree structure
+ */
+export const formatTree = <Node extends BaseNode>({
+  node = {},
+  paddingLength,
+  indent = '',
+  getNodes: getLeaves = ({nodes}) => nodes,
+  getMessage,
+}: Options<Node>): string => {
+  const entries = Object.entries(node)
+
+  return entries
+    .map(([key, child], index) => {
+      const isLast = index === entries.length - 1
+      const nextIndent = `${indent}${isLast ? '  ' : '│ '}`
+      const leaves = getLeaves(child)
+
+      const nested = formatTree({
+        node: child.children,
+        paddingLength,
+        indent: nextIndent,
+        getNodes: getLeaves,
+        getMessage,
+      })
+
+      if (!leaves?.length) {
+        const current = `${indent}${isLast ? '└' : '├'}─ ${key}`
+        return [current, nested].filter(Boolean).join('\n')
+      }
+
+      const [first, ...rest] = leaves
+      const firstPadding = '.'.repeat(paddingLength - indent.length - key.length)
+      const elbow = isLast ? '└' : '├'
+      const subsequentPadding = ' '.repeat(paddingLength - indent.length + 2)
+
+      const firstMessage = `${indent}${elbow}─ ${key} ${firstPadding} ${getMessage(first)}`
+      const subsequentMessages = rest
+        .map((marker) => `${nextIndent}${subsequentPadding} ${getMessage(marker)}`)
+        .join('\n')
+
+      const current = [firstMessage, subsequentMessages].filter(Boolean).join('\n')
+      return [current, nested].filter(Boolean).join('\n')
+    })
+    .join('\n')
+}
+
+/**
+ * Converts a set of markers with paths into a tree of markers where the paths
+ * are embedded in the tree
+ */
+export function convertToTree<const Node extends BaseNode>(nodes: Node[]): Tree<Node> {
+  const root: Tree<Node> = {}
+
+  // add the markers to the tree
+  function addNode(node: Node, tree: Tree<Node> = root) {
+    // if we've traversed the whole path
+    if (!node.path.length) {
+      if (!tree.nodes) tree.nodes = [] // ensure markers is defined
+
+      // then add the marker to the front
+      tree.nodes.push(node)
+      return
+    }
+
+    const [current, ...rest] = node.path
+    const key = pathToString([current])
+
+    // ensure the current node has children and the next node
+    if (!tree.children) tree.children = {}
+    if (!(key in tree.children)) tree.children[key] = {}
+
+    addNode({...node, path: rest}, tree.children[key])
+  }
+
+  for (const node of nodes) addNode(node)
+  return root
+}

package/src/core/config/index.ts

@@ -12,3 +12,4 @@ export * from './components'
 export * from './studio'
 export * from './flattenConfig'
 export * from './form'
+export * from './resolveSchemaTypes'

package/src/core/config/prepareConfig.ts

@@ -44,7 +44,6 @@ import {
   partialIndexingEnabledReducer,
   resolveProductionUrlReducer,
   schemaTemplatesReducer,
-  schemaTypesReducer,
   toolsReducer,
 } from './configPropertyReducers'
 import {resolveConfigProperty} from './resolveConfigProperty'
@@ -52,6 +51,7 @@ import {ConfigResolutionError} from './ConfigResolutionError'
 import {SchemaError} from './SchemaError'
 import {createDefaultIcon} from './createDefaultIcon'
 import {documentFieldActionsReducer, initialDocumentFieldActions} from './document'
+import {resolveSchemaTypes} from './resolveSchemaTypes'
 
 type InternalSource = WorkspaceSummary['__internal']['sources'][number]
 
@@ -118,12 +118,9 @@ export function prepareConfig(
 
       let schemaTypes
       try {
-        schemaTypes = resolveConfigProperty({
-          propertyName: 'schema.types',
+        schemaTypes = resolveSchemaTypes({
           config: source,
           context: {projectId, dataset},
-          initialValue: [],
-          reducer: schemaTypesReducer,
         })
       } catch (e) {
         throw new ConfigResolutionError({

package/src/core/config/resolveSchemaTypes.ts

@@ -0,0 +1,29 @@
+import {SchemaTypeDefinition} from '@sanity/types'
+import {ConfigPropertyReducer, PluginOptions} from './types'
+import {schemaTypesReducer} from './configPropertyReducers'
+import {resolveConfigProperty} from './resolveConfigProperty'
+
+type ConfigContext<T> = T extends ConfigPropertyReducer<any, infer TContext> ? TContext : never
+type SchemaTypeContext = ConfigContext<typeof schemaTypesReducer>
+
+interface ResolveSchemaTypesOptions {
+  config: PluginOptions
+  context: SchemaTypeContext
+}
+
+/**
+ * @internal
+ * @hidden
+ */
+export function resolveSchemaTypes({
+  config,
+  context,
+}: ResolveSchemaTypesOptions): SchemaTypeDefinition[] {
+  return resolveConfigProperty({
+    propertyName: 'schema.types',
+    config,
+    context,
+    initialValue: [],
+    reducer: schemaTypesReducer,
+  })
+}

package/src/core/studio/screens/schemaErrors/SchemaProblemGroups.tsx

@@ -77,7 +77,9 @@ export function SchemaProblemGroups(props: {problemGroups: SchemaValidationProbl
                 >
                   {group.path.map((segment, j) => {
                     if (segment.kind === 'type') {
-                      const text = `${_renderSegmentName(segment.name)}:${segment.type}`
+                      const text = `${_renderSegmentName(
+                        segment.name || `<anonymous ${segment.type}>`,
+                      )}:${segment.type}`
                       return (
                         <Text title={text} key={j} size={1} textOverflow="ellipsis">
                           <SegmentSpan>{text}</SegmentSpan>
@@ -132,7 +134,7 @@ function getTypeInfo(problem: SchemaValidationProblemGroup): {name: string; type
   // a possible API improvement is to add schemaType info to the problem group interface itself
   const first = problem.path[0]
   if (first.kind === 'type') {
-    return {name: first.name, type: first.type}
+    return {name: first.name || `<anonymous ${first.type}>`, type: first.type}
   }
   return null
 }

package/src/structure/comments/src/components/pte/blocks/MentionInlineBlock.tsx

@@ -1,10 +1,9 @@
 import React from 'react'
-import {Flex, Text} from '@sanity/ui'
+import {Flex, Text, TextSkeleton} from '@sanity/ui'
 import styled, {css} from 'styled-components'
 import {Tooltip} from '../../../../../../ui-components'
-import {commentsLocaleNamespace} from '../../../../i18n'
 import {CommentsAvatar} from '../../avatars'
-import {useCurrentUser, useTranslation, useUser} from 'sanity'
+import {useCurrentUser, useUser} from 'sanity'
 
 const Span = styled.span(({theme}) => {
   const {regular} = theme.sanity.fonts?.text.weights
@@ -34,10 +33,18 @@ export function MentionInlineBlock(props: MentionInlineBlockProps) {
   const {selected, userId} = props
   const [user, loading] = useUser(userId)
   const currentUser = useCurrentUser()
-  const {t} = useTranslation(commentsLocaleNamespace)
 
-  // eslint-disable-next-line i18next/no-literal-string
-  if (!user || loading) return <Span>@Loading</Span> // todo: improve
+  if (!user || loading)
+    return (
+      <TextSkeleton
+        data-testid="comment-mentions-loading-skeleton"
+        style={{width: '10ch'}}
+        size={0}
+        muted
+        radius={1}
+        animated
+      />
+    )
 
   return (
     <Tooltip