@sanity/cli 3.93.1-next.8.cf0bf8550a → 3.94.0

package/src/packageManager/yarnStub.ts

@@ -1,22 +0,0 @@
-import {type CliCommandContext, type CliYarnOptions} from '../types'
-import {installDeclaredPackages, installNewPackages} from './installPackages'
-import {getPackageManagerChoice} from './packageManagerChoice'
-import {uninstallPackages} from './uninstallPackages'
-
-export function getYarnStub(context: Pick<CliCommandContext, 'output' | 'workDir'>) {
-  return async function yarnStub(args: string[], options?: CliYarnOptions): Promise<void> {
-    const workDir = options?.rootDir || context.workDir
-    const yarnContext = {workDir, output: context.output}
-    const {chosen} = await getPackageManagerChoice(workDir, {interactive: false})
-    const [command, ...packages] = args
-    if (command === 'add') {
-      await installNewPackages({packageManager: chosen, packages}, yarnContext)
-    } else if (command === 'remove') {
-      await uninstallPackages({packageManager: chosen, packages}, yarnContext)
-    } else if (command === 'install') {
-      await installDeclaredPackages(workDir, chosen, yarnContext)
-    } else {
-      throw new Error(`Unsupported package manager command "${command}"`)
-    }
-  }
-}

package/src/prompters/cliPrompter.ts

@@ -1,9 +0,0 @@
-import inquirer, {type Answers, type DistinctQuestion} from 'inquirer'
-
-export function prompt<T extends Answers = Answers>(questions: DistinctQuestion<T>[]): Promise<T> {
-  return inquirer.prompt(questions)
-}
-
-prompt.Separator = inquirer.Separator
-prompt.single = <T = string>(question: DistinctQuestion) =>
-  prompt<{value: T}>([{...question, name: 'value'}]).then((answers) => answers.value)

package/src/run.ts

@@ -1,8 +0,0 @@
-import path from 'node:path'
-
-import {runCli} from './cli'
-import {getCliVersion} from './util/getCliVersion'
-
-getCliVersion().then((cliVersion) => {
-  runCli(path.join(__dirname, '..'), {cliVersion})
-})

package/src/studioDependencies.ts

@@ -1,25 +0,0 @@
-export const studioDependencies = {
-  // Dependencies for a default Sanity installation
-  dependencies: {
-    // Official studio dependencies
-    'sanity': 'latest',
-
-    // Official studio plugin dependencies
-    '@sanity/vision': 'latest',
-
-    // Non-Sanity dependencies
-    'react': '^19.1',
-    'react-dom': '^19.1',
-    'styled-components': '^6.1.18',
-  },
-
-  devDependencies: {
-    // Linting/tooling
-    '@sanity/eslint-config-studio': 'latest',
-    // When using typescript, we'll want the these types too, so might as well install them
-    '@types/react': '^19.1',
-    'eslint': '^9.28',
-    'prettier': '^3.5',
-    'typescript': '^5.8', // Peer dependency of eslint-config-studio (implicitly)
-  },
-}

package/src/types.ts

@@ -1,387 +0,0 @@
-import {type SanityClient} from '@sanity/client'
-import {type TelemetryLogger} from '@sanity/telemetry'
-import type chalk from 'chalk'
-import {type Answers, type ChoiceCollection, type DistinctQuestion, type Separator} from 'inquirer'
-import {type Options, type Ora} from 'ora'
-import {type ConfigEnv, type InlineConfig} from 'vite'
-
-import {type CliPackageManager} from './packageManager'
-import {type ClientRequirements} from './util/clientWrapper'
-import {type CliConfigResult} from './util/getCliConfig'
-
-export interface SanityCore {
-  requiredCliVersionRange: string
-  commands: (CliCommandDefinition | CliCommandGroupDefinition)[]
-}
-
-export interface SanityModuleInternal {
-  cliProjectCommands: {
-    requiredCliVersionRange: string
-    commands: (CliCommandDefinition | CliCommandGroupDefinition)[]
-  }
-}
-
-export interface PackageJson {
-  name: string
-  version: string
-  scripts?: Record<string, string>
-
-  description?: string
-  author?: string
-  license?: string
-  private?: boolean
-
-  dependencies?: Record<string, string>
-  devDependencies?: Record<string, string>
-  peerDependencies?: Record<string, string>
-
-  repository?: {type: string; url: string}
-}
-
-export interface CliCommandGroupDefinition {
-  name: string
-  signature: string
-  isGroupRoot: boolean
-  description: string
-  hideFromHelp?: boolean
-}
-
-export interface ResolvedCliCommand {
-  command: CliCommandDefinition | CliCommandGroupDefinition
-  commandName: string
-  parentName?: string
-  isGroup: boolean
-  isCommand: boolean
-}
-
-export type CliCommandAction<F = Record<string, unknown>> = (
-  args: CliCommandArguments<F>,
-  context: CliCommandContext,
-) => Promise<unknown>
-
-export interface CliCommandDefinition<F = Record<string, unknown>> {
-  name: string
-  group?: string
-  signature: string
-  description: string
-  helpText: string
-  action: CliCommandAction<F>
-  hideFromHelp?: boolean
-}
-
-export interface CliCommandArguments<F = Record<string, unknown>> {
-  groupOrCommand: string
-  argv: string[]
-  extOptions: F
-  argsWithoutOptions: string[]
-  extraArguments: string[]
-}
-
-export type CliCommandContext = CliV2CommandContext | CliV3CommandContext
-
-export interface CliBaseCommandContext {
-  output: CliOutputter
-  prompt: CliPrompter
-  apiClient: CliApiClient
-  sanityMajorVersion: 2 | 3
-  cliConfigPath?: string
-  cliRoot: string
-  workDir: string
-  corePath?: string
-  chalk: typeof chalk
-  commandRunner: CliCommandRunner
-  fromInitCommand?: boolean
-}
-
-export interface TelemetryUserProperties {
-  runtime: string
-  runtimeVersion: string
-  cliVersion: string
-  machinePlatform: string
-  cpuArchitecture: string
-  projectId?: string
-  dataset?: string
-}
-
-export interface CliV2CommandContext extends CliBaseCommandContext {
-  sanityMajorVersion: 2
-  cliConfig?: SanityJson
-  cliPackageManager?: CliPackageManager
-  telemetry: TelemetryLogger<TelemetryUserProperties>
-}
-
-export interface CliV3CommandContext extends CliBaseCommandContext {
-  sanityMajorVersion: 3
-  cliConfig?: CliConfig
-  cliPackageManager: CliPackageManager
-  telemetry: TelemetryLogger<TelemetryUserProperties>
-}
-
-export interface CliCommandRunner {
-  commands: Readonly<(CliCommandDefinition | CliCommandGroupDefinition)[]>
-  commandGroups: Readonly<Record<string, (CliCommandDefinition | CliCommandGroupDefinition)[]>>
-
-  runCommand(
-    commandOrGroup: string,
-    args: CliCommandArguments,
-    options: CommandRunnerOptions,
-  ): Promise<unknown>
-
-  resolveSubcommand(
-    group: (CliCommandDefinition | CliCommandGroupDefinition)[],
-    subCommandName: string,
-    parentGroupName: string,
-  ): ResolvedCliCommand | null
-}
-
-export interface CliUserConfig {
-  cliLastUpdateCheck?: number
-  cliLastUpdateNag?: number
-  authToken?: string
-  authType?: string
-}
-
-export interface CommandRunnerOptions {
-  cliConfig: CliConfigResult | null
-  cliRoot: string
-  workDir: string
-  corePath: string | undefined
-  telemetry: TelemetryLogger<TelemetryUserProperties>
-}
-
-export interface CliOutputter {
-  print: (...args: unknown[]) => void
-  success: (...args: unknown[]) => void
-  warn: (...args: unknown[]) => void
-  error: (...args: unknown[]) => void
-  clear: () => void
-  spinner(options: Options | string): Ora
-}
-
-export type SinglePrompt =
-  | (Omit<DistinctQuestion, 'name'> & {type: 'list'; choices: ChoiceCollection})
-  | (Omit<DistinctQuestion, 'name'> & {type: 'confirm'})
-  | (Omit<DistinctQuestion, 'name'> & {type: 'input'})
-
-export type CliPrompter = (<T extends Answers = Answers>(
-  questions: DistinctQuestion<T>[],
-) => Promise<T>) & {
-  Separator: typeof Separator
-  single: <T = string>(question: SinglePrompt) => Promise<T>
-}
-
-export type CliApiClient = (options?: ClientRequirements) => SanityClient
-
-export interface CliYarnOptions {
-  print?: CliOutputter['print']
-  error?: CliOutputter['error']
-  rootDir?: string
-}
-
-export type CliStubbedYarn = (args: string[], options?: CliYarnOptions) => Promise<void>
-
-export interface CliApiConfig {
-  projectId?: string
-  dataset?: string
-}
-
-export interface SanityJson {
-  root?: boolean
-
-  project?: {
-    name?: string
-    basePath?: string
-  }
-
-  api?: CliApiConfig
-
-  // eslint-disable-next-line camelcase
-  __experimental_spaces?: {
-    name: string
-    title: string
-    default?: true
-    api: {
-      projectId?: string
-      dataset?: string
-    }
-  }[]
-
-  plugins?: string[]
-
-  parts?: {
-    name?: string
-    path?: string
-    implements?: string
-    description?: string
-  }[]
-
-  env?: {
-    production?: SanityJson
-    staging?: SanityJson
-    development?: SanityJson
-  }
-}
-
-export interface GraphQLAPIConfig {
-  /**
-   * ID of GraphQL API. Only (currently) required when using the `--api` flag
-   * for `sanity graphql deploy`, in order to only deploy a specific API.
-   */
-  id?: string
-
-  /**
-   * Name of workspace containing the schema to deploy
-   *
-   * Optional, defaults to `default` (eg the one used if no `name` is defined)
-   */
-  workspace?: string
-
-  /**
-   * Name of source containing the schema to deploy, within the configured workspace
-   *
-   * Optional, defaults to `default` (eg the one used if no `name` is defined)
-   */
-  source?: string
-
-  /**
-   * API tag for this API - allows deploying multiple different APIs to a single dataset
-   *
-   * Optional, defaults to `default`
-   */
-  tag?: string
-
-  /**
-   * Whether or not to deploy a "GraphQL Playground" to the API url - an HTML interface that allows
-   * running queries and introspecting the schema from the browser. Note that this interface is not
-   * secured in any way, but as the schema definition and API route is generally open, this does not
-   * expose any more information than is otherwise available - it only makes it more discoverable.
-   *
-   * Optional, defaults to `true`
-   */
-  playground?: boolean
-
-  /**
-   * Generation of API to auto-generate from schema. New APIs should use the latest (`gen3`).
-   *
-   * Optional, defaults to `gen3`
-   */
-  generation?: 'gen3' | 'gen2' | 'gen1'
-
-  /**
-   * Define document interface fields (`_id`, `_type` etc) as non-nullable.
-   * If you never use a document type as an object (within other documents) in your schema types,
-   * you can (and probably should) set this to `true`. Because a document type _could_ be used
-   * inside other documents, it is by default set to `false`, as in these cases these fields
-   * _can_ be null.
-   *
-   * Optional, defaults to `false`
-   */
-  nonNullDocumentFields?: boolean
-
-  /**
-   * Suffix to use for generated filter types.
-   *
-   * Optional, Defaults to `Filter`.
-   *
-   */
-  filterSuffix?: string
-}
-
-/**
- * Until these types are on npm: https://github.com/facebook/react/blob/0bc30748730063e561d87a24a4617526fdd38349/compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Options.ts#L39-L122
- * @beta
- */
-export interface ReactCompilerConfig {
-  /**
-   * @see https://react.dev/learn/react-compiler#existing-projects
-   */
-  sources?: Array<string> | ((filename: string) => boolean) | null
-
-  /**
-   * The minimum major version of React that the compiler should emit code for. If the target is 19
-   * or higher, the compiler emits direct imports of React runtime APIs needed by the compiler. On
-   * versions prior to 19, an extra runtime package react-compiler-runtime is necessary to provide
-   * a userspace approximation of runtime APIs.
-   * @see https://react.dev/learn/react-compiler#using-react-compiler-with-react-17-or-18
-   */
-  target: '18' | '19'
-
-  panicThreshold?: 'ALL_ERRORS' | 'CRITICAL_ERRORS' | 'NONE'
-
-  compilationMode?: 'infer' | 'syntax' | 'annotation' | 'all'
-}
-
-interface AppConfig {
-  organizationId: string
-  /**
-   * Defaults to './src/App'
-   */
-  entry?: string
-  id?: string
-}
-
-export interface CliConfig {
-  api?: CliApiConfig
-
-  project?: {
-    basePath?: string
-  }
-
-  /**
-   * Wraps the Studio in `<React.StrictMode>` root to aid flagging potential problems related to concurrent features (`startTransition`, `useTransition`, `useDeferredValue`, `Suspense`)
-   * Can also be enabled by setting `SANITY_STUDIO_REACT_STRICT_MODE="true"|"false"`.
-   * It only applies to `sanity dev` in dev mode, it's ignored in `sanity build` and in production.
-   * Defaults to `false`
-   */
-  reactStrictMode?: boolean
-
-  /**
-   * The React Compiler is currently in beta, and is disabled by default.
-   * @see https://react.dev/learn/react-compiler
-   * @beta
-   */
-  reactCompiler?: ReactCompilerConfig
-
-  server?: {
-    hostname?: string
-    port?: number
-  }
-
-  graphql?: GraphQLAPIConfig[]
-
-  vite?: UserViteConfig
-
-  autoUpdates?: boolean
-
-  studioHost?: string
-
-  /**
-   * Parameter used to configure other kinds of applications.
-   * Signals to `sanity` commands that this is not a studio.
-   */
-  app?: AppConfig
-
-  /**
-   * Configuration for Sanity media libraries.
-   */
-  mediaLibrary?: {
-    /**
-     * The path to the Media Library aspects directory. When using the CLI to manage aspects, this
-     * is the directory they will be read from and written to.
-     */
-    aspectsPath: string
-  }
-}
-
-export type UserViteConfig =
-  | InlineConfig
-  | ((config: InlineConfig, env: ConfigEnv) => InlineConfig | Promise<InlineConfig>)
-
-export type SanityUser = {
-  id: string
-  name: string
-  email: string
-  profileImage?: string
-  tosAcceptedAt?: string
-  provider: 'google' | 'github' | 'sanity' | `saml-${string}`
-}

package/src/util/canLaunchBrowser.ts

@@ -1,12 +0,0 @@
-import os from 'node:os'
-
-export function canLaunchBrowser(): boolean {
-  const isWindowsOrMac = ['win32', 'darwin'].includes(os.platform())
-  if (isWindowsOrMac) {
-    return true
-  }
-
-  // eslint-disable-next-line no-process-env
-  const hasWM = Boolean(process.env.XDG_CURRENT_DESKTOP || process.env.GDMSESSION)
-  return hasWM
-}

package/src/util/cliWorker.ts

@@ -1,34 +0,0 @@
-import path from 'node:path'
-
-import pkgDir from 'pkg-dir'
-
-/**
- * Because we're bundling the CLI into a single file, the classic approach of
- * checking `isMainThread()` and spawning a thread on `__dirname` does not work,
- * as it leads to the entire CLI being re-executed in the worker thread.
- *
- * To make things worse, the built CLI makes it difficult to resolve paths to
- * built source files (that contains the unpackaged worker).
- *
- * This function takes a path relative to the `src/workers` folder, resolves
- * the location of that within the installed location (eg global Sanity CLI)
- * and ensures we can resolve the actual module before trying to spawn the
- * worker thread.
- *
- * @param workerPath - _RELATIVE_ path (relative to `src/workers`) to the worker
- * @returns Full, absolute path to the worker
- * @internal
- */
-export async function getCliWorkerPath(workerPath: string): Promise<string> {
-  const cliDir = await pkgDir(__dirname)
-  if (!cliDir) {
-    throw new Error('Failed to find root @sanity/cli module directory')
-  }
-
-  const resolvedPath = path.resolve(cliDir, 'lib', 'workers', workerPath)
-  try {
-    return require.resolve(resolvedPath)
-  } catch {
-    throw new Error(`Unable to resolve path for worker: ${workerPath}`)
-  }
-}

package/src/util/clientWrapper.ts

@@ -1,119 +0,0 @@
-import path from 'node:path'
-
-import {
-  type ClientError,
-  createClient,
-  requester as defaultRequester,
-  type SanityClient,
-  type ServerError,
-} from '@sanity/client'
-import {generateHelpUrl} from '@sanity/generate-help-url'
-import chalk from 'chalk'
-
-import {type CliApiConfig} from '../types'
-import {getUserConfig} from './getUserConfig'
-
-const apiHosts: Record<string, string | undefined> = {
-  staging: 'https://api.sanity.work',
-  development: 'http://api.sanity.local',
-}
-
-/**
- * Creates a wrapper/getter function to retrieve a Sanity API client.
- * Instead of spreading the error checking logic around the project,
- * we call it here when (and only when) a command needs to use the API
- */
-const defaults = {
-  requireUser: true,
-  requireProject: true,
-}
-
-const authErrors = () => ({
-  onError: (err: Error | null) => {
-    if (!err || !isReqResError(err)) {
-      return err
-    }
-
-    const statusCode = err.response && err.response.body && err.response.body.statusCode
-    if (statusCode === 401) {
-      err.message = `${err.message}. You may need to login again with ${chalk.cyan(
-        'sanity login',
-      )}.\nFor more information, see ${generateHelpUrl('cli-errors')}.`
-    }
-
-    return err
-  },
-})
-
-function isReqResError(err: Error): err is ClientError | ServerError {
-  return err.hasOwnProperty('response')
-}
-
-export function getCliToken(): string | undefined {
-  // eslint-disable-next-line no-process-env
-  const envAuthToken = process.env.SANITY_AUTH_TOKEN
-  const userConfig = getUserConfig()
-  return envAuthToken || userConfig.get('authToken')
-}
-
-export interface ClientRequirements {
-  requireUser?: boolean
-  requireProject?: boolean
-  api?: {
-    projectId?: string
-    dataset?: string
-    apiHost?: string
-    apiVersion?: string
-    requestTagPrefix?: string
-  }
-}
-
-export function getClientWrapper(
-  cliApiConfig: CliApiConfig | null,
-  configPath: string,
-): (options?: ClientRequirements) => SanityClient {
-  const requester = defaultRequester.clone()
-  requester.use(authErrors())
-
-  return function (opts?: ClientRequirements) {
-    // Read these environment variables "late" to allow `.env` files
-
-    /* eslint-disable no-process-env */
-    const sanityEnv = process.env.SANITY_INTERNAL_ENV || 'production'
-    /* eslint-enable no-process-env */
-
-    const {requireUser, requireProject, api} = {...defaults, ...opts}
-    const token = getCliToken()
-    const apiHost = apiHosts[sanityEnv]
-    const apiConfig = {
-      ...cliApiConfig,
-      ...api,
-    }
-
-    if (apiHost) {
-      apiConfig.apiHost = apiHost
-    }
-
-    if (requireUser && !token) {
-      throw new Error('You must login first - run "sanity login"')
-    }
-
-    if (requireProject && !apiConfig.projectId) {
-      const relativeConfigPath = path.relative(process.cwd(), configPath)
-      throw new Error(
-        `${relativeConfigPath} does not contain a project identifier ("api.projectId"), ` +
-          'which is required for the Sanity CLI to communicate with the Sanity API',
-      )
-    }
-
-    return createClient({
-      ...apiConfig,
-      apiVersion: '1',
-      dataset: apiConfig.dataset || '~dummy-placeholder-dataset-',
-      token: requireUser ? token : undefined,
-      useProjectHostname: requireProject,
-      requester,
-      useCdn: false,
-    })
-  }
-}

package/src/util/copy.ts

@@ -1,50 +0,0 @@
-import fs from 'node:fs/promises'
-import path from 'node:path'
-
-import {readdirRecursive} from './readdirRecursive'
-
-interface CopyOptions {
-  rename?: (originalName: string) => string
-}
-
-export async function copy(
-  srcPath: string,
-  dstPath: string,
-  options?: CopyOptions,
-): Promise<number> {
-  const rename = options?.rename
-  const content = (await fs.stat(srcPath)).isDirectory()
-    ? await readdirRecursive(srcPath)
-    : [{path: srcPath, isDir: false}]
-
-  const directories = content
-    .filter((entry) => entry.isDir)
-    .sort((a, b) => b.path.length - a.path.length)
-    .sort((a, b) => a.path.localeCompare(b.path))
-    .map((entry) => entry.path)
-
-  for (const subDir of directories) {
-    const relativePath = path.relative(srcPath, subDir)
-    const fullDstPath = path.join(dstPath, relativePath)
-    await fs.mkdir(fullDstPath, {recursive: true})
-  }
-
-  const files = content
-    .filter((entry) => !entry.isDir)
-    .sort((a, b) => b.path.length - a.path.length)
-    .sort((a, b) => a.path.localeCompare(b.path))
-    .map((entry) => {
-      const relativePath = path.relative(srcPath, entry.path)
-      const baseName = path.basename(relativePath)
-      const dirName = path.dirname(relativePath)
-      const dstName = rename ? rename(baseName) : baseName
-      const fullDstPath = path.join(dstPath, dirName, dstName)
-      return {from: entry.path, to: fullDstPath}
-    })
-
-  for (const file of files) {
-    await fs.copyFile(file.from, file.to)
-  }
-
-  return files.length
-}