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

package/src/util/updateNotifier.ts

@@ -1,158 +0,0 @@
-/* eslint-disable no-process-env */
-import boxen from 'boxen'
-import chalk from 'chalk'
-import latestVersion from 'get-latest-version'
-import pTimeout from 'p-timeout'
-import semverCompare from 'semver-compare'
-
-import {debug} from '../debug'
-import {getCliUpgradeCommand} from '../packageManager'
-import {type PackageJson} from '../types'
-import {getUserConfig} from './getUserConfig'
-import {isCi} from './isCi'
-
-const MAX_BLOCKING_TIME = 300
-const TWELVE_HOURS = 1000 * 60 * 60 * 12
-const isDisabled =
-  isCi || // Running in CI environment
-  process.env.NO_UPDATE_NOTIFIER // Explicitly disabled
-
-interface UpdateCheckOptions {
-  pkg: PackageJson
-  cwd: string
-  workDir: string
-}
-
-export function runUpdateCheck(options: UpdateCheckOptions): {notify: () => Promise<void>} {
-  debug('CLI installed at %s', __dirname)
-
-  const {pkg, cwd, workDir} = options
-  const {name, version} = pkg
-  const userConfig = getUserConfig()
-  const check = getLatestRemote().catch((): false => false)
-  let hasPrintedResult = false
-
-  return {notify}
-
-  async function notify() {
-    if (!process.stdout.isTTY) {
-      return
-    }
-
-    const result = await pTimeout(check, MAX_BLOCKING_TIME, printCachedResult)
-    if (hasPrintedResult) {
-      debug('Has already printed result through timeout check, skipping result notification')
-      return
-    }
-
-    printResult(result)
-  }
-
-  async function printCachedResult(): Promise<false> {
-    debug('Max time (%dms) reached waiting for latest version info', MAX_BLOCKING_TIME)
-    hasPrintedResult = true
-
-    const cached = userConfig.get('cliHasUpdate')
-    if (!cached) {
-      debug('No cached latest version result found')
-      return false
-    }
-
-    const diff = semverCompare(cached, version)
-    if (diff <= 0) {
-      // Looks like CLI was upgraded since last check
-      debug('CLI was upgraded since last check, falling back')
-      userConfig.delete('cliHasUpdate')
-      return false
-    }
-
-    debug('Printing cached latest version result')
-    await printResult(cached)
-    return false
-  }
-
-  async function printResult(newVersion: string | false) {
-    hasPrintedResult = true
-
-    const lastUpdated = userConfig.get('cliLastUpdateNag') || 0
-    if (Date.now() - lastUpdated < TWELVE_HOURS) {
-      debug('Less than 12 hours since last nag, skipping')
-      return
-    }
-
-    if (!newVersion || semverCompare(newVersion, version) <= 0) {
-      debug(`New version is ${newVersion || 'unknown'}, current is ${version}. Falling back.`)
-      return
-    }
-
-    const upgradeCommand = await getCliUpgradeCommand({cwd, workDir})
-    const message = [
-      'Update available ',
-      chalk.dim(version),
-      chalk.reset(' → '),
-      chalk.green(newVersion),
-      ' \nRun ',
-      chalk.cyan(upgradeCommand),
-      ' to update',
-    ].join('')
-
-    const boxenOpts = {
-      padding: 1,
-      margin: 1,
-      borderColor: 'yellow',
-
-      // Typescript issues forcing these to any
-      align: 'center' as any,
-      borderStyle: 'round' as any,
-    }
-
-    // Print to stderr to prevent garbling command output
-    // eslint-disable-next-line no-console
-    console.error(`\n${boxen(message, boxenOpts)}`)
-
-    userConfig.set('cliLastUpdateNag', Date.now())
-  }
-
-  async function getLatestRemote(): Promise<false | string> {
-    if (isDisabled) {
-      debug('Running on CI, or explicitly disabled, skipping update check')
-      return false
-    }
-
-    const lastUpdated = userConfig.get('cliLastUpdateCheck') || 0
-    if (Date.now() - lastUpdated < TWELVE_HOURS) {
-      debug('Less than 12 hours since last check, skipping update check')
-      return userConfig.get('cliHasUpdate') || false
-    }
-
-    let latestRemote: string | undefined
-    try {
-      debug('Checking for latest remote version')
-      latestRemote = await latestVersion(name)
-      debug('Latest remote version is %s', latestRemote)
-    } catch (err) {
-      debug(`Failed to fetch latest version of ${name} from npm:\n${err.stack}`)
-      return false
-    }
-
-    if (!latestRemote) {
-      debug(`Failed to fetch latest version of ${name} from npm`)
-      return false
-    }
-
-    userConfig.set('cliLastUpdateCheck', Date.now())
-
-    const diff = semverCompare(latestRemote, version)
-    if (diff <= 0) {
-      // No change, or lower
-      debug(diff === 0 ? 'No update found' : 'Remote version older than local')
-      userConfig.delete('cliHasUpdate')
-      return false
-    }
-
-    // Update available, set to user config so we may notify on next startup
-    userConfig.set('cliHasUpdate', latestRemote)
-    debug('Update is available (%s)', latestRemote)
-    return latestRemote
-  }
-}

package/src/util/writeJson.ts

@@ -1,6 +0,0 @@
-import {writeFile} from 'node:fs/promises'
-
-export function writeJson(filePath: string, content: unknown): Promise<void> {
-  const serialized = JSON.stringify(content, null, 2)
-  return writeFile(filePath, serialized, 'utf8')
-}

package/src/workers/getAndWriteJourneySchema.ts

@@ -1,7 +0,0 @@
-import {parentPort, workerData} from 'node:worker_threads'
-
-import {getAndWriteJourneySchema} from '../util/journeyConfig'
-
-getAndWriteJourneySchema(workerData)
-  .then(() => parentPort?.postMessage({type: 'success'}))
-  .catch((error) => parentPort?.postMessage({type: 'error', error}))

package/src/workers/getCliConfig.ts

@@ -1,14 +0,0 @@
-import {parentPort, workerData} from 'node:worker_threads'
-
-import {getCliConfig} from '../util/getCliConfig'
-
-// We're communicating with a parent process through a message channel
-getCliConfig(workerData, {forked: false})
-  .then((config) => parentPort?.postMessage({type: 'config', config}))
-  .catch((error) =>
-    parentPort?.postMessage({
-      type: 'error',
-      error: error instanceof Error ? error.stack : error,
-      errorType: error && (error.type || error.name),
-    }),
-  )

package/src/workers/typegenGenerate.ts

@@ -1,228 +0,0 @@
-import {isMainThread, parentPort, workerData as _workerData} from 'node:worker_threads'
-
-import {
-  findQueriesInPath,
-  getResolver,
-  readSchema,
-  registerBabel,
-  safeParseQuery,
-  TypeGenerator,
-} from '@sanity/codegen'
-import createDebug from 'debug'
-import {typeEvaluate, type TypeNode} from 'groq-js'
-
-const $info = createDebug('sanity:codegen:generate:info')
-
-export interface TypegenGenerateTypesWorkerData {
-  workDir: string
-  workspaceName?: string
-  schemaPath: string
-  searchPath: string | string[]
-  overloadClientMethods?: boolean
-}
-
-export type TypegenGenerateTypesWorkerMessage =
-  | {
-      type: 'error'
-      error: Error
-      fatal: boolean
-      query?: string
-      filename?: string
-    }
-  | {
-      type: 'types'
-      filename: string
-      types: {
-        queryName: string
-        query: string
-        type: string
-        unknownTypeNodesGenerated: number
-        typeNodesGenerated: number
-        emptyUnionTypeNodesGenerated: number
-      }[]
-    }
-  | {
-      type: 'schema'
-      filename: string
-      schema: string
-      length: number
-    }
-  | {
-      type: 'typemap'
-      typeMap: string
-    }
-  | {
-      type: 'complete'
-    }
-
-if (isMainThread || !parentPort) {
-  throw new Error('This module must be run as a worker thread')
-}
-
-const opts = _workerData as TypegenGenerateTypesWorkerData
-
-registerBabel()
-
-async function main() {
-  const schema = await readSchema(opts.schemaPath)
-
-  const typeGenerator = new TypeGenerator(schema)
-  const schemaTypes = [typeGenerator.generateSchemaTypes(), TypeGenerator.generateKnownTypes()]
-    .join('\n')
-    .trim()
-  const resolver = getResolver()
-
-  parentPort?.postMessage({
-    type: 'schema',
-    schema: `${schemaTypes.trim()}\n`,
-    filename: 'schema.json',
-    length: schema.length,
-  } satisfies TypegenGenerateTypesWorkerMessage)
-
-  const queries = findQueriesInPath({
-    path: opts.searchPath,
-    resolver,
-  })
-
-  const allQueries = []
-
-  for await (const result of queries) {
-    if (result.type === 'error') {
-      parentPort?.postMessage({
-        type: 'error',
-        error: result.error,
-        fatal: false,
-        filename: result.filename,
-      } satisfies TypegenGenerateTypesWorkerMessage)
-      continue
-    }
-    $info(`Processing ${result.queries.length} queries in "${result.filename}"...`)
-
-    const fileQueryTypes: {
-      queryName: string
-      query: string
-      type: string
-      typeName: string
-      typeNode: TypeNode
-      unknownTypeNodesGenerated: number
-      typeNodesGenerated: number
-      emptyUnionTypeNodesGenerated: number
-    }[] = []
-    for (const {name: queryName, result: query} of result.queries) {
-      try {
-        const ast = safeParseQuery(query)
-        const queryTypes = typeEvaluate(ast, schema)
-
-        const typeName = `${queryName}Result`
-        const type = typeGenerator.generateTypeNodeTypes(typeName, queryTypes)
-
-        const queryTypeStats = walkAndCountQueryTypeNodeStats(queryTypes)
-        fileQueryTypes.push({
-          queryName,
-          query,
-          typeName,
-          typeNode: queryTypes,
-          type: `${type.trim()}\n`,
-          unknownTypeNodesGenerated: queryTypeStats.unknownTypes,
-          typeNodesGenerated: queryTypeStats.allTypes,
-          emptyUnionTypeNodesGenerated: queryTypeStats.emptyUnions,
-        })
-      } catch (err) {
-        parentPort?.postMessage({
-          type: 'error',
-          error: new Error(
-            `Error generating types for query "${queryName}" in "${result.filename}": ${err.message}`,
-            {cause: err},
-          ),
-          fatal: false,
-          query,
-        } satisfies TypegenGenerateTypesWorkerMessage)
-      }
-    }
-
-    if (fileQueryTypes.length > 0) {
-      $info(`Generated types for ${fileQueryTypes.length} queries in "${result.filename}"\n`)
-      parentPort?.postMessage({
-        type: 'types',
-        types: fileQueryTypes,
-        filename: result.filename,
-      } satisfies TypegenGenerateTypesWorkerMessage)
-    }
-
-    if (fileQueryTypes.length > 0) {
-      allQueries.push(...fileQueryTypes)
-    }
-  }
-
-  if (opts.overloadClientMethods && allQueries.length > 0) {
-    const typeMap = `${typeGenerator.generateQueryMap(allQueries).trim()}\n`
-    parentPort?.postMessage({
-      type: 'typemap',
-      typeMap,
-    } satisfies TypegenGenerateTypesWorkerMessage)
-  }
-
-  parentPort?.postMessage({
-    type: 'complete',
-  } satisfies TypegenGenerateTypesWorkerMessage)
-}
-
-function walkAndCountQueryTypeNodeStats(typeNode: TypeNode): {
-  allTypes: number
-  unknownTypes: number
-  emptyUnions: number
-} {
-  switch (typeNode.type) {
-    case 'unknown': {
-      return {allTypes: 1, unknownTypes: 1, emptyUnions: 0}
-    }
-    case 'array': {
-      const acc = walkAndCountQueryTypeNodeStats(typeNode.of)
-      acc.allTypes += 1 // count the array type itself
-      return acc
-    }
-    case 'object': {
-      // if the rest is unknown, we count it as one unknown type
-      if (typeNode.rest && typeNode.rest.type === 'unknown') {
-        return {allTypes: 2, unknownTypes: 1, emptyUnions: 0} // count the object type itself as well
-      }
-
-      const restStats = typeNode.rest
-        ? walkAndCountQueryTypeNodeStats(typeNode.rest)
-        : {allTypes: 1, unknownTypes: 0, emptyUnions: 0} // count the object type itself
-
-      return Object.values(typeNode.attributes).reduce((acc, attribute) => {
-        const {allTypes, unknownTypes, emptyUnions} = walkAndCountQueryTypeNodeStats(
-          attribute.value,
-        )
-        return {
-          allTypes: acc.allTypes + allTypes,
-          unknownTypes: acc.unknownTypes + unknownTypes,
-          emptyUnions: acc.emptyUnions + emptyUnions,
-        }
-      }, restStats)
-    }
-    case 'union': {
-      if (typeNode.of.length === 0) {
-        return {allTypes: 1, unknownTypes: 0, emptyUnions: 1}
-      }
-
-      return typeNode.of.reduce(
-        (acc, type) => {
-          const {allTypes, unknownTypes, emptyUnions} = walkAndCountQueryTypeNodeStats(type)
-          return {
-            allTypes: acc.allTypes + allTypes,
-            unknownTypes: acc.unknownTypes + unknownTypes,
-            emptyUnions: acc.emptyUnions + emptyUnions,
-          }
-        },
-        {allTypes: 1, unknownTypes: 0, emptyUnions: 0}, // count the union type itself
-      )
-    }
-    default: {
-      return {allTypes: 1, unknownTypes: 0, emptyUnions: 0}
-    }
-  }
-}
-
-main()