@sanity/cli 3.93.0 → 3.93.1-bump-pkg-utils.34.5d0c0b3d22

package/src/commands/debug/printDebugInfo.ts

@@ -1,243 +0,0 @@
-import os from 'node:os'
-import path from 'node:path'
-import util from 'node:util'
-
-import {type SanityProject, type SanityProjectMember} from '@sanity/client'
-import {omit, pick} from 'lodash'
-import promiseProps from 'promise-props-recursive'
-import xdgBasedir from 'xdg-basedir'
-
-import {
-  findSanityModuleVersions,
-  type ModuleVersionResult,
-} from '../../actions/versions/findSanityModuleVersions'
-import {
-  type CliCommandAction,
-  type CliCommandContext,
-  type CliUserConfig,
-  type SanityJson,
-} from '../../types'
-import {getCliToken} from '../../util/clientWrapper'
-import {getUserConfig} from '../../util/getUserConfig'
-import {printResult as printVersionsResult} from '../versions/printVersionResult'
-
-export const printDebugInfo: CliCommandAction = async (args, context) => {
-  const flags = args.extOptions
-  const {user, globalConfig, projectConfig, project, versions} = await gatherInfo(context)
-  const {chalk} = context
-
-  // User info
-  context.output.print('\nUser:')
-  if (user instanceof Error) {
-    context.output.print(`  ${chalk.red(user.message)}\n`)
-  } else {
-    printKeyValue(
-      {
-        ID: user.id,
-        Name: user.name,
-        Email: user.email,
-        Roles: project ? project.userRoles : undefined,
-      },
-      context,
-    )
-  }
-
-  // Project info (API-based)
-  if (project) {
-    context.output.print('Project:')
-    printKeyValue(
-      {
-        'ID': project.id,
-        'Display name': project.displayName,
-        'Studio URL': project.studioHostname,
-      },
-      context,
-    )
-  }
-
-  // Auth info
-  // eslint-disable-next-line no-process-env
-  const authToken = process.env.SANITY_AUTH_TOKEN || globalConfig.authToken
-  if (authToken) {
-    context.output.print('Authentication:')
-    printKeyValue(
-      {
-        'User type': globalConfig.authType || 'normal',
-        'Auth token': flags.secrets ? authToken : `<redacted>`,
-      },
-      context,
-    )
-
-    if (!flags.secrets) {
-      context.output.print('  (run with --secrets to reveal token)\n')
-    }
-  }
-
-  // Global configuration (user home dir config file)
-  context.output.print(`Global config (${chalk.yellow(getGlobalConfigLocation())}):`)
-  const globalCfg = omit(globalConfig, ['authType', 'authToken'])
-  context.output.print(`  ${formatObject(globalCfg).replace(/\n/g, '\n  ')}\n`)
-
-  // Project configuration (projectDir/sanity.json)
-  if (projectConfig) {
-    const configLocation = context.cliConfigPath
-      ? ` (${chalk.yellow(path.relative(process.cwd(), context.cliConfigPath))})`
-      : ''
-
-    context.output.print(`Project config${configLocation}:`)
-    context.output.print(`  ${formatObject(projectConfig).replace(/\n/g, '\n  ')}`)
-  }
-
-  // Print installed package versions
-  if (versions) {
-    context.output.print('\nPackage versions:')
-    printVersionsResult(versions, (line) => context.output.print(`  ${line}`))
-    context.output.print('')
-  }
-}
-
-function formatObject(obj: Record<string, any>): string {
-  return util.inspect(obj, {colors: true, depth: +Infinity})
-}
-
-function printKeyValue(obj: Record<string, any>, context: CliCommandContext): void {
-  let printedLines = 0
-  Object.keys(obj).forEach((key) => {
-    if (typeof obj[key] !== 'undefined') {
-      context.output.print(`  ${key}: ${formatObject(obj[key])}`)
-      printedLines++
-    }
-  })
-
-  if (printedLines > 0) {
-    context.output.print('')
-  }
-}
-
-interface Configs {
-  globalConfig: CliUserConfig
-  projectConfig: SanityJson
-}
-
-interface UserInfo {
-  id: string
-  name: string
-  email: string
-}
-
-interface ProjectInfo {
-  id: string
-  displayName: string
-  studioHostname?: string | null
-  userRoles: string[]
-}
-
-interface ConfigsWithUser extends Configs {
-  user: UserInfo | Error
-}
-
-interface DebugInfo extends ConfigsWithUser {
-  project: ProjectInfo
-  versions: ModuleVersionResult[]
-}
-
-interface SanityRole {
-  name: string
-  title: string
-  description: string
-}
-
-interface SanityProjectWithRoles extends SanityProject {
-  members: (SanityProjectMember & {roles: SanityRole[]})[]
-}
-
-async function gatherInfo(context: CliCommandContext): Promise<DebugInfo> {
-  const baseInfo = await promiseProps<Configs>({
-    globalConfig: gatherGlobalConfigInfo(),
-    projectConfig: gatherProjectConfigInfo(context),
-  })
-
-  const withUser: ConfigsWithUser = {
-    ...baseInfo,
-    user: await gatherUserInfo(context, {
-      projectBased: Boolean(baseInfo.projectConfig && baseInfo.projectConfig.api),
-    }),
-  }
-
-  return promiseProps<DebugInfo>({
-    project: gatherProjectInfo(context, withUser),
-    versions: findSanityModuleVersions(context, {target: 'latest'}),
-    ...withUser,
-  })
-}
-
-function getGlobalConfigLocation(): string {
-  const user = (os.userInfo().username || 'user').replace(/\\/g, '')
-  const configDir = xdgBasedir.config || path.join(os.tmpdir(), user, '.config')
-  return path.join(configDir, 'sanity', 'config.json')
-}
-
-function gatherGlobalConfigInfo(): CliUserConfig {
-  return getUserConfig().all
-}
-
-function gatherProjectConfigInfo(context: CliCommandContext): SanityJson | {error: string} | null {
-  const {cliConfig} = context
-  if (cliConfig?.api?.projectId) {
-    return cliConfig
-  }
-
-  return {
-    error: `Missing required "api.projectId" key`,
-  }
-}
-
-async function gatherProjectInfo(
-  context: CliCommandContext,
-  baseInfo: ConfigsWithUser,
-): Promise<ProjectInfo | null | Error> {
-  const projectClient = context.apiClient({requireUser: false, requireProject: false})
-  const projectId = projectClient.config().projectId
-  const hasToken = Boolean(getCliToken())
-  if (!projectId || !hasToken) {
-    return null
-  }
-
-  const client = context
-    .apiClient({requireUser: true, requireProject: false})
-    .withConfig({apiVersion: '2023-06-06'})
-
-  const projectInfo = await client.request<SanityProjectWithRoles>({url: `/projects/${projectId}`})
-  if (!projectInfo) {
-    return new Error(`Project specified in configuration (${projectId}) does not exist in API`)
-  }
-
-  const userId = baseInfo.user instanceof Error ? null : baseInfo.user.id
-  const host = projectInfo.studioHost
-  const member = (projectInfo.members || []).find((user) => user.id === userId)
-  const hostname = host && `https://${host}.sanity.studio/`
-  return {
-    id: projectId,
-    displayName: projectInfo.displayName,
-    studioHostname: hostname,
-    userRoles: member ? member.roles.map((role) => role.name) : ['<none>'],
-  }
-}
-
-async function gatherUserInfo(
-  context: CliCommandContext,
-  options: {projectBased: boolean},
-): Promise<UserInfo | Error> {
-  const hasToken = Boolean(getCliToken())
-  if (!hasToken) {
-    return new Error('Not logged in')
-  }
-
-  const client = context.apiClient({requireUser: true, requireProject: options.projectBased})
-  const userInfo = await client.users.getById('me')
-  if (!userInfo) {
-    return new Error('Token expired or invalid')
-  }
-
-  return pick(userInfo, ['id', 'name', 'email'])
-}

package/src/commands/docs/docsCommand.ts

@@ -1,20 +0,0 @@
-import open from 'open'
-
-import {type CliCommandDefinition} from '../../types'
-
-const docsCommand: CliCommandDefinition = {
-  name: 'docs',
-  helpText: '',
-  signature: 'docs',
-  description: 'Opens Sanity Studio documentation in your web browser',
-  async action(args, context) {
-    const {output} = context
-    const {print} = output
-    const url = 'https://www.sanity.io/docs'
-
-    print(`Opening ${url}`)
-    await open(url)
-  },
-}
-
-export default docsCommand

package/src/commands/functions/devFunctionsCommand.ts

@@ -1,73 +0,0 @@
-import open from 'open'
-
-import {type CliCommandDefinition} from '../../types'
-
-const helpText = `
-Options
-  --port <port> Port to start emulator on
-  --open Open dev server in a new browser tab
-
-Examples
-  # Start dev server on default port
-  sanity functions dev
-
-  # Start dev server on specific port
-  sanity functions dev --port 3333
-
-  # Start dev server and open a new browser tab
-  sanity functions dev --open
-`
-
-export interface FunctionsDevFlags {
-  open?: boolean
-  port?: number
-}
-
-const defaultFlags: FunctionsDevFlags = {
-  open: false,
-  port: 8080,
-}
-
-const devFunctionsCommand: CliCommandDefinition<FunctionsDevFlags> = {
-  name: 'dev',
-  group: 'functions',
-  helpText,
-  signature: '[--port <port> --open]',
-  description: 'Start the Sanity Function emulator',
-  async action(args, context) {
-    const {apiClient, output} = context
-    const flags = {...defaultFlags, ...args.extOptions}
-    const {open: shouldOpen} = flags
-
-    const client = apiClient({requireUser: true, requireProject: false})
-    const {token} = client.config()
-
-    if (!token) throw new Error('No API token found. Please run `sanity login`.')
-
-    const {initBlueprintConfig} = await import('@sanity/runtime-cli/cores')
-    const {functionDevCore} = await import('@sanity/runtime-cli/cores/functions')
-
-    const cmdConfig = await initBlueprintConfig({
-      bin: 'sanity',
-      log: (message) => output.print(message),
-      token,
-    })
-
-    if (!cmdConfig.ok) throw new Error(cmdConfig.error)
-
-    const {success, error} = await functionDevCore({
-      ...cmdConfig.value,
-      flags: {
-        port: flags.port,
-      },
-    })
-
-    if (!success) throw new Error(error)
-
-    if (shouldOpen) {
-      open(`http://localhost:${flags.port}`)
-    }
-  },
-}
-
-export default devFunctionsCommand

package/src/commands/functions/envFunctionsCommand.ts

@@ -1,105 +0,0 @@
-import {type CliCommandDefinition} from '../../types'
-
-const helpText = `
-Commands
-  add    Add or update an environment variable
-  list   List the environment variables
-  remove Remove an environment variable
-
-Arguments
-  <name> The name of the function
-  <key> The name of the environment variable
-  <value> The value of the environment variable
-
-Examples
-  # Add or update an environment variable
-  sanity functions env add echo API_URL https://api.example.com/
-
-  # Remove an environment variable
-  sanity functions env remove echo API_URL
-
-  # List environment variables
-  sanity functions env list echo
-`
-
-export interface FunctionsEnvFlags {
-  //
-}
-
-const envFunctionsCommand: CliCommandDefinition<FunctionsEnvFlags> = {
-  name: 'env',
-  group: 'functions',
-  helpText,
-  signature: '<add|list|remove> <name> [key] [value]',
-  description:
-    'Add or remove an environment variable or list environment variables for a Sanity function',
-  async action(args, context) {
-    const {apiClient, output} = context
-    const [subCommand, name, key, value] = args.argsWithoutOptions
-
-    if (!subCommand || !['add', 'list', 'remove'].includes(subCommand)) {
-      throw new Error('You must specify if you want to list, add or remove')
-    }
-
-    if (subCommand === 'add' && (!key || !value)) {
-      throw new Error('You must specify the name, key and value arguments')
-    } else if (subCommand === 'remove' && !key) {
-      throw new Error('You must specify the name and key arguments')
-    }
-
-    const client = apiClient({
-      requireUser: true,
-      requireProject: false,
-    })
-
-    if (!name) {
-      throw new Error('You must provide a function name as the first argument')
-    }
-
-    const token = client.config().token
-    if (!token) throw new Error('No API token found. Please run `sanity login`.')
-
-    const {initDeployedBlueprintConfig} = await import('@sanity/runtime-cli/cores')
-    const {functionEnvAddCore, functionEnvListCore, functionEnvRemoveCore} = await import(
-      '@sanity/runtime-cli/cores/functions'
-    )
-
-    const cmdConfig = await initDeployedBlueprintConfig({
-      bin: 'sanity',
-      log: (message) => output.print(message),
-      token,
-    })
-
-    if (!cmdConfig.ok) throw new Error(cmdConfig.error)
-
-    let response
-    switch (subCommand) {
-      case 'add':
-        response = await functionEnvAddCore({
-          ...cmdConfig.value,
-          args: {name, key, value},
-        })
-        break
-      case 'list':
-        response = await functionEnvListCore({
-          ...cmdConfig.value,
-          args: {name},
-        })
-        break
-      case 'remove':
-        response = await functionEnvRemoveCore({
-          ...cmdConfig.value,
-          args: {name, key},
-        })
-        break
-      default:
-        throw new Error(`Unknown subcommand: ${subCommand}`)
-    }
-
-    const {success, error} = response
-
-    if (!success) throw new Error(error)
-  },
-}
-
-export default envFunctionsCommand

package/src/commands/functions/functionsGroup.ts

@@ -1,10 +0,0 @@
-import {type CliCommandGroupDefinition} from '../../types'
-
-const functionsGroup: CliCommandGroupDefinition = {
-  name: 'functions',
-  signature: '[COMMAND]',
-  isGroupRoot: true,
-  description: 'Manage, test, and observe Sanity Functions',
-}
-
-export default functionsGroup

package/src/commands/functions/logsFunctionsCommand.ts

@@ -1,94 +0,0 @@
-import {type CliCommandDefinition} from '../../types'
-
-const helpText = `
-Arguments
-  <name> The name of the Function to retrieve logs for
-
-Options
-  --limit <limit> The number of log entries to retrieve [default 50]
-  --json          If set return json
-  --utc           Use UTC dates in logs
-  --delete        Delete all logs for the Function
-  --force         Force delete all logs for the Function
-  --watch         Watch for new logs (streaming mode)
-
-Examples
-  # Retrieve logs for Sanity Function
-  sanity functions logs echo
-
-  # Retrieve the last two log entries for Sanity Function
-  sanity functions logs echo --limit 2
-
-  # Retrieve logs for Sanity Function in json format
-  sanity functions logs echo --json
-
-  # Delete all logs for Sanity Function
-  sanity functions logs echo --delete
-
-  # Watch for new logs (streaming mode)
-  sanity functions logs echo --watch
-`
-
-export interface FunctionsLogsFlags {
-  limit?: number
-  json?: boolean
-  utc?: boolean
-  delete?: boolean
-  force?: boolean
-  watch?: boolean // undocumented for now
-}
-
-const defaultFlags = {
-  limit: 50,
-  json: false,
-  utc: false,
-  delete: false,
-  force: false,
-  watch: false,
-}
-
-const logsFunctionsCommand: CliCommandDefinition<FunctionsLogsFlags> = {
-  name: 'logs',
-  group: 'functions',
-  helpText,
-  signature: '<name> [--limit <number>] [--json] [--utc] [--delete [--force]] [--watch]',
-  description: 'Retrieve or delete logs for a Sanity Function',
-  async action(args, context) {
-    const {apiClient, output} = context
-    const [name] = args.argsWithoutOptions
-    const flags = {...defaultFlags, ...args.extOptions}
-
-    const client = apiClient({
-      requireUser: true,
-      requireProject: false,
-    })
-
-    if (!name) {
-      throw new Error('You must provide a function name as the first argument')
-    }
-
-    const token = client.config().token
-    if (!token) throw new Error('No API token found. Please run `sanity login`.')
-
-    const {initDeployedBlueprintConfig} = await import('@sanity/runtime-cli/cores')
-    const {functionLogsCore} = await import('@sanity/runtime-cli/cores/functions')
-
-    const cmdConfig = await initDeployedBlueprintConfig({
-      bin: 'sanity',
-      log: (message) => output.print(message),
-      token,
-    })
-
-    if (!cmdConfig.ok) throw new Error(cmdConfig.error)
-
-    const {success, error} = await functionLogsCore({
-      ...cmdConfig.value,
-      args: {name},
-      flags,
-    })
-
-    if (!success) throw new Error(error)
-  },
-}
-
-export default logsFunctionsCommand

package/src/commands/functions/testFunctionsCommand.ts

@@ -1,93 +0,0 @@
-import {type CliCommandDefinition} from '../../types'
-
-const helpText = `
-Arguments
-  <name> The name of the Sanity Function
-
-Options
-  --data <data> Data to send to the function
-  --file <file> Read data from file and send to the function
-  --timeout <timeout> Execution timeout value in seconds
-  --api <version> Sanity API Version to use
-  --dataset <dataset> The Sanity dataset to use
-  --project-id <id> Sanity Project ID to use
-
-
-Examples
-  # Test function passing event data on command line
-  sanity functions test echo --data '{ "id": 1 }'
-
-  # Test function passing event data via a file
-  sanity functions test echo --file 'payload.json'
-
-  # Test function passing event data on command line and cap execution time to 60 seconds
-  sanity functions test echo --data '{ "id": 1 }' --timeout 60
-`
-
-export interface FunctionsTestFlags {
-  'data'?: string
-  'file'?: string
-  'timeout'?: number
-  'api'?: string
-  'dataset'?: string
-  'project-id'?: string
-}
-
-const defaultFlags: FunctionsTestFlags = {
-  timeout: 10, // seconds
-}
-
-const testFunctionsCommand: CliCommandDefinition<FunctionsTestFlags> = {
-  name: 'test',
-  group: 'functions',
-  helpText,
-  signature:
-    '<name> [--data <json>] [--file <filename>] [--timeout <seconds>] [--api <version>] [--dataset <name>] [--project-id] <id>]',
-  description: 'Invoke a local Sanity Function',
-  async action(args, context) {
-    const {apiClient, output} = context
-    const [name] = args.argsWithoutOptions
-    const flags = {...defaultFlags, ...args.extOptions}
-
-    const client = apiClient({
-      requireUser: true,
-      requireProject: false,
-    })
-    const {dataset, projectId, token} = client.config()
-    const actualDataset = dataset === '~dummy-placeholder-dataset-' ? undefined : dataset
-
-    if (!token) throw new Error('No API token found. Please run `sanity login`.')
-
-    if (!name) {
-      throw new Error('You must provide a function name as the first argument')
-    }
-
-    const {initBlueprintConfig} = await import('@sanity/runtime-cli/cores')
-    const {functionTestCore} = await import('@sanity/runtime-cli/cores/functions')
-
-    const cmdConfig = await initBlueprintConfig({
-      bin: 'sanity',
-      log: (message: string) => output.print(message),
-      token,
-    })
-
-    if (!cmdConfig.ok) throw new Error(cmdConfig.error)
-
-    const {success, error} = await functionTestCore({
-      ...cmdConfig.value,
-      args: {name},
-      flags: {
-        'data': flags.data,
-        'file': flags.file,
-        'timeout': flags.timeout,
-        'api': flags.api,
-        'dataset': flags.dataset || actualDataset,
-        'project-id': flags['project-id'] || projectId,
-      },
-    })
-
-    if (!success) throw new Error(error)
-  },
-}
-
-export default testFunctionsCommand

package/src/commands/help/helpCommand.ts

@@ -1,21 +0,0 @@
-import {type CliCommandDefinition} from '../../types'
-import showHelp from './showHelp'
-
-const help = `
-With no options and no COMMAND given, the synopsis of the sanity command and a
-list of the most commonly used commands are printed on the standard output.
-
-If a command is given, the help page for that command is printed to standard
-output. This will usually be more in-depth than the brief description shown in
-the command list.
-`
-
-const command: CliCommandDefinition = {
-  name: 'help',
-  signature: '[COMMAND]',
-  description: 'Displays help information about Sanity CLI commands',
-  action: showHelp,
-  helpText: help,
-}
-
-export default command