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

package/src/util/createExpiringConfig.ts

@@ -1,80 +0,0 @@
-import type ConfigStore from 'configstore'
-
-export interface ExpiringConfigOptions<Type> {
-  /** Config store */
-  store: ConfigStore
-  /** Config key */
-  key: string
-  /** TTL (milliseconds) */
-  ttl: number
-  /** Fetch value */
-  fetchValue: () => Type | Promise<Type>
-  /** Subscribe to revalidate event */
-  onRevalidate?: () => void
-  /** Subscribe to fetch event */
-  onFetch?: () => void
-  /** Subscribe to cache hit event */
-  onCacheHit?: () => void
-}
-
-export interface ExpiringConfigApi<Type> {
-  /**
-   * Attempt to get the cached value. If there is no cached value, or the cached value has expired,
-   * fetch, cache, and return the value.
-   */
-  get: () => Promise<Type>
-  /**
-   * Delete the cached value.
-   */
-  delete: () => void
-}
-
-/**
- * Create a config in the provided config store that expires after the provided TTL.
- */
-export function createExpiringConfig<Type>({
-  key,
-  ttl,
-  store,
-  fetchValue,
-  onRevalidate = () => null,
-  onFetch = () => null,
-  onCacheHit = () => null,
-}: ExpiringConfigOptions<Type>): ExpiringConfigApi<Type> {
-  let currentFetch: Promise<Type> | null = null
-  return {
-    async get() {
-      const {value, updatedAt} = store.get(key) ?? {}
-
-      if (value && updatedAt) {
-        const hasExpired = Date.now() - updatedAt > ttl
-
-        if (!hasExpired) {
-          onCacheHit()
-          return value
-        }
-
-        onRevalidate()
-      }
-
-      if (currentFetch) {
-        return currentFetch
-      }
-      onFetch()
-
-      currentFetch = Promise.resolve(fetchValue())
-      const nextValue = await currentFetch
-      currentFetch = null
-
-      store.set(key, {
-        value: nextValue,
-        updatedAt: Date.now(),
-      })
-
-      return nextValue
-    },
-    delete() {
-      store.delete(key)
-    },
-  }
-}

package/src/util/createTelemetryStore.ts

@@ -1,204 +0,0 @@
-import {appendFile} from 'node:fs/promises'
-
-import {type SanityClient} from '@sanity/client'
-import {
-  type ConsentStatus,
-  createBatchedStore,
-  createSessionId,
-  type TelemetryEvent,
-} from '@sanity/telemetry'
-
-import {debug as baseDebug} from '../debug'
-import {getClientWrapper, getCliToken} from './clientWrapper'
-import {createExpiringConfig} from './createExpiringConfig'
-import {getUserConfig} from './getUserConfig'
-import {isCi} from './isCi'
-import {isTrueish} from './isTrueish'
-
-const debug = baseDebug.extend('telemetry')
-
-const FIVE_MINUTES = 1000 * 60 * 5
-const LOG_FILE_NAME = 'telemetry-events.ndjson'
-
-export const TELEMETRY_CONSENT_CONFIG_KEY = 'telemetryConsent'
-
-const VALID_API_STATUSES = ['granted', 'denied', 'unset'] as const
-type ValidApiConsentStatus = (typeof VALID_API_STATUSES)[number]
-
-function isValidApiConsentStatus(status: string): status is ValidApiConsentStatus {
-  return VALID_API_STATUSES.includes(status as ValidApiConsentStatus)
-}
-
-function parseApiConsentStatus(value: unknown): ValidApiConsentStatus {
-  if (typeof value === 'string' && isValidApiConsentStatus(value)) {
-    return value
-  }
-  throw new Error(`Invalid consent status. Must be one of: ${VALID_API_STATUSES.join(', ')}`)
-}
-
-function createTelemetryClient(token: string) {
-  const getClient = getClientWrapper(null, 'sanity.cli.js')
-  return getClient({requireUser: false, requireProject: false}).config({
-    apiVersion: '2023-12-18',
-    token,
-    useCdn: false,
-    useProjectHostname: false,
-  })
-}
-
-let _client: SanityClient | null = null
-function getCachedClient(token: string) {
-  if (!_client) {
-    _client = createTelemetryClient(token)
-  }
-  return _client
-}
-
-interface Env {
-  DO_NOT_TRACK?: string
-  SANITY_TELEMETRY_INSPECT?: string
-}
-
-interface Options {
-  env: Env | NodeJS.ProcessEnv
-}
-
-export type ConsentInformation =
-  | {
-      status: Extract<ConsentStatus, 'granted'>
-      reason?: never
-    }
-  | {
-      status: Extract<ConsentStatus, 'undetermined'>
-      reason: 'unauthenticated' | 'fetchError'
-    }
-  | {
-      status: Extract<ConsentStatus, 'denied'>
-      reason?: 'localOverride'
-    }
-  | {
-      status: Extract<ConsentStatus, 'unset'>
-      reason?: never
-    }
-
-export function resolveConsent({env}: Options): Promise<ConsentInformation> {
-  debug('Resolving consent…')
-  if (isCi) {
-    debug('CI environment detected, treating telemetry consent as denied')
-    return Promise.resolve({status: 'denied'})
-  }
-  if (isTrueish(env.DO_NOT_TRACK)) {
-    debug('DO_NOT_TRACK is set, consent is denied')
-    return Promise.resolve({
-      status: 'denied',
-      reason: 'localOverride',
-    })
-  }
-
-  const token = getCliToken()
-  if (!token) {
-    debug('User is not logged in, consent is undetermined')
-    return Promise.resolve({
-      status: 'undetermined',
-      reason: 'unauthenticated',
-    })
-  }
-
-  const client = getCachedClient(token)
-
-  function fetchConsent(): Promise<{
-    status: ValidApiConsentStatus
-  }> {
-    const telemetryConsentConfig = createExpiringConfig<{
-      status: ValidApiConsentStatus
-    }>({
-      store: getUserConfig(),
-      key: TELEMETRY_CONSENT_CONFIG_KEY,
-      ttl: FIVE_MINUTES,
-      fetchValue: () =>
-        client.request({uri: '/intake/telemetry-status', tag: 'telemetry-consent.cli'}),
-      onRevalidate() {
-        debug('Revalidating cached telemetry consent status...')
-      },
-      onFetch() {
-        debug('Fetching telemetry consent status...')
-      },
-      onCacheHit() {
-        debug('Retrieved telemetry consent status from cache')
-      },
-    })
-    return telemetryConsentConfig.get()
-  }
-
-  return fetchConsent()
-    .then<ConsentInformation>((response) => {
-      debug('User consent status is %s', response.status)
-      return {status: parseApiConsentStatus(response.status)}
-    })
-    .catch((err) => {
-      debug('Failed to fetch user consent status, treating it as "undetermined": %s', err.stack)
-      return {
-        status: 'undetermined',
-        reason: 'fetchError',
-      }
-    })
-}
-export function createTelemetryStore<UserProperties>({
-  env,
-  projectId,
-}: {
-  projectId?: string
-  env: {[key: string]: string | undefined}
-}) {
-  debug('Initializing telemetry')
-
-  // Note: if this function throws/rejects the events will be put back on the buffer
-  async function sendEvents(batch: TelemetryEvent[]) {
-    const token = getCliToken()
-    if (!token) {
-      // Note: since the telemetry store checks for consent before sending events, and this token
-      // check is also done during consent checking, this would normally never happen
-      debug('No user token found. Something is not quite right')
-      return Promise.reject(new Error('User is not logged in'))
-    }
-    const inspectEvents = isTrueish(env.SANITY_TELEMETRY_INSPECT)
-    if (inspectEvents) {
-      // eslint-disable-next-line no-console
-      console.info(`SANITY_TELEMETRY_INSPECT is set, appending events to "${LOG_FILE_NAME}"`)
-      await appendFile(LOG_FILE_NAME, `${batch.map((entry) => JSON.stringify(entry)).join('\n')}\n`)
-    }
-    const client = getCachedClient(token)
-    debug('Submitting %s telemetry events', batch.length)
-    try {
-      return await client.request({
-        uri: '/intake/batch',
-        method: 'POST',
-        json: true,
-        body: {projectId, batch},
-      })
-    } catch (err) {
-      const statusCode = err.response && err.response.statusCode
-      debug(
-        'Failed to send telemetry events%s: %s',
-        statusCode ? ` (HTTP ${statusCode})` : '',
-        err.stack,
-      )
-      // note: we want to throw - the telemetry store implements error handling already
-      throw err
-    }
-  }
-
-  const sessionId = createSessionId()
-  debug('session id: %s', sessionId)
-
-  const store = createBatchedStore<UserProperties>(sessionId, {
-    resolveConsent: () => resolveConsent({env}),
-    sendEvents,
-  })
-
-  process.once('SIGINT', () => store.flush().finally(() => process.exit(0)))
-  process.once('beforeExit', () => store.flush())
-  process.once('unhandledRejection', () => store.flush())
-  process.once('uncaughtException', () => store.flush())
-  return store
-}

package/src/util/detectRuntime.ts

@@ -1,12 +0,0 @@
-export function detectRuntime() {
-  if ('Deno' in globalThis) {
-    return 'deno'
-  }
-  if ('Bun' in globalThis) {
-    return 'bun'
-  }
-  // Consider using a more reliable way of detecting that we're actually in Node.js
-  // I first attempted using https://www.npmjs.com/package/is-really-node, but it fails
-  // due to using top level await.
-  return 'node'
-}

package/src/util/dynamicRequire.ts

@@ -1,17 +0,0 @@
-// Prevent webpack from bundling in webpack context,
-// use regular node require for unbundled context
-
-/* eslint-disable camelcase, no-undef */
-declare const __webpack_require__: boolean
-declare const __non_webpack_require__: typeof require
-
-const requireFunc: typeof require =
-  typeof __webpack_require__ === 'function' ? __non_webpack_require__ : require
-/* eslint-enable camelcase, no-undef */
-
-export function dynamicRequire<T = any>(request: string): T {
-  const mod = requireFunc(request)
-  return mod.__esModule && mod.default ? mod.default : mod
-}
-
-dynamicRequire.resolve = requireFunc.resolve

package/src/util/frameworkPort.ts

@@ -1,63 +0,0 @@
-const FALLBACK_PORT = 3000
-
-const portMap: Record<string, number> = {
-  'nextjs': 3000,
-  'blitzjs': 3000,
-  'gatsby': 8000,
-  'remix': 3000,
-  'astro': 4321,
-  'hexo': 4000,
-  'eleventy': 8080,
-  'docusaurus': 3000,
-  'docusaurus-2': 3000,
-  'preact': 8080,
-  'solidstart': 3000,
-  'solidstart-1': 3000,
-  'dojo': 3000,
-  'ember': 4200,
-  'vue': 8080,
-  'scully': 1668,
-  'ionic-angular': 4200,
-  'angular': 4200,
-  'polymer': 8081,
-  'svelte': 5000,
-  'sveltekit': 5173,
-  'sveltekit-1': 5173,
-  'ionic-react': 3000,
-  'create-react-app': 3000,
-  'gridsome': 8080,
-  'umijs': 8000,
-  'saber': 3000,
-  'stencil': 3333,
-  'nuxtjs': 3000,
-  'redwoodjs': 8910,
-  'hugo': 1313,
-  'jekyll': 4000,
-  'brunch': 3333,
-  'middleman': 4567,
-  'zola': 1111,
-  'hydrogen': 3000,
-  'vite': 5173,
-  'vitepress': 5173,
-  'vuepress': 8080,
-  'parcel': 1234,
-  'fasthtml': 8000,
-  'sanity': 3333,
-  'sanity-v3': 3333,
-  'storybook': 6006,
-}
-
-/**
- * Returns the default development port for a given framework.
- * Contains default ports for all frameworks supported by `@vercel/frameworks`.
- * Falls back to port 3000 if framework is not found or not specified.
- *
- * @see https://github.com/vercel/vercel/blob/main/packages/frameworks/src/frameworks.ts
- * for the complete list of supported frameworks
- *
- * @param frameworkSlug - The framework identifier from `@vercel/frameworks`
- * @returns The default port number for the framework
- */
-export function getDefaultPortForFramework(frameworkSlug?: string | null): number {
-  return portMap[frameworkSlug ?? ''] ?? FALLBACK_PORT
-}

package/src/util/generateCommandsDocumentation.ts

@@ -1,62 +0,0 @@
-import {padEnd} from 'lodash'
-
-import {type CliCommandDefinition, type CliCommandGroupDefinition} from '../types'
-import {getNoSuchCommandText} from './noSuchCommandText'
-
-/**
- * Generate documentation for all commands within a given group
- */
-export function generateCommandsDocumentation(
-  commandGroups: Record<string, (CliCommandDefinition | CliCommandGroupDefinition)[]>,
-  group = 'default',
-): string {
-  const commandGroup = commandGroups[group]
-  const commands = commandGroup && commandGroup.filter((cmd) => !cmd.hideFromHelp)
-
-  if (!commands || commands.length === 0) {
-    throw new Error(getNoSuchCommandText(group))
-  }
-
-  // Find the maximum length of a command name, so we can pad the descriptions
-  const cmdLength = commands.reduce((max, cmd) => Math.max(cmd.name.length, max), 0)
-  const prefix = group === 'default' ? '' : ` ${group}`
-
-  const rows = [
-    `usage: npx sanity${prefix} [--default] [-v|--version] [-d|--debug] [-h|--help] <command> [<args>]`,
-    '',
-    'Commands:',
-  ]
-    .concat(commands.map((cmd) => `   ${padEnd(cmd.name, cmdLength + 1)} ${cmd.description}`))
-    .concat([
-      '',
-      `See 'npx sanity help${prefix} <command>' for specific information on a subcommand.`,
-    ])
-
-  return rows.join('\n')
-}
-
-/**
- * Generate documentation for a single command within the given group
- */
-export function generateCommandDocumentation(
-  command: CliCommandDefinition,
-  group?: string | null,
-  subCommand?: string,
-): string {
-  if (!command) {
-    throw new Error(
-      subCommand
-        ? `"${subCommand}" is not a subcommand of "${group}". See 'npx sanity help ${group}'`
-        : getNoSuchCommandText(group || command),
-    )
-  }
-
-  const cmdParts = [group || command.name, subCommand].filter(Boolean).join(' ')
-  return [
-    `usage: npx sanity ${cmdParts} ${command.signature}`,
-    '',
-    `   ${command.description}`,
-    '',
-    (command.helpText || '').trim(),
-  ].join('\n')
-}

package/src/util/getCliConfig.ts

@@ -1,172 +0,0 @@
-/* eslint-disable no-sync */
-
-/**
- * Reads the Sanity CLI config from one of the following files (in preferred order):
- *   - sanity.cli.js
- *   - sanity.cli.ts
- *
- * Note: There are two ways of using this:
- * a) `getCliConfig(cwd)`
- * b) `getCliConfig(cwd, {forked: true})`
- *
- * Approach a is generally a bit faster as it avoids the forking startup time, while
- * approach b could be considered "safer" since any side-effects of running the config
- * file will not bleed into the current CLI process directly.
- */
-import fs from 'node:fs'
-import path from 'node:path'
-import {Worker} from 'node:worker_threads'
-
-import {type CliConfig, type SanityJson} from '../types'
-import {getCliWorkerPath} from './cliWorker'
-import {dynamicRequire} from './dynamicRequire'
-
-export type CliMajorVersion = 2 | 3
-
-export type CliConfigResult =
-  | {config: SanityJson; path: string; version: 2}
-  | {config: CliConfig; path: string; version: 3}
-  | {config: null; path: string; version: CliMajorVersion}
-
-export async function getCliConfig(
-  cwd: string,
-  {forked}: {forked?: boolean} = {},
-): Promise<CliConfigResult | null> {
-  if (forked) {
-    try {
-      return await getCliConfigForked(cwd)
-    } catch {
-      // Intentional noop - try unforked variant
-    }
-  }
-
-  const {unregister} = __DEV__
-    ? {unregister: () => undefined}
-    : // eslint-disable-next-line @typescript-eslint/no-require-imports
-      require('esbuild-register/dist/node').register({supported: {'dynamic-import': true}})
-
-  try {
-    const v3Config = getSanityCliConfig(cwd)
-    if (v3Config) {
-      return v3Config
-    }
-
-    return getSanityJsonConfig(cwd)
-  } catch (err) {
-    throw err
-  } finally {
-    unregister()
-  }
-}
-
-export function getCliConfigSync(cwd: string): CliConfigResult | null {
-  const v3Config = getSanityCliConfig(cwd)
-  return v3Config ? v3Config : getSanityJsonConfig(cwd)
-}
-
-async function getCliConfigForked(cwd: string): Promise<CliConfigResult | null> {
-  const workerPath = await getCliWorkerPath('getCliConfig')
-  return new Promise((resolve, reject) => {
-    const worker = new Worker(workerPath, {
-      workerData: cwd,
-      env: process.env,
-    })
-    worker.on('message', (message) => {
-      if (message.type === 'config') {
-        resolve(message.config)
-      } else {
-        const error = new Error(message.error)
-        ;(error as any).type = message.errorType
-        reject(new Error(message.error))
-      }
-    })
-    worker.on('error', reject)
-    worker.on('exit', (code) => {
-      if (code !== 0) {
-        reject(new Error(`Worker stopped with exit code ${code}`))
-      }
-    })
-  })
-}
-
-function getSanityJsonConfig(cwd: string): CliConfigResult | null {
-  const configPath = path.join(cwd, 'sanity.json')
-
-  if (!fs.existsSync(configPath)) {
-    return null
-  }
-
-  return {
-    config: loadJsonConfig(configPath),
-    path: configPath,
-    version: 2,
-  }
-}
-
-function getSanityCliConfig(cwd: string): CliConfigResult | null {
-  const jsConfigPath = path.join(cwd, 'sanity.cli.js')
-  const tsConfigPath = path.join(cwd, 'sanity.cli.ts')
-
-  const [js, ts] = [fs.existsSync(jsConfigPath), fs.existsSync(tsConfigPath)]
-
-  if (!js && !ts) {
-    return null
-  }
-
-  if (!js && ts) {
-    return {
-      config: importConfig(tsConfigPath),
-      path: tsConfigPath,
-      version: 3,
-    }
-  }
-
-  if (js && ts) {
-    warn('Found both `sanity.cli.js` and `sanity.cli.ts` - using sanity.cli.js')
-  }
-
-  return {
-    config: importConfig(jsConfigPath),
-    path: jsConfigPath,
-    version: 3,
-  }
-}
-
-function loadJsonConfig(filePath: string): SanityJson | null {
-  try {
-    const content = fs.readFileSync(filePath, 'utf8')
-    return JSON.parse(content)
-  } catch (err) {
-    console.error(`Error reading "${filePath}": ${err.message}`)
-    return null
-  }
-}
-
-function importConfig(filePath: string): CliConfig | null {
-  try {
-    const config = dynamicRequire<CliConfig | {default: CliConfig} | null>(filePath)
-    if (config === null || typeof config !== 'object') {
-      throw new Error('Module export is not a configuration object')
-    }
-
-    return 'default' in config ? config.default : config
-  } catch (err) {
-    // If attempting to import `defineCliConfig` or similar from `sanity/cli`,
-    // accept the fact that it might not be installed. Instead, let the CLI
-    // give a warning about the `sanity` module not being installed
-    if (err.code === 'MODULE_NOT_FOUND' && err.message.includes('sanity/cli')) {
-      return null
-    }
-
-    console.error(`Error reading "${filePath}": ${err.message}`)
-    return null
-  }
-}
-
-function warn(warning: string) {
-  if (typeof process.send === 'function') {
-    process.send({type: 'warning', warning})
-  } else {
-    console.warn(warning)
-  }
-}

package/src/util/getCliVersion.ts

@@ -1,22 +0,0 @@
-import fs from 'node:fs/promises'
-import path from 'node:path'
-
-import pkgDir from 'pkg-dir'
-
-export async function getCliVersion(): Promise<string> {
-  const cliPath = pkgDir.sync(__dirname)
-
-  if (!cliPath) {
-    throw new Error('Unable to resolve root of @sanity/cli module')
-  }
-
-  let data: string | undefined
-  try {
-    data = await fs.readFile(path.join(cliPath, 'package.json'), 'utf-8')
-  } catch (err) {
-    throw new Error(`Unable to read @sanity/cli/package.json: ${err.message}`)
-  }
-
-  const pkg = JSON.parse(data)
-  return pkg.version
-}

package/src/util/getLocalVersion.ts

@@ -1,35 +0,0 @@
-import {readFileSync} from 'node:fs'
-import {join as joinPath, normalize as normalizePath} from 'node:path'
-
-import resolveFrom from 'resolve-from'
-
-export function getLocalVersion(moduleId: string, workDir: string): string | undefined {
-  const fromPath = workDir || process.cwd()
-  const modulePath = resolveFrom.silent(fromPath, joinPath(moduleId, 'package.json'))
-  if (modulePath) {
-    return tryGetVersion(modulePath)
-  }
-
-  // In the case of packages with an `exports` key, we may not be able to resolve `package.json`.
-  // If this happens, try to resolve the module itself and look for the last occurence of the
-  // package name, then append `package.json` to that path
-  const pathSegment = normalizePath(moduleId)
-  const parentPath = resolveFrom.silent(fromPath, moduleId)
-  if (!parentPath) {
-    return undefined
-  }
-
-  const moduleRoot = parentPath.slice(0, parentPath.lastIndexOf(pathSegment) + pathSegment.length)
-  const manifestPath = joinPath(moduleRoot, 'package.json')
-  return tryGetVersion(manifestPath)
-}
-
-function tryGetVersion(modulePath: string): string | undefined {
-  try {
-    const fileContent = readFileSync(modulePath, 'utf8')
-    const manifest = JSON.parse(fileContent)
-    return manifest.version
-  } catch {
-    return undefined
-  }
-}