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

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

@@ -0,0 +1,214 @@
+import {isatty} from 'tty'
+import {Migration, Mutation, NodePatch, Transaction} from '@sanity/migrate'
+import {KeyedSegment} from '@sanity/types'
+import {Chalk} from 'chalk'
+import {convertToTree, formatTree, maxKeyLength} from '../../util/tree'
+
+type ItemRef = string | number
+type Impact = 'destructive' | 'maybeDestructive' | 'incremental'
+type Variant = Impact | 'info'
+
+const isTty = isatty(1)
+
+interface FormatterOptions<Subject> {
+  chalk: Chalk
+  subject: Subject
+  migration: Migration
+  indentSize?: number
+}
+
+export function prettyFormat({
+  chalk,
+  subject,
+  migration,
+  indentSize = 0,
+}: FormatterOptions<Mutation | Transaction | (Mutation | Transaction)[]>): string {
+  return (Array.isArray(subject) ? subject : [subject])
+    .map((subjectEntry) => {
+      if (subjectEntry.type === 'transaction') {
+        return [
+          [
+            badge('transaction', 'info', chalk),
+            typeof subjectEntry.id === 'undefined' ? null : chalk.underline(subjectEntry.id),
+          ]
+            .filter(Boolean)
+            .join(' '),
+          indent(
+            prettyFormat({
+              chalk,
+              subject: subjectEntry.mutations,
+              migration,
+              indentSize: indentSize,
+            }),
+          ),
+        ].join('\n\n')
+      }
+      return prettyFormatMutation({
+        chalk,
+        subject: subjectEntry,
+        migration,
+        indentSize,
+      })
+    })
+    .join('\n\n')
+}
+
+function encodeItemRef(ref: number | KeyedSegment): ItemRef {
+  return typeof ref === 'number' ? ref : ref._key
+}
+
+function badgeStyle(chalk: Chalk, variant: Variant): Chalk {
+  const styles: Record<Variant, Chalk> = {
+    info: chalk.bgWhite.black,
+    incremental: chalk.bgGreen.black.bold,
+    maybeDestructive: chalk.bgYellow.black.bold,
+    destructive: chalk.bgRed.black.bold,
+  }
+
+  return styles[variant]
+}
+
+function badge(label: string, variant: Variant, chalk: Chalk): string {
+  if (!isTty) {
+    return `[${label}]`
+  }
+
+  return badgeStyle(chalk, variant)(` ${label} `)
+}
+
+const mutationImpact: Record<Mutation['type'], Impact> = {
+  create: 'incremental',
+  createIfNotExists: 'incremental',
+  createOrReplace: 'maybeDestructive',
+  delete: 'destructive',
+  patch: 'maybeDestructive',
+}
+
+function documentId(mutation: Mutation): string | undefined {
+  if ('id' in mutation) {
+    return mutation.id
+  }
+
+  if ('document' in mutation) {
+    return mutation.document._id
+  }
+
+  return undefined
+}
+
+const listFormatter = new Intl.ListFormat('en-US', {
+  type: 'disjunction',
+})
+
+function mutationHeader(chalk: Chalk, mutation: Mutation, migration: Migration): string {
+  const mutationType = badge(mutation.type, mutationImpact[mutation.type], chalk)
+
+  const documentType =
+    'document' in mutation || migration.documentTypes
+      ? badge(
+          'document' in mutation
+            ? mutation.document._type
+            : listFormatter.format(migration.documentTypes ?? []),
+          'info',
+          chalk,
+        )
+      : null
+
+  // TODO: Should we list documentType when a mutation can be yielded for any document type?
+  return [mutationType, documentType, chalk.underline(documentId(mutation))]
+    .filter(Boolean)
+    .join(' ')
+}
+
+export function prettyFormatMutation({
+  chalk,
+  subject,
+  migration,
+  indentSize = 0,
+}: FormatterOptions<Mutation>): string {
+  const lock =
+    'options' in subject ? chalk.cyan(`(if revision==${subject.options?.ifRevision})`) : ''
+  const header = [mutationHeader(chalk, subject, migration), lock].join(' ')
+  const padding = ' '.repeat(indentSize)
+
+  if (
+    subject.type === 'create' ||
+    subject.type === 'createIfNotExists' ||
+    subject.type === 'createOrReplace'
+  ) {
+    return [header, '\n', indent(JSON.stringify(subject.document, null, 2), indentSize)].join('')
+  }
+
+  if (subject.type === 'patch') {
+    const tree = convertToTree<NodePatch>(subject.patches.flat())
+    const paddingLength = Math.max(maxKeyLength(tree.children) + 2, 30)
+
+    return [
+      header,
+      '\n',
+      formatTree<NodePatch>({
+        node: tree.children,
+        paddingLength,
+        indent: padding,
+        getMessage: (patch) => formatPatchMutation(chalk, patch),
+      }),
+    ].join('')
+  }
+
+  return header
+}
+
+function formatPatchMutation(chalk: Chalk, patch: NodePatch): string {
+  const {op} = patch
+  const formattedType = chalk.bold(op.type)
+  if (op.type === 'unset') {
+    return `${chalk.red(formattedType)}()`
+  }
+  if (op.type === 'diffMatchPatch') {
+    return `${chalk.yellow(formattedType)}(${op.value})`
+  }
+  if (op.type === 'inc' || op.type === 'dec') {
+    return `${chalk.yellow(formattedType)}(${op.amount})`
+  }
+  if (op.type === 'set') {
+    return `${chalk.yellow(formattedType)}(${JSON.stringify(op.value)})`
+  }
+  if (op.type === 'setIfMissing') {
+    return `${chalk.green(formattedType)}(${JSON.stringify(op.value)})`
+  }
+  if (op.type === 'assign') {
+    return `${chalk.yellow(formattedType)}(${JSON.stringify(op.value)})`
+  }
+  if (op.type === 'unassign') {
+    return `${chalk.red(formattedType)}(${JSON.stringify(op.keys)})`
+  }
+  if (op.type === 'insert') {
+    return `${chalk.green(formattedType)}(${op.position}, ${encodeItemRef(
+      op.referenceItem,
+    )}, ${JSON.stringify(op.items)})`
+  }
+  if (op.type === 'upsert') {
+    return `${chalk.yellow(formattedType)}(${op.position}, ${encodeItemRef(
+      op.referenceItem,
+    )}, ${JSON.stringify(op.items)})`
+  }
+  if (op.type === 'replace') {
+    return `${chalk.yellow(formattedType)}(${encodeItemRef(op.referenceItem)}, ${JSON.stringify(
+      op.items,
+    )})`
+  }
+  if (op.type === 'truncate') {
+    return `${chalk.red(formattedType)}(${op.startIndex}, ${op.endIndex})`
+  }
+  // @ts-expect-error all cases are covered
+  throw new Error(`Invalid operation type: ${op.type}`)
+}
+
+function indent(subject: string, size = 2): string {
+  const padding = ' '.repeat(size)
+
+  return subject
+    .split('\n')
+    .map((line) => padding + line)
+    .join('\n')
+}

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

@@ -11,29 +11,31 @@ import {
   runFromArchive,
 } from '@sanity/migrate'
 
+import {Table} from 'console-table-printer'
 import {debug} from '../../debug'
-import {formatTransaction} from './utils/mutationFormatter'
+import {resolveMigrations} from './listMigrationsCommand'
+import {prettyFormat} from './prettyMutationFormatter'
 
 const helpText = `
 Options
   --dry <boolean> Whether or not to dry run the migration. Default to true, to actually run the migration, pass --no-dry
-  --from-export <export.tar.gz> Use a local dataset export as source for migration instead of calling the Sanity API. Note: this is only supported for dry runs.
   --concurrency <concurrent> How many mutation requests to run in parallel. Must be between 1 and ${MAX_MUTATION_CONCURRENCY}. Default: ${DEFAULT_MUTATION_CONCURRENCY}.
   --no-progress Don't output progress. Useful if you want debug your migration script and see the output of console.log() statements.
   --dataset <dataset> Dataset to migrate. Defaults to the dataset configured in your Sanity CLI config.
   --projectId <project id> Project ID of the dataset to migrate. Defaults to the projectId configured in your Sanity CLI config.
   --no-confirm Skip the confirmation prompt before running the migration. Make sure you know what you're doing before using this flag.
+  --from-export <export.tar.gz> Use a local dataset export as source for migration instead of calling the Sanity API. Note: this is only supported for dry runs.
 
 
 Examples
   # dry run the migration
-  sanity migration run <name>
+  sanity migration run <id>
 
   # execute the migration against a dataset
-  sanity migration run <name> --no-dry --projectId xyz --dataset staging
+  sanity migration run <id> --no-dry --projectId xyz --dataset staging
 
   # run the migration using the dataset export as the source
-  sanity migration run <name> --dry false --from-export=production.tar.gz --projectId xyz --dataset staging
+  sanity migration run <id> --dry false --from-export=production.tar.gz --projectId xyz --dataset staging
 `
 
 interface CreateFlags {
@@ -48,8 +50,8 @@ interface CreateFlags {
 
 const tryExtensions = ['mjs', 'js', 'ts', 'cjs']
 
-function resolveMigrationScript(workDir: string, migrationName: string) {
-  return [migrationName, path.join(migrationName, 'index')].flatMap((location) =>
+function resolveMigrationScript(workDir: string, migrationId: string) {
+  return [migrationId, path.join(migrationId, 'index')].flatMap((location) =>
     tryExtensions.map((ext) => {
       const relativePath = path.join('migrations', `${location}.${ext}`)
       const absolutePath = path.resolve(workDir, relativePath)
@@ -58,22 +60,24 @@ function resolveMigrationScript(workDir: string, migrationName: string) {
         // eslint-disable-next-line import/no-dynamic-require
         mod = require(absolutePath)
       } catch (err) {
-        // console.error(err)
+        if (err.code !== 'MODULE_NOT_FOUND') {
+          throw new Error(`Error: ${err.message}"`)
+        }
       }
       return {relativePath, absolutePath, mod}
     }),
   )
 }
 
-const createMigrationCommand: CliCommandDefinition<CreateFlags> = {
+const runMigrationCommand: CliCommandDefinition<CreateFlags> = {
   name: 'run',
   group: 'migration',
-  signature: '[NAME] [MIGRATION NAME]',
+  signature: 'ID',
   helpText,
   description: 'Run a migration against a dataset',
   action: async (args, context) => {
     const {apiClient, output, prompt, chalk, workDir} = context
-    const [migrationName] = args.argsWithoutOptions
+    const [id] = args.argsWithoutOptions
 
     const [fromExport, dry, showProgress, dataset, projectId, shouldConfirm] = [
       args.extOptions['from-export'],
@@ -88,8 +92,24 @@ const createMigrationCommand: CliCommandDefinition<CreateFlags> = {
       throw new Error('If either --dataset or --projectId is provided, both must be provided')
     }
 
-    if (!migrationName) {
-      throw new Error('MIGRATION NAME must be provided. `sanity migration run <name>`')
+    if (!id) {
+      output.error(chalk.red('Error: Migration ID must be provided'))
+      const migrations = await resolveMigrations(workDir)
+      const table = new Table({
+        title: `Migrations found in project`,
+        columns: [
+          {name: 'id', title: 'ID', alignment: 'left'},
+          {name: 'title', title: 'Title', alignment: 'left'},
+        ],
+      })
+
+      migrations.forEach((definedMigration) => {
+        table.addRow({id: definedMigration.dirname, title: definedMigration.migration.title})
+      })
+      table.printTable()
+      output.print('\nRun `sanity migration run <ID>` to run a migration')
+
+      return
     }
 
     if (!__DEV__) {
@@ -98,21 +118,21 @@ const createMigrationCommand: CliCommandDefinition<CreateFlags> = {
       })
     }
 
-    const candidates = resolveMigrationScript(workDir, migrationName)
+    const candidates = resolveMigrationScript(workDir, id)
 
     const resolvedScripts = candidates.filter((candidate) => candidate!.mod?.default)
 
     if (resolvedScripts.length > 1) {
       // todo: consider prompt user about which one to run? note: it's likely a mistake if multiple files resolve to the same name
       throw new Error(
-        `Found multiple migrations for "${migrationName}" in current directory ${candidates
+        `Found multiple migrations for "${id}" in current directory ${candidates
           .map((candidate) => candidate!.relativePath)
           .join(', ')}`,
       )
     }
     if (resolvedScripts.length === 0) {
       throw new Error(
-        `No migration found for "${migrationName}" in current directory. Make sure that the migration file exists and exports a valid migration as its default export.\n
+        `No migration found for "${id}" in current directory. Make sure that the migration file exists and exports a valid migration as its default export.\n
  Tried the following files:\n -${candidates
    .map((candidate) => candidate.relativePath)
    .join('\n - ')}`,
@@ -161,65 +181,53 @@ const createMigrationCommand: CliCommandDefinition<CreateFlags> = {
       token: projectConfig.token!,
       apiVersion: 'v2024-01-29',
     } as const
-
     if (dry) {
-      const spinner = output.spinner(`Running migration "${migrationName}" in dry mode`).start()
-      if (fromExport) {
-        await runFromArchive(migration, fromExport, {
-          api: apiConfig,
-          concurrency,
-          onProgress: createProgress(spinner),
-        })
-        return
-      }
-
-      dryRun({api: apiConfig}, migration)
-
-      spinner.stop()
-    } else {
-      const response =
-        shouldConfirm &&
-        (await prompt.single<boolean>({
-          message: `This migration will run on the ${chalk.yellow(
-            chalk.bold(apiConfig.dataset),
-          )} dataset in ${chalk.yellow(chalk.bold(apiConfig.projectId))} project. Are you sure?`,
-          type: 'confirm',
-        }))
-
-      if (response === false) {
-        debug('User aborted migration')
-        return
-      }
+      dryRunHandler()
+      return
+    }
 
-      const spinner = output.spinner(`Running migration "${migrationName}"`).start()
-      await run({api: apiConfig, concurrency, onProgress: createProgress(spinner)}, migration)
-      spinner.stop()
+    const response =
+      shouldConfirm &&
+      (await prompt.single<boolean>({
+        message: `This migration will run on the ${chalk.yellow(
+          chalk.bold(apiConfig.dataset),
+        )} dataset in ${chalk.yellow(chalk.bold(apiConfig.projectId))} project. Are you sure?`,
+        type: 'confirm',
+      }))
+
+    if (response === false) {
+      debug('User aborted migration')
+      return
     }
 
-    function createProgress(spinner: ReturnType<typeof output.spinner>) {
+    const spinner = output.spinner(`Running migration "${id}"`).start()
+    await run({api: apiConfig, concurrency, onProgress: createProgress(spinner)}, migration)
+    spinner.stop()
+
+    function createProgress(progressSpinner: ReturnType<typeof output.spinner>) {
       return function onProgress(progress: MigrationProgress) {
         if (!showProgress) {
-          spinner.stop()
+          progressSpinner.stop()
           return
         }
         if (progress.done) {
-          spinner.text = `Migration "${migrationName}" completed.
+          progressSpinner.text = `Migration "${id}" completed.
 
-  Project id:  ${chalk.bold(projectId)}
-  Dataset:     ${chalk.bold(dataset)}
+  Project id:  ${chalk.bold(apiConfig.projectId)}
+  Dataset:     ${chalk.bold(apiConfig.dataset)}
 
   ${progress.documents} documents processed.
   ${progress.mutations} mutations generated.
   ${chalk.green(progress.completedTransactions.length)} transactions committed.`
-          spinner.stopAndPersist({symbol: chalk.green('✔')})
+          progressSpinner.stopAndPersist({symbol: chalk.green('✔')})
           return
         }
 
         ;[null, ...progress.currentTransactions].forEach((transaction) => {
-          spinner.text = `Running migration "${migrationName}"…
+          progressSpinner.text = `Running migration "${id}" ${dry ? 'in dry mode...' : '...'}
 
-  Project id:     ${chalk.bold(projectId)}
-  Dataset:        ${chalk.bold(dataset)}
+  Project id:     ${chalk.bold(apiConfig.projectId)}
+  Dataset:        ${chalk.bold(apiConfig.dataset)}
   Document type:  ${chalk.bold(migration.documentTypes?.join(','))}
 
   ${progress.documents} documents processed…
@@ -227,11 +235,47 @@ const createMigrationCommand: CliCommandDefinition<CreateFlags> = {
   ${chalk.blue(progress.pending)} requests pending…
   ${chalk.green(progress.completedTransactions.length)} transactions committed.
 
-  ${transaction && !progress.done ? `» ${chalk.grey(formatTransaction(chalk, transaction))}` : ''}`
+  ${
+    transaction && !progress.done
+      ? `» ${prettyFormat({chalk, subject: transaction, migration, indentSize: 2})}`
+      : ''
+  }`
+        })
+      }
+    }
+
+    async function dryRunHandler() {
+      if (fromExport) {
+        const dryRunSpinner = output.spinner(`Running migration "${id}" in dry mode`).start()
+
+        // TODO: Dry run output when using archive source.
+        await runFromArchive(migration, fromExport, {
+          api: apiConfig,
+          concurrency,
+          onProgress: createProgress(dryRunSpinner),
         })
+
+        dryRunSpinner.stop()
+      } else {
+        output.print(`Running migration "${id}" in dry mode`)
+        output.print()
+        output.print(`Project id:  ${chalk.bold(apiConfig.projectId)}`)
+        output.print(`Dataset:     ${chalk.bold(apiConfig.dataset)}`)
+
+        for await (const mutation of dryRun({api: apiConfig}, migration)) {
+          if (!mutation) continue
+          output.print()
+          output.print(
+            prettyFormat({
+              chalk,
+              subject: mutation,
+              migration,
+            }),
+          )
+        }
       }
     }
   },
 }
 
-export default createMigrationCommand
+export default runMigrationCommand

package/src/_internal/cli/commands/migration/templates/minimalAdvanced.ts

@@ -11,7 +11,7 @@ export const minimalAdvanced = ({
  * and make \`true\` the default value for the \`enabled\` field
  */
 export default defineMigration({
-  name: '${migrationName}',
+  title: '${migrationName}',
 ${
   documentTypes.length > 0
     ? `  documentTypes: [${documentTypes.map((t) => JSON.stringify(t)).join(', ')}],\n`

package/src/_internal/cli/commands/migration/templates/minimalSimple.ts

@@ -7,7 +7,7 @@ export const minimalSimple = ({
 }) => `import {defineMigration} from 'sanity/migrate'
 
 export default defineMigration({
-  name: '${migrationName}',
+  title: '${migrationName}',
 ${
   documentTypes.length > 0
     ? `  documentTypes: [${documentTypes.map((t) => JSON.stringify(t)).join(', ')}],\n`

package/src/_internal/cli/commands/migration/templates/renameField.ts

@@ -10,16 +10,16 @@ const from = 'oldFieldName'
 const to = 'newFieldName'
 
 export default defineMigration({
-  name: '${migrationName}',
+  title: '${migrationName}',
 ${
   documentTypes.length > 0
     ? `  documentTypes: [${documentTypes.map((t) => JSON.stringify(t)).join(', ')}],\n`
     : ''
 }
   migrate: {
-    document(doc, path, context) {
+    document(doc, context) {
       return [
-        at(to, setIfMissing(doc[from]))
+        at(to, setIfMissing(doc[from])),
         at(from, unset())
       ]
     }

package/src/_internal/cli/commands/migration/templates/renameType.ts

@@ -10,7 +10,7 @@ const oldType = 'old'
 const newType = 'new'
 
 export default defineMigration({
-  name: '${migrationName}',
+  title: '${migrationName}',
 ${
   documentTypes.length > 0
     ? `  documentTypes: [${documentTypes.map((t) => JSON.stringify(t)).join(', ')}],\n`

package/src/_internal/cli/commands/migration/templates/stringToPTE.ts

@@ -10,7 +10,7 @@ import {defineMigration, set} from 'sanity/migrate'
 const targetPath = stringToPath('some.path')
 
 export default defineMigration({
-  name: '${migrationName}',
+  title: '${migrationName}',
 ${
   documentTypes.length > 0
     ? `  documentTypes: [${documentTypes.map((t) => JSON.stringify(t)).join(', ')}],\n`

package/src/_internal/cli/commands/migration/utils/mutationFormatter.ts

@@ -83,7 +83,7 @@ function formatPatchMutation(chalk: Chalk, patch: NodePatch<any>): string {
     ].join(': ')
   }
   if (op.type === 'truncate') {
-    return [path, `${formattedType}(${op.startIndex}, ${op.endIndex}`].join(': ')
+    return [path, `${formattedType}(${op.startIndex}, ${op.endIndex})`].join(': ')
   }
   // @ts-expect-error all cases are covered
   throw new Error(`Invalid operation type: ${op.type}`)

package/src/_internal/cli/commands/schema/validateSchemaCommand.ts

@@ -0,0 +1,35 @@
+import type {CliCommandDefinition} from '@sanity/cli'
+
+const description = 'Validates all schema types specified in a workspace.'
+
+const helpText = `
+Options
+  --workspace <name> The name of the workspace to use when validating all schema types.
+  --format <pretty|ndjson|json> The output format used to print schema errors and warnings.
+  --level <error|warning> The minimum level reported out. Defaults to warning.
+
+Examples
+  # Validates all schema types in a Sanity project with more than one workspace
+  sanity schema validate --workspace default
+
+  # Save the results of the report into a file
+  sanity schema validate > report.txt
+
+  # Report out only errors
+  sanity schema validate --level error
+`
+
+const validateDocumentsCommand: CliCommandDefinition = {
+  name: 'validate',
+  group: 'schema',
+  signature: '',
+  description,
+  helpText,
+  action: async (args, context) => {
+    const mod = await import('../../actions/schema/validateAction')
+
+    return mod.default(args, context)
+  },
+} satisfies CliCommandDefinition
+
+export default validateDocumentsCommand

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

@@ -4,7 +4,7 @@ import {isPlainObject} from 'lodash'
 import type {Schema} from '@sanity/types'
 import type {CliV3CommandContext, GraphQLAPIConfig} from '@sanity/cli'
 import type {SchemaDefinitionish, TypeResolvedGraphQLAPI} from '../actions/graphql/types'
-import {getStudioConfig} from '../util/getStudioConfig'
+import {getStudioWorkspaces} from '../util/getStudioWorkspaces'
 import {Workspace} from 'sanity'
 
 if (isMainThread || !parentPort) {
@@ -26,7 +26,7 @@ async function resolveGraphQLApis({
 }: Pick<CliV3CommandContext, 'cliConfig' | 'cliConfigPath' | 'workDir'>): Promise<
   TypeResolvedGraphQLAPI[]
 > {
-  const workspaces = await getStudioConfig({basePath: workDir})
+  const workspaces = await getStudioWorkspaces({basePath: workDir})
   const numSources = workspaces.reduce(
     (count, workspace) => count + workspace.unstable_sources.length,
     0,

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

@@ -11,7 +11,7 @@ import {
   createClient,
 } from '@sanity/client'
 import {type ValidationContext, type ValidationMarker, isReference} from '@sanity/types'
-import {getStudioConfig} from '../util/getStudioConfig'
+import {getStudioWorkspaces} from '../util/getStudioWorkspaces'
 import {mockBrowserEnvironment} from '../util/mockBrowserEnvironment'
 import {
   createReporter,
@@ -108,7 +108,10 @@ const idRegex = /^[^-][A-Z0-9._-]*$/i
 
 // during testing, the `doc` endpoint 502'ed if given an invalid ID
 const isValidId = (id: unknown) => typeof id === 'string' && idRegex.test(id)
-const shouldIncludeDocument = (document: SanityDocument) => !document._id.startsWith('system.')
+const shouldIncludeDocument = (document: SanityDocument) => {
+  // Filter out system documents
+  return !document._type.startsWith('system.')
+}
 
 async function* readerToGenerator(reader: ReadableStreamDefaultReader<Uint8Array>) {
   while (true) {
@@ -121,7 +124,7 @@ async function* readerToGenerator(reader: ReadableStreamDefaultReader<Uint8Array
 validateDocuments()
 
 async function loadWorkspace() {
-  const workspaces = await getStudioConfig({basePath: workDir, configPath})
+  const workspaces = await getStudioWorkspaces({basePath: workDir, configPath})
 
   if (!workspaces.length) {
     throw new Error(`Configuration did not return any workspaces.`)