sanity 3.93.1-next.16.586a638358 → 3.93.1-next.17.e9296c12d1

package/src/_internal/cli/commands/backup/downloadBackupCommand.ts

@@ -1,286 +0,0 @@
-import {createWriteStream, existsSync, mkdirSync} from 'node:fs'
-import {mkdtemp} from 'node:fs/promises'
-import {tmpdir} from 'node:os'
-import path from 'node:path'
-import {finished} from 'node:stream/promises'
-
-import {
-  type CliCommandArguments,
-  type CliCommandContext,
-  type CliCommandDefinition,
-  type SanityClient,
-} from '@sanity/cli'
-import {absolutify} from '@sanity/util/fs'
-import {Mutex} from 'async-mutex'
-import createDebug from 'debug'
-import {isString} from 'lodash'
-import prettyMs from 'pretty-ms'
-import {hideBin} from 'yargs/helpers'
-import yargs from 'yargs/yargs'
-
-import archiveDir from '../../actions/backup/archiveDir'
-import chooseBackupIdPrompt from '../../actions/backup/chooseBackupIdPrompt'
-import cleanupTmpDir from '../../actions/backup/cleanupTmpDir'
-import downloadAsset from '../../actions/backup/downloadAsset'
-import downloadDocument from '../../actions/backup/downloadDocument'
-import {type File, PaginatedGetBackupStream} from '../../actions/backup/fetchNextBackupPage'
-import parseApiErr from '../../actions/backup/parseApiErr'
-import newProgress from '../../actions/backup/progressSpinner'
-import resolveApiClient from '../../actions/backup/resolveApiClient'
-import humanFileSize from '../../util/humanFileSize'
-import isPathDirName from '../../util/isPathDirName'
-import {defaultApiVersion} from './backupGroup'
-
-const debug = createDebug('sanity:backup')
-
-const DEFAULT_DOWNLOAD_CONCURRENCY = 10
-const MAX_DOWNLOAD_CONCURRENCY = 24
-
-interface DownloadBackupOptions {
-  projectId: string
-  datasetName: string
-  token: string
-  backupId: string
-  outDir: string
-  outFileName: string
-  overwrite: boolean
-  concurrency: number
-}
-
-const helpText = `
-Options
-  --backup-id <string> The backup ID to download. (required)
-  --out <string>       The file or directory path the backup should download to.
-  --overwrite          Allows overwriting of existing backup file.
-  --concurrency <num>  Concurrent number of backup item downloads. (max: 24)
-
-Examples
-  sanity backup download DATASET_NAME --backup-id 2024-01-01-backup-1
-  sanity backup download DATASET_NAME --backup-id 2024-01-01-backup-2 --out /path/to/file
-  sanity backup download DATASET_NAME --backup-id 2024-01-01-backup-3 --out /path/to/file --overwrite
-`
-
-function parseCliFlags(args: {argv?: string[]}) {
-  return yargs(hideBin(args.argv || process.argv).slice(2))
-    .options('backup-id', {type: 'string'})
-    .options('out', {type: 'string'})
-    .options('concurrency', {type: 'number', default: DEFAULT_DOWNLOAD_CONCURRENCY})
-    .options('overwrite', {type: 'boolean', default: false}).argv
-}
-
-const downloadBackupCommand: CliCommandDefinition = {
-  name: 'download',
-  group: 'backup',
-  signature: '[DATASET_NAME]',
-  description: 'Download a dataset backup to a local file.',
-  helpText,
-  // eslint-disable-next-line max-statements
-  action: async (args, context) => {
-    const {output, chalk} = context
-    const [client, opts] = await prepareBackupOptions(context, args)
-    const {projectId, datasetName, backupId, outDir, outFileName} = opts
-
-    // If any of the output path or file name is empty, cancel the operation.
-    if (outDir === '' || outFileName === '') {
-      output.print('Operation cancelled.')
-      return
-    }
-    const outFilePath = path.join(outDir, outFileName)
-
-    output.print('╭───────────────────────────────────────────────────────────╮')
-    output.print('│                                                           │')
-    output.print('│ Downloading backup for:                                   │')
-    output.print(`│ ${chalk.bold('projectId')}: ${chalk.cyan(projectId).padEnd(56)} │`)
-    output.print(`│ ${chalk.bold('dataset')}: ${chalk.cyan(datasetName).padEnd(58)} │`)
-    output.print(`│ ${chalk.bold('backupId')}: ${chalk.cyan(backupId).padEnd(56)} │`)
-    output.print('│                                                           │')
-    output.print('╰───────────────────────────────────────────────────────────╯')
-    output.print('')
-    output.print(`Downloading backup to "${chalk.cyan(outFilePath)}"`)
-
-    const start = Date.now()
-    const progressSpinner = newProgress(output, 'Setting up backup environment...')
-
-    // Create a unique temporary directory to store files before bundling them into the archive at outputPath.
-    // Temporary directories are normally deleted at the end of backup process, any unexpected exit may leave them
-    // behind, hence it is important to create a unique directory for each attempt.
-    const tmpOutDir = await mkdtemp(path.join(tmpdir(), `sanity-backup-`))
-
-    // Create required directories if they don't exist.
-    for (const dir of [outDir, path.join(tmpOutDir, 'images'), path.join(tmpOutDir, 'files')]) {
-      mkdirSync(dir, {recursive: true})
-    }
-
-    debug('Writing to temporary directory %s', tmpOutDir)
-    const tmpOutDocumentsFile = path.join(tmpOutDir, 'data.ndjson')
-
-    // Handle concurrent writes to the same file using mutex.
-    const docOutStream = createWriteStream(tmpOutDocumentsFile)
-    const docWriteMutex = new Mutex()
-
-    try {
-      const backupFileStream = new PaginatedGetBackupStream(
-        client,
-        opts.projectId,
-        opts.datasetName,
-        opts.backupId,
-        opts.token,
-      )
-
-      const files: File[] = []
-      let i = 0
-      for await (const file of backupFileStream) {
-        files.push(file)
-        i++
-        progressSpinner.set({
-          step: `Reading backup files...`,
-          update: true,
-          current: i,
-          total: backupFileStream.totalFiles,
-        })
-      }
-
-      let totalItemsDownloaded = 0
-      // This is dynamically imported because this module is ESM only and this file gets compiled to CJS at this time.
-      const {default: pMap} = await import('p-map')
-      await pMap(
-        files,
-        async (file: File) => {
-          if (file.type === 'file' || file.type === 'image') {
-            await downloadAsset(file.url, file.name, file.type, tmpOutDir)
-          } else {
-            const doc = await downloadDocument(file.url)
-            await docWriteMutex.runExclusive(() => {
-              docOutStream.write(`${doc}\n`)
-            })
-          }
-
-          totalItemsDownloaded += 1
-          progressSpinner.set({
-            step: `Downloading documents and assets...`,
-            update: true,
-            current: totalItemsDownloaded,
-            total: backupFileStream.totalFiles,
-          })
-        },
-        {concurrency: opts.concurrency},
-      )
-    } catch (error) {
-      progressSpinner.fail()
-      const {message} = parseApiErr(error)
-      throw new Error(`Downloading dataset backup failed: ${message}`)
-    }
-
-    docOutStream.end()
-    await finished(docOutStream)
-
-    progressSpinner.set({step: `Archiving files into a tarball...`, update: true})
-    try {
-      await archiveDir(tmpOutDir, outFilePath, (processedBytes: number) => {
-        progressSpinner.update({
-          step: `Archiving files into a tarball, ${humanFileSize(processedBytes)} bytes written...`,
-        })
-      })
-    } catch (err) {
-      progressSpinner.fail()
-      throw new Error(`Archiving backup failed: ${err.message}`)
-    }
-
-    progressSpinner.set({
-      step: `Cleaning up temporary files at ${chalk.cyan(`${tmpOutDir}`)}`,
-    })
-    await cleanupTmpDir(tmpOutDir)
-
-    progressSpinner.set({
-      step: `Backup download complete [${prettyMs(Date.now() - start)}]`,
-    })
-    progressSpinner.succeed()
-  },
-}
-
-// prepareBackupOptions validates backup options from CLI and prepares Client and DownloadBackupOptions.
-async function prepareBackupOptions(
-  context: CliCommandContext,
-  args: CliCommandArguments,
-): Promise<[SanityClient, DownloadBackupOptions]> {
-  const flags = await parseCliFlags(args)
-  const [dataset] = args.argsWithoutOptions
-  const {prompt, workDir} = context
-  const {projectId, datasetName, client} = await resolveApiClient(
-    context,
-    dataset,
-    defaultApiVersion,
-  )
-
-  const {token} = client.config()
-  if (!isString(token) || token.length < 1) {
-    throw new Error(`token is missing`)
-  }
-
-  if (!isString(datasetName) || datasetName.length < 1) {
-    throw new Error(`dataset ${datasetName} must be a valid dataset name`)
-  }
-
-  const backupId = String(flags['backup-id'] || (await chooseBackupIdPrompt(context, datasetName)))
-  if (backupId.length < 1) {
-    throw new Error(`backup-id ${flags['backup-id']} should be a valid string`)
-  }
-
-  if ('concurrency' in flags) {
-    if (flags.concurrency < 1 || flags.concurrency > MAX_DOWNLOAD_CONCURRENCY) {
-      throw new Error(`concurrency should be in 1 to ${MAX_DOWNLOAD_CONCURRENCY} range`)
-    }
-  }
-
-  const defaultOutFileName = `${datasetName}-backup-${backupId}.tar.gz`
-  let out = await (async (): Promise<string> => {
-    if (flags.out !== undefined) {
-      // Rewrite the output path to an absolute path, if it is not already.
-      return absolutify(flags.out)
-    }
-
-    const input = await prompt.single({
-      type: 'input',
-      message: 'Output path:',
-      default: path.join(workDir, defaultOutFileName),
-      filter: absolutify,
-    })
-    return input
-  })()
-
-  // If path is a directory name, then add a default file name to the path.
-  if (isPathDirName(out)) {
-    out = path.join(out, defaultOutFileName)
-  }
-
-  // If the file already exists, ask for confirmation if it should be overwritten.
-  if (!flags.overwrite && existsSync(out)) {
-    const shouldOverwrite = await prompt.single({
-      type: 'confirm',
-      message: `File "${out}" already exists, would you like to overwrite it?`,
-      default: false,
-    })
-
-    // If the user does not want to overwrite the file, set the output path to an empty string.
-    // This should be handled by the caller of this function as cancel operation.
-    if (!shouldOverwrite) {
-      out = ''
-    }
-  }
-
-  return [
-    client,
-    {
-      projectId,
-      datasetName,
-      backupId,
-      token,
-      outDir: path.dirname(out),
-      outFileName: path.basename(out),
-      overwrite: flags.overwrite,
-      concurrency: flags.concurrency || DEFAULT_DOWNLOAD_CONCURRENCY,
-    },
-  ]
-}
-
-export default downloadBackupCommand

package/src/_internal/cli/commands/backup/enableBackupCommand.ts

@@ -1,52 +0,0 @@
-import {type CliCommandDefinition} from '@sanity/cli'
-
-import parseApiErr from '../../actions/backup/parseApiErr'
-import resolveApiClient from '../../actions/backup/resolveApiClient'
-import {defaultApiVersion} from './backupGroup'
-
-const helpText = `
-Examples
-  sanity backup enable DATASET_NAME
-`
-
-const enableDatasetBackupCommand: CliCommandDefinition = {
-  name: 'enable',
-  group: 'backup',
-  signature: '[DATASET_NAME]',
-  description: 'Enable backup for a dataset.',
-  helpText,
-  action: async (args, context) => {
-    const {output, chalk} = context
-    const [dataset] = args.argsWithoutOptions
-    const {projectId, datasetName, token, client} = await resolveApiClient(
-      context,
-      dataset,
-      defaultApiVersion,
-    )
-
-    try {
-      await client.request({
-        method: 'PUT',
-        headers: {Authorization: `Bearer ${token}`},
-        uri: `/projects/${projectId}/datasets/${datasetName}/settings/backups`,
-        body: {
-          enabled: true,
-        },
-      })
-
-      output.print(
-        `${chalk.green(
-          `Enabled backups for dataset ${datasetName}.\nPlease note that it may take up to 24 hours before the first backup is created.\n`,
-        )}`,
-      )
-
-      output.print(
-        `${chalk.bold(`Retention policies may apply depending on your plan and agreement.\n`)}`,
-      )
-    } catch (error) {
-      const {message} = parseApiErr(error)
-      output.print(`${chalk.red(`Enabling dataset backup failed: ${message}`)}\n`)
-    }
-  },
-}
-export default enableDatasetBackupCommand

package/src/_internal/cli/commands/backup/listBackupCommand.ts

@@ -1,149 +0,0 @@
-import {type CliCommandDefinition} from '@sanity/cli'
-import {Table} from 'console-table-printer'
-import {isAfter, isValid, lightFormat, parse} from 'date-fns'
-import {hideBin} from 'yargs/helpers'
-import yargs from 'yargs/yargs'
-
-import parseApiErr from '../../actions/backup/parseApiErr'
-import resolveApiClient from '../../actions/backup/resolveApiClient'
-import {defaultApiVersion} from './backupGroup'
-
-const DEFAULT_LIST_BACKUP_LIMIT = 30
-
-interface ListDatasetBackupFlags {
-  before?: string
-  after?: string
-  limit?: string
-}
-
-type ListBackupRequestQueryParams = {
-  before?: string
-  after?: string
-  limit: string
-}
-
-type ListBackupResponse = {
-  backups: ListBackupResponseItem[]
-}
-
-type ListBackupResponseItem = {
-  id: string
-  createdAt: string
-}
-
-const helpText = `
-Options
-  --limit <int>     Maximum number of backups returned. Default 30.
-  --after <string>  Only return backups after this date (inclusive)
-  --before <string> Only return backups before this date (exclusive). Cannot be younger than <after> if specified.
-
-Examples
-  sanity backup list DATASET_NAME
-  sanity backup list DATASET_NAME --limit 50
-  sanity backup list DATASET_NAME --after 2024-01-31 --limit 10
-  sanity backup list DATASET_NAME --after 2024-01-31 --before 2024-01-10
-`
-
-function parseCliFlags(args: {argv?: string[]}) {
-  return yargs(hideBin(args.argv || process.argv).slice(2))
-    .options('after', {type: 'string'})
-    .options('before', {type: 'string'})
-    .options('limit', {type: 'number', default: DEFAULT_LIST_BACKUP_LIMIT, alias: 'l'}).argv
-}
-
-const listDatasetBackupCommand: CliCommandDefinition<ListDatasetBackupFlags> = {
-  name: 'list',
-  group: 'backup',
-  signature: '[DATASET_NAME]',
-  description: 'List available backups for a dataset.',
-  helpText,
-  action: async (args, context) => {
-    const {output, chalk} = context
-    const flags = await parseCliFlags(args)
-    const [dataset] = args.argsWithoutOptions
-
-    const {projectId, datasetName, token, client} = await resolveApiClient(
-      context,
-      dataset,
-      defaultApiVersion,
-    )
-
-    const query: ListBackupRequestQueryParams = {limit: DEFAULT_LIST_BACKUP_LIMIT.toString()}
-    if (flags.limit) {
-      // We allow limit up to Number.MAX_SAFE_INTEGER to leave it for server-side validation,
-      //  while still sending sensible value in limit string.
-      if (flags.limit < 1 || flags.limit > Number.MAX_SAFE_INTEGER) {
-        throw new Error(
-          `Parsing --limit: must be an integer between 1 and ${Number.MAX_SAFE_INTEGER}`,
-        )
-      }
-      query.limit = flags.limit.toString()
-    }
-
-    if (flags.before || flags.after) {
-      try {
-        const parsedBefore = processDateFlags(flags.before)
-        const parsedAfter = processDateFlags(flags.after)
-
-        if (parsedAfter && parsedBefore && isAfter(parsedAfter, parsedBefore)) {
-          throw new Error('--after date must be before --before')
-        }
-
-        query.before = flags.before
-        query.after = flags.after
-      } catch (err) {
-        throw new Error(`Parsing date flags: ${err}`)
-      }
-    }
-
-    let response
-    try {
-      response = await client.request<ListBackupResponse>({
-        headers: {Authorization: `Bearer ${token}`},
-        uri: `/projects/${projectId}/datasets/${datasetName}/backups`,
-        query: {...query},
-      })
-    } catch (error) {
-      const {message} = parseApiErr(error)
-      output.error(`${chalk.red(`List dataset backup failed: ${message}`)}\n`)
-    }
-
-    if (response && response.backups) {
-      if (response.backups.length === 0) {
-        output.print('No backups found.')
-        return
-      }
-
-      const table = new Table({
-        columns: [
-          {name: 'resource', title: 'RESOURCE', alignment: 'left'},
-          {name: 'createdAt', title: 'CREATED AT', alignment: 'left'},
-          {name: 'backupId', title: 'BACKUP ID', alignment: 'left'},
-        ],
-      })
-
-      response.backups.forEach((backup: ListBackupResponseItem) => {
-        const {id, createdAt} = backup
-        table.addRow({
-          resource: 'Dataset',
-          createdAt: lightFormat(Date.parse(createdAt), 'yyyy-MM-dd HH:mm:ss'),
-          backupId: id,
-        })
-      })
-
-      table.printTable()
-    }
-  },
-}
-
-function processDateFlags(date: string | undefined): Date | undefined {
-  if (!date) return undefined
-  const parsedDate = parse(date, 'yyyy-MM-dd', new Date())
-  if (isValid(parsedDate)) {
-    return parsedDate
-  }
-
-  throw new Error(`Invalid ${date} date format. Use YYYY-MM-DD`)
-}
-
-export default listDatasetBackupCommand

package/src/_internal/cli/commands/build/buildCommand.ts

@@ -1,60 +0,0 @@
-import type {CliCommandArguments, CliCommandContext, CliCommandDefinition} from '@sanity/cli'
-import {BuildSanityStudioCommandFlags} from '../../actions/build/buildAction'
-import {determineIsApp} from '../../util/determineIsApp'
-
-const helpText = `
-Options
-  --source-maps Enable source maps for built bundles (increases size of bundle)
-  --no-minify Skip minifying built JavaScript (speeds up build, increases size of bundle)
-  -y, --yes Unattended mode, answers "yes" to any "yes/no" prompt and otherwise uses defaults
-  --schema-path If you are storing your schemas in a different path than the default one, you need to specify it here.
-
-Examples
-  sanity build
-  sanity build --no-minify --source-maps
-`
-
-const buildCommand: CliCommandDefinition = {
-  name: 'build',
-  signature: '[OUTPUT_DIR]',
-  description: 'Builds the Sanity Studio configuration into a static bundle',
-  action: async (
-    args: CliCommandArguments<BuildSanityStudioCommandFlags>,
-    context: CliCommandContext,
-    overrides?: {basePath?: string},
-  ) => {
-    const buildAction = await getBuildAction(context)
-
-    return buildAction(args, context, overrides)
-  },
-  helpText,
-}
-
-async function getBuildAction(context: CliCommandContext) {
-  const isApp = determineIsApp(context.cliConfig)
-  // NOTE: in dev-mode we want to include from `src` so we need to use `.ts` extension
-  // NOTE: this `if` statement is not included in the output bundle
-  if (__DEV__) {
-    if (isApp) {
-      // eslint-disable-next-line import/extensions
-      const mod: typeof import('../../actions/app/buildAction') = require('../../actions/app/buildAction.ts')
-      return mod.default
-    }
-
-    // eslint-disable-next-line import/extensions
-    const mod: typeof import('../../actions/build/buildAction') = require('../../actions/build/buildAction.ts')
-
-    return mod.default
-  }
-
-  if (isApp) {
-    const mod = await import('../../actions/app/buildAction')
-    return mod.default
-  }
-
-  const mod = await import('../../actions/build/buildAction')
-
-  return mod.default
-}
-
-export default buildCommand

package/src/_internal/cli/commands/cors/addCorsOriginCommand.ts

@@ -1,47 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-
-import {type CliCommandDefinition} from '@sanity/cli'
-
-import {addCorsOrigin} from '../../actions/cors/addCorsOrigin'
-
-const helpText = `
-Options
-  --credentials Allow credentials (token/cookie) to be sent from this origin
-  --no-credentials Disallow credentials (token/cookie) to be sent from this origin
-
-Examples
-  sanity cors add
-  sanity cors add http://localhost:3000 --no-credentials
-`
-
-const addCorsOriginCommand: CliCommandDefinition = {
-  name: 'add',
-  group: 'cors',
-  signature: '[ORIGIN]',
-  helpText,
-  description: 'Allow a new origin to use your project API through CORS',
-  action: async (args, context) => {
-    const {output} = context
-    const [origin] = args.argsWithoutOptions
-
-    if (!origin) {
-      throw new Error('No origin specified, use `sanity cors add <origin-url>`')
-    }
-
-    const flags = args.extOptions
-
-    // eslint-disable-next-line no-sync
-    const isFile = fs.existsSync(path.join(process.cwd(), origin))
-    if (isFile) {
-      output.warn(`Origin "${origin}?" Remember to quote values (sanity cors add "*")`)
-    }
-
-    const success = await addCorsOrigin(origin, flags, context)
-    if (success) {
-      output.print('CORS origin added successfully')
-    }
-  },
-}
-
-export default addCorsOriginCommand

package/src/_internal/cli/commands/cors/corsGroup.ts

@@ -1,10 +0,0 @@
-import {type CliCommandGroupDefinition} from '@sanity/cli'
-
-const corsGroup: CliCommandGroupDefinition = {
-  name: 'cors',
-  signature: '[COMMAND]',
-  isGroupRoot: true,
-  description: 'Configures CORS settings for Sanity projects',
-}
-
-export default corsGroup

package/src/_internal/cli/commands/cors/deleteCorsOriginCommand.ts

@@ -1,54 +0,0 @@
-import {type CliCommandContext, type CliCommandDefinition} from '@sanity/cli'
-
-import {type CorsOrigin} from './types'
-
-const helpText = `
-Examples
-  sanity cors delete
-  sanity cors delete http://localhost:3000
-`
-
-const deleteCorsOriginCommand: CliCommandDefinition = {
-  name: 'delete',
-  group: 'cors',
-  signature: '[ORIGIN]',
-  helpText,
-  description: 'Delete an existing CORS-origin from your project',
-  action: async (args, context) => {
-    const {output, apiClient} = context
-    const [origin] = args.argsWithoutOptions
-    const client = apiClient({requireUser: true, requireProject: true})
-    const originId = await promptForOrigin(origin, context)
-    try {
-      await client.request({method: 'DELETE', uri: `/cors/${originId}`})
-      output.print('Origin deleted')
-    } catch (err) {
-      throw new Error(`Origin deletion failed:\n${err.message}`)
-    }
-  },
-}
-
-export default deleteCorsOriginCommand
-
-async function promptForOrigin(specified: string | undefined, context: CliCommandContext) {
-  const specifiedOrigin = specified && specified.toLowerCase()
-  const {prompt, apiClient} = context
-  const client = apiClient({requireUser: true, requireProject: true})
-
-  const origins = await client.request<CorsOrigin[]>({url: '/cors'})
-  if (specifiedOrigin) {
-    const selected = origins.filter((origin) => origin.origin.toLowerCase() === specifiedOrigin)[0]
-    if (!selected) {
-      throw new Error(`Origin "${specified} not found"`)
-    }
-
-    return selected.id
-  }
-
-  const choices = origins.map((origin) => ({value: origin.id, name: origin.origin}))
-  return prompt.single({
-    message: 'Select origin to delete',
-    type: 'list',
-    choices,
-  })
-}

package/src/_internal/cli/commands/cors/listCorsOriginsCommand.ts

@@ -1,25 +0,0 @@
-import {type CliCommandDefinition} from '@sanity/cli'
-
-import {type CorsOrigin} from './types'
-
-const helpText = `
-Examples
-  sanity cors list
-`
-
-const listCorsOriginsCommand: CliCommandDefinition = {
-  name: 'list',
-  group: 'cors',
-  signature: '',
-  helpText,
-  description: 'List all origins allowed to access the API for this project',
-  action: async (args, context) => {
-    const {output} = context
-    const {apiClient} = context
-    const client = apiClient({requireUser: true, requireProject: true})
-    const origins = await client.request<CorsOrigin[]>({url: '/cors'})
-    output.print(origins.map((origin) => origin.origin).join('\n'))
-  },
-}
-
-export default listCorsOriginsCommand