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

package/lib/structure.esm.js

@@ -1,4 +1,4 @@
-export { ComponentBuilder, ComponentViewBuilder, ConfirmDeleteDialogContainer as ConfirmDeleteDialog, DEFAULT_INTENT_HANDLER, DocumentBuilder, DocumentInspectorHeader, DocumentListBuilder, DocumentListItemBuilder, DocumentListPane, DocumentPane, DocumentPaneProvider, DocumentTypeListBuilder, FormViewBuilder, GenericListBuilder, GenericViewBuilder, HELP_URL, InitialValueTemplateItemBuilder, ListBuilder, ListItemBuilder, MenuItemBuilder, MenuItemGroupBuilder, PaneLayout, PaneRouterContext, SerializeError, StructureToolProvider, component, createStructureBuilder, defaultInitialValueTemplateItems, defaultIntentChecker, documentFromEditor, documentFromEditorWithInitialValue, form, getOrderingMenuItem, getOrderingMenuItemsForSchemaType, getTypeNamesFromFilter, isDocumentListItem, maybeSerializeInitialValueTemplateItem, maybeSerializeMenuItem, maybeSerializeMenuItemGroup, maybeSerializeView, menuItemsFromInitialValueTemplateItems, shallowIntentChecker, structureLocaleNamespace, structureTool, useDocumentPane, useDocumentTitle, usePaneRouter, useStructureTool } from './_chunks/structure-qJLnDJXq.js';
+export { ComponentBuilder, ComponentViewBuilder, ConfirmDeleteDialogContainer as ConfirmDeleteDialog, DEFAULT_INTENT_HANDLER, DocumentBuilder, DocumentInspectorHeader, DocumentListBuilder, DocumentListItemBuilder, DocumentListPane, DocumentPane, DocumentPaneProvider, DocumentTypeListBuilder, FormViewBuilder, GenericListBuilder, GenericViewBuilder, HELP_URL, InitialValueTemplateItemBuilder, ListBuilder, ListItemBuilder, MenuItemBuilder, MenuItemGroupBuilder, PaneLayout, PaneRouterContext, SerializeError, StructureToolProvider, component, createStructureBuilder, defaultInitialValueTemplateItems, defaultIntentChecker, documentFromEditor, documentFromEditorWithInitialValue, form, getOrderingMenuItem, getOrderingMenuItemsForSchemaType, getTypeNamesFromFilter, isDocumentListItem, maybeSerializeInitialValueTemplateItem, maybeSerializeMenuItem, maybeSerializeMenuItemGroup, maybeSerializeView, menuItemsFromInitialValueTemplateItems, shallowIntentChecker, structureLocaleNamespace, structureTool, useDocumentPane, useDocumentTitle, usePaneRouter, useStructureTool } from './_chunks/structure-iqIDIH7-.js';
 import 'react/jsx-runtime';
 import 'react';
 import '@sanity/ui';

package/lib/structure.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', {
   value: true
 });
-var structure = require('./_chunks/structure-588eAwLd.js');
+var structure = require('./_chunks/structure-o_wMXC_G.js');
 require('react/jsx-runtime');
 require('react');
 require('@sanity/ui');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sanity",
-  "version": "3.26.2-canary.52+be0d838591",
+  "version": "3.26.2-canary.69+747ad532f2",
   "description": "Sanity is a real-time content infrastructure with a scalable, hosted backend featuring a Graph Oriented Query Language (GROQ), asset pipelines and fast edge caches",
   "keywords": [
     "sanity",
@@ -199,28 +199,28 @@
     "@rexxars/react-json-inspector": "^8.0.1",
     "@sanity/asset-utils": "^1.2.5",
     "@sanity/bifur-client": "^0.3.1",
-    "@sanity/block-tools": "3.26.2-canary.52+be0d838591",
-    "@sanity/cli": "3.26.2-canary.52+be0d838591",
-    "@sanity/client": "^6.11.1",
+    "@sanity/block-tools": "3.26.2-canary.69+747ad532f2",
+    "@sanity/cli": "3.26.2-canary.69+747ad532f2",
+    "@sanity/client": "^6.12.3",
     "@sanity/color": "^3.0.0",
-    "@sanity/diff": "3.26.2-canary.52+be0d838591",
+    "@sanity/diff": "3.26.2-canary.69+747ad532f2",
     "@sanity/diff-match-patch": "^3.1.1",
     "@sanity/eventsource": "^5.0.0",
-    "@sanity/export": "3.26.2-canary.52+be0d838591",
+    "@sanity/export": "3.26.2-canary.69+747ad532f2",
     "@sanity/generate-help-url": "^3.0.0",
     "@sanity/icons": "^2.8.0",
     "@sanity/image-url": "^1.0.2",
-    "@sanity/import": "3.26.2-canary.52+be0d838591",
+    "@sanity/import": "3.26.2-canary.69+747ad532f2",
     "@sanity/logos": "^2.1.4",
-    "@sanity/migrate": "3.26.2-canary.52+be0d838591",
-    "@sanity/mutator": "3.26.2-canary.52+be0d838591",
-    "@sanity/portable-text-editor": "3.26.2-canary.52+be0d838591",
-    "@sanity/presentation": "1.7.1",
-    "@sanity/schema": "3.26.2-canary.52+be0d838591",
+    "@sanity/migrate": "3.26.2-canary.69+747ad532f2",
+    "@sanity/mutator": "3.26.2-canary.69+747ad532f2",
+    "@sanity/portable-text-editor": "3.26.2-canary.69+747ad532f2",
+    "@sanity/presentation": "1.7.2",
+    "@sanity/schema": "3.26.2-canary.69+747ad532f2",
     "@sanity/telemetry": "^0.7.6",
-    "@sanity/types": "3.26.2-canary.52+be0d838591",
+    "@sanity/types": "3.26.2-canary.69+747ad532f2",
     "@sanity/ui": "^2.0.0",
-    "@sanity/util": "3.26.2-canary.52+be0d838591",
+    "@sanity/util": "3.26.2-canary.69+747ad532f2",
     "@sanity/uuid": "^3.0.1",
     "@tanstack/react-virtual": "3.0.0-beta.54",
     "@types/is-hotkey": "^0.1.7",
@@ -334,5 +334,5 @@
   "engines": {
     "node": ">=18"
   },
-  "gitHead": "be0d83859183df1d9d7413775c453b32f0ec6dd8"
+  "gitHead": "747ad532f2f9e2d3dd4e859262bd2a8fc859296e"
 }

package/src/_internal/cli/actions/schema/formatSchemaValidation.ts

@@ -0,0 +1,96 @@
+import {isatty} from 'tty'
+import chalk from 'chalk'
+import {SchemaValidationProblemGroup, SchemaValidationProblemPath} from '@sanity/types'
+import logSymbols from 'log-symbols'
+
+const isTty = isatty(1)
+
+const headers = {
+  error: isTty ? chalk.bold(chalk.bgRed(chalk.black(' ERROR '))) : chalk.red('[ERROR]'),
+  warning: isTty ? chalk.bold(chalk.bgYellow(chalk.black(' WARN '))) : chalk.yellow('[WARN]'),
+}
+
+const severityValues = {error: 0, warning: 1}
+
+function formatPath(pathSegments: SchemaValidationProblemPath) {
+  const format = (
+    [curr, ...next]: SchemaValidationProblemPath,
+    mode: 'object' | 'array' = 'object',
+  ): string => {
+    if (!curr) return ''
+    if (curr.kind === 'property') return format(next, curr.name === 'of' ? 'array' : 'object')
+
+    const name = curr.name ? curr.name : `<anonymous_${curr.type}>`
+    return `${mode === 'array' ? `[${name}]` : `.${name}`}${format(next)}`
+  }
+
+  return format(pathSegments.slice(1)).substring(1) // removes the top-level type and leading `.`
+}
+
+export function getAggregatedSeverity(
+  groupOrGroups: SchemaValidationProblemGroup | SchemaValidationProblemGroup[],
+): 'error' | 'warning' {
+  const groups = Array.isArray(groupOrGroups) ? groupOrGroups : [groupOrGroups]
+  return groups
+    .flatMap((group) => group.problems.map((problem) => problem.severity))
+    .find((severity) => severity === 'error')
+    ? 'error'
+    : 'warning'
+}
+
+export function formatSchemaValidation(validation: SchemaValidationProblemGroup[]): string {
+  let unnamedTopLevelTypeCount = 0
+  const validationByType = Object.entries(
+    validation.reduce<Record<string, SchemaValidationProblemGroup[]>>((acc, next) => {
+      const [firstSegment] = next.path
+      if (!firstSegment) return acc
+      if (firstSegment.kind !== 'type') return acc
+
+      const topLevelType =
+        firstSegment.name || `<unnamed_${firstSegment.type}_type_${unnamedTopLevelTypeCount++}>`
+      const problems = acc[topLevelType] ?? []
+
+      problems.push(next)
+
+      acc[topLevelType] = problems
+      return acc
+    }, {}),
+  )
+
+  const formatted = validationByType
+    .sort((a, b) => {
+      const [aType, aGroups] = a
+      const [bType, bGroups] = b
+      const aValue = severityValues[getAggregatedSeverity(aGroups)]
+      const bValue = severityValues[getAggregatedSeverity(bGroups)]
+      if (aValue === bValue) return aType.localeCompare(bType, 'en-US')
+      return aValue - bValue
+    })
+    .map(([topLevelType, groups]) => {
+      const formattedTopLevelType = isTty
+        ? chalk.bgWhite(chalk.black(` ${topLevelType} `))
+        : `[${topLevelType}]`
+
+      const header = `${headers[getAggregatedSeverity(groups)]} ${formattedTopLevelType}`
+      const body = groups
+        .sort(
+          (a, b) =>
+            severityValues[getAggregatedSeverity(a)] - severityValues[getAggregatedSeverity(b)],
+        )
+        .map((group) => {
+          const formattedPath = `  ${chalk.bold(formatPath(group.path) || '(root)')}`
+          const formattedMessages = group.problems
+            .sort((a, b) => severityValues[a.severity] - severityValues[b.severity])
+            .map(({severity, message}) => `    ${logSymbols[severity]} ${message}`)
+            .join('\n')
+
+          return `${formattedPath}\n${formattedMessages}`
+        })
+        .join('\n')
+
+      return `${header}\n${body}`
+    })
+    .join('\n\n')
+
+  return formatted
+}

package/src/_internal/cli/actions/schema/validateAction.ts

@@ -0,0 +1,120 @@
+import path from 'path'
+import {Worker} from 'worker_threads'
+import {type CliCommandArguments, type CliCommandContext} from '@sanity/cli'
+import readPkgUp from 'read-pkg-up'
+import logSymbols from 'log-symbols'
+import {
+  type ValidateSchemaWorkerData,
+  type ValidateSchemaWorkerResult,
+} from '../../threads/validateSchema'
+import {formatSchemaValidation, getAggregatedSeverity} from './formatSchemaValidation'
+
+interface ValidateFlags {
+  workspace?: string
+  format?: string
+  level?: 'error' | 'warning'
+}
+
+export type SchemaValidationFormatter = (result: ValidateSchemaWorkerResult) => string
+
+export default async function validateAction(
+  args: CliCommandArguments<ValidateFlags>,
+  {workDir, output}: CliCommandContext,
+): Promise<void> {
+  const flags = args.extOptions
+
+  const rootPkgPath = readPkgUp.sync({cwd: __dirname})?.path
+  if (!rootPkgPath) {
+    throw new Error('Could not find root directory for `sanity` package')
+  }
+
+  const workerPath = path.join(
+    path.dirname(rootPkgPath),
+    'lib',
+    '_internal',
+    'cli',
+    'threads',
+    'validateSchema.js',
+  )
+
+  const level = flags.level || 'warning'
+
+  if (level !== 'error' && level !== 'warning') {
+    throw new Error(`Invalid level. Available levels are 'error' and 'warning'.`)
+  }
+
+  const format = flags.format || 'pretty'
+
+  if (!['pretty', 'ndjson', 'json'].includes(format)) {
+    throw new Error(
+      `Did not recognize format '${flags.format}'. Available formats are 'pretty', 'ndjson', and 'json'.`,
+    )
+  }
+
+  let spinner
+
+  if (format === 'pretty') {
+    spinner = output
+      .spinner(
+        flags.workspace
+          ? `Validating schema from workspace '${flags.workspace}'…`
+          : 'Validating schema…',
+      )
+      .start()
+  }
+
+  const worker = new Worker(workerPath, {
+    workerData: {
+      workDir,
+      level,
+      workspace: flags.workspace,
+    } satisfies ValidateSchemaWorkerData,
+    // eslint-disable-next-line no-process-env
+    env: process.env,
+  })
+
+  const {validation} = await new Promise<ValidateSchemaWorkerResult>((resolve, reject) => {
+    worker.addListener('message', resolve)
+    worker.addListener('error', reject)
+  })
+
+  const problems = validation.flatMap((group) => group.problems)
+  const errorCount = problems.filter((problem) => problem.severity === 'error').length
+  const warningCount = problems.filter((problem) => problem.severity === 'warning').length
+
+  const overallSeverity = getAggregatedSeverity(validation)
+
+  switch (format) {
+    case 'ndjson': {
+      for (const group of validation) {
+        output.print(JSON.stringify(group))
+      }
+      break
+    }
+    case 'json': {
+      output.print(JSON.stringify(validation))
+      break
+    }
+    default: {
+      spinner?.succeed('Validated schema')
+      output.print(`\nValidation results:`)
+      output.print(
+        `${logSymbols.error} Errors:   ${errorCount.toLocaleString('en-US')} error${
+          errorCount === 1 ? '' : 's'
+        }`,
+      )
+      if (level !== 'error') {
+        output.print(
+          `${logSymbols.warning} Warnings: ${warningCount.toLocaleString('en-US')} warning${
+            warningCount === 1 ? '' : 's'
+          }`,
+        )
+      }
+      output.print()
+
+      output.print(formatSchemaValidation(validation))
+    }
+  }
+
+  process.exitCode = overallSeverity === 'error' ? 1 : 0
+}

package/src/_internal/cli/actions/validation/reporters/prettyReporter/formatDocumentValidation.ts

@@ -1,19 +1,20 @@
 import chalk from 'chalk'
-import {ValidationMarker} from '@sanity/types'
+import {ValidationMarker, Path} from '@sanity/types'
 import logSymbols from 'log-symbols'
+import {Tree, convertToTree, formatTree, maxKeyLength} from '../../../../util/tree'
 import {DocumentValidationResult, Level, isTty, levelValues} from './util'
-import {pathToString} from 'sanity'
 
 export interface FormatDocumentValidationOptions extends DocumentValidationResult {
   studioHost: string | null
   basePath: string
 }
 
-interface ValidationTree {
-  markers?: Pick<ValidationMarker, 'level' | 'message'>[]
-  children?: Record<string, ValidationTree>
+interface Marker extends Pick<ValidationMarker, 'level' | 'message'> {
+  path: Path
 }
 
+type ValidationTree = Tree<Marker>
+
 const levelHeaders = {
   error: isTty ? chalk.bold(chalk.bgRed(chalk.black(' ERROR '))) : chalk.red('[ERROR]'),
   warning: isTty ? chalk.bold(chalk.bgYellow(chalk.black(' WARN '))) : chalk.yellow('[WARN]'),
@@ -26,73 +27,19 @@ const levelHeaders = {
 const link = (text: string, url: string) =>
   isTty ? `\u001b]8;;${url}\u0007${text}\u001b]8;;\u0007` : chalk.underline(text)
 
-/**
- * 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.
- */
-const maxKeyLength = (children: Record<string, ValidationTree> = {}, 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)
-}
-
 /**
  * For sorting markers
  */
 const compareLevels = <T extends {level: Level; message: string}>(a: T, b: T) =>
   levelValues[a.level] - levelValues[b.level]
 
-/**
- * Recursively formats a given tree into a printed user-friendly tree structure
- */
-const formatTree = (
-  node: Record<string, ValidationTree> = {},
-  paddingLength: number,
-  indent = '',
-): string => {
-  const entries = Object.entries(node)
-
-  return entries
-    .map(([key, child], index) => {
-      const isLast = index === entries.length - 1
-      const nextIndent = `${indent}${isLast ? '  ' : '│ '}`
-      const nested = formatTree(child.children, paddingLength, nextIndent)
-
-      if (!child.markers?.length) {
-        const current = `${indent}${isLast ? '└' : '├'}─ ${key}`
-        return [current, nested].filter(Boolean).join('\n')
-      }
-
-      const [first, ...rest] = child.markers.slice().sort(compareLevels)
-      const firstPadding = '.'.repeat(paddingLength - indent.length - key.length)
-      const elbow = isLast ? '└' : '├'
-      const firstBullet = logSymbols[first.level]
-      const subsequentPadding = ' '.repeat(paddingLength - indent.length + 2)
-
-      const firstMessage = `${indent}${elbow}─ ${key} ${firstPadding} ${firstBullet} ${first.message}`
-      const subsequentMessages = rest
-        .map(
-          (marker) =>
-            `${nextIndent}${subsequentPadding} ${logSymbols[marker.level]} ${marker.message}`,
-        )
-        .join('\n')
-
-      const current = [firstMessage, subsequentMessages].filter(Boolean).join('\n')
-      return [current, nested].filter(Boolean).join('\n')
-    })
-    .join('\n')
-}
-
 /**
  * Formats the markers at the root of the validation tree
  */
 const formatRootErrors = (root: ValidationTree, hasChildren: boolean, paddingLength: number) => {
-  if (!root.markers) return ''
+  if (!root.nodes) return ''
 
-  const [first, ...rest] = root.markers.slice().sort(compareLevels)
+  const [first, ...rest] = root.nodes.slice().sort(compareLevels)
   if (!first) return ''
 
   const firstElbow = hasChildren ? '│ ' : '└─'
@@ -112,38 +59,6 @@ const formatRootErrors = (root: ValidationTree, hasChildren: boolean, paddingLen
   return [firstLine, restOfLines].filter(Boolean).join('\n')
 }
 
-/**
- * Converts a set of markers with paths into a tree of markers where the paths
- * are embedded in the tree
- */
-function convertToTree(markers: ValidationMarker[]): ValidationTree {
-  const root: ValidationTree = {}
-
-  // add the markers to the tree
-  function addMarker(marker: ValidationMarker, node: ValidationTree = root) {
-    // if we've traversed the whole path
-    if (!marker.path.length) {
-      if (!node.markers) node.markers = [] // ensure markers is defined
-
-      // then add the marker to the front
-      node.markers.push({level: marker.level, message: marker.message})
-      return
-    }
-
-    const [current, ...rest] = marker.path
-    const key = pathToString([current])
-
-    // ensure the current node has children and the next node
-    if (!node.children) node.children = {}
-    if (!(key in node.children)) node.children[key] = {}
-
-    addMarker({...marker, path: rest}, node.children[key])
-  }
-
-  for (const marker of markers) addMarker(marker)
-  return root
-}
-
 /**
  * Formats document validation results into a user-friendly tree structure
  */
@@ -155,7 +70,7 @@ export function formatDocumentValidation({
   studioHost,
   markers,
 }: FormatDocumentValidationOptions): string {
-  const tree = convertToTree(markers)
+  const tree = convertToTree<Marker>(markers)
   const editLink =
     studioHost &&
     `${studioHost}${basePath}/intent/edit/id=${encodeURIComponent(
@@ -171,7 +86,14 @@ export function formatDocumentValidation({
   }`
 
   const paddingLength = Math.max(maxKeyLength(tree.children) + 2, 30)
-  const childErrors = formatTree(tree.children, paddingLength)
+
+  const childErrors = formatTree<Marker>({
+    node: tree.children,
+    paddingLength,
+    getNodes: ({nodes}) => (nodes ?? []).slice().sort(compareLevels),
+    getMessage: (marker) => [logSymbols[marker.level], marker.message].join(' '),
+  })
+
   const rootErrors = formatRootErrors(tree, childErrors.length > 0, paddingLength)
 
   return [header, rootErrors, childErrors].filter(Boolean).join('\n')

package/src/_internal/cli/commands/index.ts

@@ -21,6 +21,7 @@ import createDocumentsCommand from './documents/createDocumentsCommand'
 import validateDocumentsCommand from './documents/validateDocumentsCommand'
 import devCommand from './dev/devCommand'
 import startCommand from './start/startCommand'
+import validateSchemaCommand from './schema/validateSchemaCommand'
 import previewCommand from './preview/previewCommand'
 import uninstallCommand from './uninstall/uninstallCommand'
 import hookGroup from './hook/hookGroup'
@@ -90,6 +91,7 @@ const commands: (CliCommandDefinition | CliCommandGroupDefinition)[] = [
   deleteGraphQLAPICommand,
   devCommand,
   startCommand,
+  validateSchemaCommand,
   previewCommand,
   uninstallCommand,
   execCommand,

package/src/_internal/cli/commands/migration/createMigrationCommand.ts

@@ -13,6 +13,13 @@ import {renameField} from './templates/renameField'
 
 const helpText = `
 Create a new migration within your project
+
+Examples:
+    # Create a new migration, you will be prompted to provide a type
+    sanity migration create
+
+    # Create a new migration, specifying the title
+    sanity migration create "Rename field from location to address"
 `
 
 // eslint-disable-next-line @typescript-eslint/no-empty-interface
@@ -32,21 +39,22 @@ const TEMPLATES = [
 const createMigrationCommand: CliCommandDefinition<CreateMigrationFlags> = {
   name: 'create',
   group: 'migration',
-  signature: '[NAME]',
+  signature: '[TITLE]',
   helpText,
   description: 'Create a new content migration within your project',
   action: async (args, context) => {
     const {output, prompt, workDir, chalk} = context
 
-    let name = ''
-    while (!name.trim()) {
-      name = await prompt.single({
+    let [title] = args.argsWithoutOptions
+
+    while (!title?.trim()) {
+      title = await prompt.single({
         type: 'input',
-        suffix: ' (e.g. rename field from location to address)',
-        message: 'Name of migration',
+        suffix: ' (e.g. "Rename field from location to address")',
+        message: 'Title of migration',
       })
-      if (!name.trim()) {
-        output.print(chalk.red('Name cannot be empty'))
+      if (!title.trim()) {
+        output.error(chalk.red('Name cannot be empty'))
       }
     }
     const types = await prompt.single({
@@ -65,7 +73,7 @@ const createMigrationCommand: CliCommandDefinition<CreateMigrationFlags> = {
       })),
     })
 
-    const sluggedName = deburr(name.toLowerCase())
+    const sluggedName = deburr(title.toLowerCase())
       .replace(/\s+/g, '-')
       .replace(/[^a-z0-9-]/g, '')
 
@@ -84,7 +92,7 @@ const createMigrationCommand: CliCommandDefinition<CreateMigrationFlags> = {
     mkdirp.sync(destDir)
 
     const renderedTemplate = (templatesByName[template].template || minimalSimple)({
-      migrationName: name,
+      migrationName: title,
       documentTypes: types
         .split(',')
         .map((t) => t.trim())

package/src/_internal/cli/commands/migration/listMigrationsCommand.ts

@@ -1,6 +1,6 @@
 import path from 'path'
 import {readdir} from 'node:fs/promises'
-import type {CliCommandDefinition} from '@sanity/cli'
+import type {CliCommandContext, CliCommandDefinition} from '@sanity/cli'
 import {register} from 'esbuild-register/dist/node'
 import {Migration} from '@sanity/migrate'
 import {Table} from 'console-table-printer'
@@ -21,45 +21,48 @@ const createMigrationCommand: CliCommandDefinition<CreateFlags> = {
   helpText,
   description: 'List available migrations',
   action: async (args, context) => {
-    const {output, workDir} = context
-
-    if (!__DEV__) {
-      register({
-        target: `node${process.version.slice(1)}`,
-      })
-    }
-
-    const directories = (
-      await readdir(path.join(workDir, MIGRATIONS_DIRECTORY), {withFileTypes: true})
-    ).filter((ent) => ent.isDirectory())
-
-    const migrationModules = directories
-      .map((ent) => {
-        const candidates = resolveMigrationScript(workDir, ent.name)
-        const found = candidates.find((candidate) => candidate.mod?.default)
-        if (!found) {
-          return null
-        }
-        return {
-          dirname: ent.name,
-          migration: found.mod.default as Migration,
-        }
-      })
-      .filter(Boolean) as {dirname: string; migration: Migration}[]
+    const {workDir, output} = context
+    const migrations = await resolveMigrations(workDir)
     const table = new Table({
-      title: `Found ${migrationModules.length} migrations in project`,
+      title: `Found ${migrations.length} migrations in project`,
       columns: [
         {name: 'id', title: 'ID', alignment: 'left'},
-        {name: 'name', title: 'Name', alignment: 'left'},
+        {name: 'title', title: 'Title', alignment: 'left'},
       ],
     })
 
-    migrationModules.forEach((definedMigration) => {
-      table.addRow({id: definedMigration.dirname, name: definedMigration.migration.name})
+    migrations.forEach((definedMigration) => {
+      table.addRow({id: definedMigration.dirname, title: definedMigration.migration.title})
     })
     table.printTable()
-    output.print(`\nRun "sanity migration run <MIGRATION ID>" to run a migration`)
+    output.print('\nRun `sanity migration run <ID>` to run a migration')
   },
 }
 
+export async function resolveMigrations(workDir: string) {
+  if (!__DEV__) {
+    register({
+      target: `node${process.version.slice(1)}`,
+    })
+  }
+
+  const directories = (
+    await readdir(path.join(workDir, MIGRATIONS_DIRECTORY), {withFileTypes: true})
+  ).filter((ent) => ent.isDirectory())
+
+  return directories
+    .map((ent) => {
+      const candidates = resolveMigrationScript(workDir, ent.name)
+      const found = candidates.find((candidate) => candidate.mod?.default)
+      if (!found) {
+        return null
+      }
+      return {
+        dirname: ent.name,
+        migration: found.mod.default as Migration,
+      }
+    })
+    .filter(Boolean) as {dirname: string; migration: Migration}[]
+}
+
 export default createMigrationCommand