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

package/src/util/getProjectDefaults.ts

@@ -1,103 +0,0 @@
-import fs from 'node:fs/promises'
-import path from 'node:path'
-
-import getGitConfig from '@rexxars/gitconfiglocal'
-import {getGitUserInfo} from 'git-user-info'
-import promiseProps from 'promise-props-recursive'
-
-import {type CliCommandContext} from '../types'
-import {getCliToken} from './clientWrapper'
-
-export interface ProjectDefaults {
-  license: string
-  author: string | undefined
-  gitRemote: string
-  projectName: string
-  description: string
-}
-
-export function getProjectDefaults(
-  workDir: string,
-  {isPlugin, context}: {isPlugin: boolean; context: CliCommandContext},
-): Promise<ProjectDefaults> {
-  const cwd = process.cwd()
-  const isSanityRoot = workDir === cwd
-
-  return promiseProps({
-    license: 'UNLICENSED',
-
-    author: getUserInfo(context),
-
-    // Don't try to use git remote from main Sanity project for plugins
-    gitRemote: isPlugin && isSanityRoot ? '' : resolveGitRemote(cwd),
-
-    // Don't try to guess plugin name if we're initing from Sanity root
-    projectName: isPlugin && isSanityRoot ? '' : path.basename(cwd),
-
-    // If we're initing a plugin, don't use description from Sanity readme
-    description: getProjectDescription({isSanityRoot, isPlugin, outputDir: cwd}),
-  })
-}
-
-async function resolveGitRemote(cwd: string): Promise<string | undefined> {
-  try {
-    await fs.stat(path.join(cwd, '.git'))
-    const cfg = await getGitConfig(cwd)
-    return cfg.remote && cfg.remote.origin && cfg.remote.origin.url
-  } catch {
-    return undefined
-  }
-}
-
-async function getUserInfo(context: CliCommandContext): Promise<string | undefined> {
-  const user = await getGitUserInfo()
-  if (!user) {
-    return getSanityUserInfo(context)
-  }
-
-  if (user.name && user.email) {
-    return `${user.name} <${user.email}>`
-  }
-
-  return undefined
-}
-
-async function getSanityUserInfo(context: CliCommandContext): Promise<string | undefined> {
-  const hasToken = Boolean(getCliToken())
-  if (!hasToken) {
-    return undefined
-  }
-
-  const client = context.apiClient({requireUser: true, requireProject: false})
-  try {
-    const user = await client.users.getById('me')
-    return user ? `${user.name} <${user.email}>` : undefined
-  } catch {
-    return undefined
-  }
-}
-
-async function getProjectDescription({
-  isSanityRoot,
-  isPlugin,
-  outputDir,
-}: {
-  isSanityRoot: boolean
-  isPlugin: boolean
-  outputDir: string
-}): Promise<string> {
-  const tryResolve = isSanityRoot && !isPlugin
-  if (!tryResolve) {
-    return Promise.resolve('')
-  }
-
-  // Try to grab a project description from a standard GitHub-generated readme
-  try {
-    const readmePath = path.join(outputDir, 'README.md')
-    const readme = await fs.readFile(readmePath, {encoding: 'utf8'})
-    const match = readme.match(/^# .*?\n+(\w.*?)(?:$|\n)/)
-    return ((match && match[1]) || '').replace(/\.$/, '') || ''
-  } catch (err) {
-    return ''
-  }
-}

package/src/util/getProviderName.ts

@@ -1,9 +0,0 @@
-import {type SanityUser} from '../types'
-
-export function getProviderName(provider: SanityUser['provider']) {
-  if (provider === 'google') return 'Google'
-  if (provider === 'github') return 'GitHub'
-  if (provider === 'sanity') return 'Email'
-  if (provider.startsWith('saml-')) return 'SAML'
-  return provider
-}

package/src/util/getUserConfig.ts

@@ -1,15 +0,0 @@
-import ConfigStore from 'configstore'
-
-// eslint-disable-next-line no-process-env
-const sanityEnv = (process.env.SANITY_INTERNAL_ENV || '').toLowerCase()
-const configName = sanityEnv && sanityEnv !== 'production' ? `sanity-${sanityEnv}` : 'sanity'
-const defaults = {}
-let config: ConfigStore
-
-export const getUserConfig = (): ConfigStore => {
-  if (!config) {
-    config = new ConfigStore(configName, defaults, {globalConfigPath: true})
-  }
-
-  return config
-}

package/src/util/isCi.ts

@@ -1,7 +0,0 @@
-/* eslint-disable no-process-env */
-import {isTrueish} from './isTrueish'
-
-export const isCi =
-  isTrueish(process.env.CI) || // Travis CI, CircleCI, Gitlab CI, Appveyor, CodeShip
-  isTrueish(process.env.CONTINUOUS_INTEGRATION) || // Travis CI
-  process.env.BUILD_NUMBER // Jenkins, TeamCity

package/src/util/isCommandGroup.ts

@@ -1,7 +0,0 @@
-import {type CliCommandDefinition, type CliCommandGroupDefinition} from '../types'
-
-export function isCommandGroup(
-  cmdOrGroup: CliCommandDefinition | CliCommandGroupDefinition,
-): cmdOrGroup is CliCommandGroupDefinition {
-  return 'isGroupRoot' in cmdOrGroup
-}

package/src/util/isInteractive.ts

@@ -1,3 +0,0 @@
-/* eslint-disable no-process-env */
-export const isInteractive =
-  process.stdout.isTTY && process.env.TERM !== 'dumb' && !('CI' in process.env)

package/src/util/isTrueish.ts

@@ -1,8 +0,0 @@
-export function isTrueish(value: string | undefined) {
-  if (value === undefined) return false
-  if (value.toLowerCase() === 'true') return true
-  if (value.toLowerCase() === 'false') return false
-  const number = parseInt(value, 10)
-  if (isNaN(number)) return false
-  return number > 0
-}

package/src/util/journeyConfig.ts

@@ -1,280 +0,0 @@
-import fs from 'node:fs/promises'
-import path from 'node:path'
-import {Worker} from 'node:worker_threads'
-
-import {
-  type BaseSchemaDefinition,
-  type DocumentDefinition,
-  type ObjectDefinition,
-} from '@sanity/types'
-import {format} from 'prettier'
-
-import {type CliApiClient} from '../types'
-import {getCliWorkerPath} from './cliWorker'
-
-/**
- * A Journey schema is a server schema that is saved in the Journey API
- */
-
-interface JourneySchemaWorkerData {
-  schemasPath: string
-  useTypeScript: boolean
-  schemaUrl: string
-}
-
-type JourneySchemaWorkerResult = {type: 'success'} | {type: 'error'; error: Error}
-
-interface JourneyConfigResponse {
-  projectId: string
-  datasetName: string
-  displayName: string
-  schemaUrl: string
-  isFirstProject: boolean // Always true for now, making it compatible with the existing getOrCreateProject
-}
-
-type DocumentOrObject = DocumentDefinition | ObjectDefinition
-type SchemaObject = BaseSchemaDefinition & {
-  type: string
-  fields?: SchemaObject[]
-  of?: SchemaObject[]
-  preview?: object
-}
-
-/**
- * Fetch a Journey schema from the Sanity schema club API and write it to disk
- */
-export async function getAndWriteJourneySchema(data: JourneySchemaWorkerData): Promise<void> {
-  const {schemasPath, useTypeScript, schemaUrl} = data
-  try {
-    const documentTypes = await fetchJourneySchema(schemaUrl)
-    const fileExtension = useTypeScript ? 'ts' : 'js'
-
-    // Write a file for each schema
-    for (const documentType of documentTypes) {
-      const filePath = path.join(schemasPath, `${documentType.name}.${fileExtension}`)
-      await fs.writeFile(filePath, await assembleJourneySchemaTypeFileContent(documentType))
-    }
-    // Write an index file that exports all the schemas
-    const indexContent = await assembleJourneyIndexContent(documentTypes)
-    await fs.writeFile(path.join(schemasPath, `index.${fileExtension}`), indexContent)
-  } catch (error) {
-    throw new Error(`Failed to fetch remote schema: ${error.message}`)
-  }
-}
-
-/**
- * Executes the `getAndWriteJourneySchema` operation within a worker thread.
- *
- * This method is designed to safely import network resources by leveraging the `--experimental-network-imports` flag.
- * Due to the experimental nature of this flag, its use is not recommended in the main process. Consequently,
- * the task is delegated to a worker thread to ensure both safety and compliance with best practices.
- *
- * The core functionality involves fetching schema definitions from our own trusted API and writing them to disk.
- * This includes handling both predefined and custom schemas. For custom schemas, a process ensures
- * that they undergo JSON parsing to remove any JavaScript code and are validated before being saved.
- *
- * Depending on the configuration, the schemas are saved as either TypeScript or JavaScript files, dictated by the `useTypeScript` flag within the `workerData`.
- *
- * @param workerData - An object containing the necessary data and flags for the worker thread, including the path to save schemas, flags indicating whether to use TypeScript, and any other relevant configuration details.
- * @returns A promise that resolves upon successful execution of the schema fetching and writing process or rejects if an error occurs during the operation.
- */
-export async function getAndWriteJourneySchemaWorker(
-  workerData: JourneySchemaWorkerData,
-): Promise<void> {
-  const workerPath = await getCliWorkerPath('getAndWriteJourneySchema')
-  return new Promise((resolve, reject) => {
-    const worker = new Worker(workerPath, {
-      workerData,
-      env: {
-        // eslint-disable-next-line no-process-env
-        ...process.env,
-        // Dynamic HTTPS imports are currently behind a Node flag
-        NODE_OPTIONS: '--experimental-network-imports',
-        NODE_NO_WARNINGS: '1',
-      },
-    })
-    worker.on('message', (message: JourneySchemaWorkerResult) => {
-      if (message.type === 'success') {
-        resolve()
-      } else {
-        message.error.message = `Import schema worker failed: ${message.error.message}`
-        reject(message.error)
-      }
-    })
-    worker.on('error', (error) => {
-      error.message = `Import schema worker failed: ${error.message}`
-      reject(error)
-    })
-    worker.on('exit', (code) => {
-      if (code !== 0) {
-        reject(new Error(`Worker stopped with exit code ${code}`))
-      }
-    })
-  })
-}
-
-/**
- * Fetch a Journey config from the Sanity schema club API
- *
- * @param projectId - The slug of the Journey schema to fetch
- * @returns The Journey schema as an array of Sanity document or object definitions
- */
-export async function fetchJourneyConfig(
-  apiClient: CliApiClient,
-  projectId: string,
-): Promise<JourneyConfigResponse> {
-  if (!projectId) {
-    throw new Error('ProjectId is required')
-  }
-  if (!/^[a-zA-Z0-9-]+$/.test(projectId)) {
-    throw new Error('Invalid projectId')
-  }
-  try {
-    const response: {
-      projectId: string
-      dataset: string
-      displayName?: string
-      schemaUrl: string
-    } = await apiClient({
-      requireUser: true,
-      requireProject: true,
-      api: {projectId},
-    })
-      .config({apiVersion: 'v2024-02-23'})
-      .request({
-        method: 'GET',
-        uri: `/journey/projects/${projectId}`,
-      })
-
-    return {
-      projectId: response.projectId,
-      datasetName: response.dataset,
-      displayName: response.displayName || 'Sanity Project',
-      // The endpoint returns a signed URL that can be used to fetch the schema as ESM
-      schemaUrl: response.schemaUrl,
-      isFirstProject: true,
-    }
-  } catch {
-    throw new Error(`Failed to fetch remote schema config: ${projectId}`)
-  }
-}
-
-/**
- * Fetch a Journey schema from the Sanity schema club API
- *
- * @param projectId - The slug of the Journey schema to fetch
- * @returns The Journey schema as an array of Sanity document or object definitions
- */
-async function fetchJourneySchema(schemaUrl: string): Promise<DocumentOrObject[]> {
-  try {
-    const response = await import(schemaUrl)
-    return response.default
-  } catch {
-    throw new Error(`Failed to fetch remote schema: ${schemaUrl}`)
-  }
-}
-
-/**
- * Assemble a Journey schema type into a module export
- * Include the necessary imports and export the schema type as a named export
- *
- * @param schema - The Journey schema to export
- * @returns The Journey schema as a module export
- */
-async function assembleJourneySchemaTypeFileContent(schemaType: DocumentOrObject): Promise<string> {
-  const serialised = wrapSchemaTypeInHelpers(schemaType)
-  const imports = getImports(serialised)
-  const prettifiedSchemaType = await format(serialised, {
-    parser: 'typescript',
-    printWidth: 40,
-  })
-  // Start file with import, then export the schema type as a named export
-  return `${imports}\n\nexport const ${schemaType.name} = ${prettifiedSchemaType}\n`
-}
-
-/**
- * Assemble a list of Journey schema module exports into a single index file
- *
- * @param schemas - The Journey schemas to assemble into an index file
- * @returns The index file as a string
- */
-function assembleJourneyIndexContent(schemas: DocumentOrObject[]): Promise<string> {
-  const sortedSchema = schemas.slice().sort((a, b) => (a.name > b.name ? 1 : -1))
-  const imports = sortedSchema.map((schema) => `import { ${schema.name} } from './${schema.name}'`)
-  const exports = sortedSchema.map((schema) => schema.name).join(',')
-  const fileContents = `${imports.join('\n')}\n\nexport const schemaTypes = [${exports}]`
-  return format(fileContents, {parser: 'typescript'})
-}
-
-/**
- * Get the import statements for a schema type
- *
- * @param schemaType - The schema type to get the imports for
- * @returns The import statements for the schema type
- */
-function getImports(schemaType: string): string {
-  const defaultImports = ['defineType', 'defineField']
-  if (schemaType.includes('defineArrayMember')) {
-    defaultImports.push('defineArrayMember')
-  }
-  return `import { ${defaultImports.join(', ')} } from 'sanity'`
-}
-
-/**
- * Serialize a singleSanity schema type (signular) into a string.
- * Wraps the schema object in the appropriate helper function.
- *
- * @param schemaType - The schema type to serialize
- * @returns The schema type as a string
- */
-/**
- * Serializes a single Sanity schema type into a string.
- * Wraps the schema object in the appropriate helper function.
- *
- * @param schemaType - The schema type to serialize
- * @param root - Whether the schemaType is the root object
- * @returns The serialized schema type as a string
- */
-export function wrapSchemaTypeInHelpers(schemaType: SchemaObject, root: boolean = true): string {
-  if (root) {
-    return generateSchemaDefinition(schemaType, 'defineType')
-  } else if (schemaType.type === 'array') {
-    return `${generateSchemaDefinition(schemaType, 'defineField')},`
-  }
-  return `${generateSchemaDefinition(schemaType, 'defineField')},`
-
-  function generateSchemaDefinition(
-    object: SchemaObject,
-    definitionType: 'defineType' | 'defineField',
-  ): string {
-    const {fields, preview, of, ...otherProperties} = object
-
-    const serializedProps = serialize(otherProperties)
-    const fieldsDef =
-      fields && `fields: [${fields.map((f) => wrapSchemaTypeInHelpers(f, false)).join('')}]`
-    const ofDef = of && `of: [${of.map((f) => `defineArrayMember({${serialize(f)}})`).join(',')}]`
-    const previewDef = preview && `preview: {${serialize(preview)}}`
-
-    const combinedDefinitions = [serializedProps, fieldsDef, ofDef, previewDef]
-      .filter(Boolean)
-      .join(',')
-    return `${definitionType}({ ${combinedDefinitions} })`
-  }
-
-  function serialize(obj: object) {
-    return Object.entries(obj)
-      .map(([key, value]) => {
-        if (key === 'prepare') {
-          return `${value.toString()}`
-        }
-        if (typeof value === 'string') {
-          return `${key}: "${value}"`
-        }
-        if (typeof value === 'object') {
-          return `${key}: ${JSON.stringify(value)}`
-        }
-        return `${key}: ${value}`
-      })
-      .join(',')
-  }
-}

package/src/util/loadEnv.ts

@@ -1,110 +0,0 @@
-/**
- * This is an "inlined" version of Vite's `loadEnv` function,
- * simplified somewhat to only support our use case.
- *
- * Ideally we'd just use `loadEnv` from Vite, but importing it
- * causes bundling issues due to node APIs and downstream dependencies.
- *
- * Vite is MIT licensed, copyright (c) Yuxi (Evan) You and Vite contributors.
- */
-
-/* eslint-disable no-process-env */
-import fs from 'node:fs'
-import path from 'node:path'
-
-import {parse} from 'dotenv'
-import {expand} from 'dotenv-expand'
-
-export function loadEnv(
-  mode: string,
-  envDir: string,
-  prefixes: string[] = ['VITE_'],
-): Record<string, string> {
-  if (mode === 'local') {
-    throw new Error(
-      `"local" cannot be used as a mode name because it conflicts with ` +
-        `the .local postfix for .env files.`,
-    )
-  }
-
-  const env: Record<string, string> = {}
-  const envFiles = [
-    /** default file */ `.env`,
-    /** local file */ `.env.local`,
-    /** mode file */ `.env.${mode}`,
-    /** mode local file */ `.env.${mode}.local`,
-  ]
-
-  const parsed = Object.fromEntries(
-    envFiles.flatMap((file) => {
-      const envPath = lookupFile(envDir, [file], {
-        rootDir: envDir,
-      })
-      if (!envPath) return []
-      return Object.entries(parse(fs.readFileSync(envPath)))
-    }),
-  )
-
-  // test NODE_ENV override before expand as otherwise process.env.NODE_ENV would override this
-  if (parsed.NODE_ENV && process.env.VITE_USER_NODE_ENV === undefined) {
-    process.env.VITE_USER_NODE_ENV = parsed.NODE_ENV
-  }
-  // support BROWSER and BROWSER_ARGS env variables
-  if (parsed.BROWSER && process.env.BROWSER === undefined) {
-    process.env.BROWSER = parsed.BROWSER
-  }
-  if (parsed.BROWSER_ARGS && process.env.BROWSER_ARGS === undefined) {
-    process.env.BROWSER_ARGS = parsed.BROWSER_ARGS
-  }
-
-  try {
-    // let environment variables use each other
-    expand({parsed})
-  } catch (e) {
-    // custom error handling until https://github.com/motdotla/dotenv-expand/issues/65 is fixed upstream
-    // check for message "TypeError: Cannot read properties of undefined (reading 'split')"
-    if (e.message.includes('split')) {
-      throw new Error('dotenv-expand failed to expand env vars. Maybe you need to escape `$`?')
-    }
-    throw e
-  }
-
-  // only keys that start with prefix are exposed to client
-  for (const [key, value] of Object.entries(parsed)) {
-    if (prefixes.some((prefix) => key.startsWith(prefix))) {
-      env[key] = value
-    }
-  }
-
-  // check if there are actual env variables starting with VITE_*
-  // these are typically provided inline and should be prioritized
-  for (const key in process.env) {
-    if (prefixes.some((prefix) => key.startsWith(prefix))) {
-      env[key] = process.env[key] as string
-    }
-  }
-
-  return env
-}
-
-function lookupFile(
-  dir: string,
-  formats: string[],
-  options?: {
-    rootDir?: string
-  },
-): string | undefined {
-  for (const format of formats) {
-    const fullPath = path.join(dir, format)
-    // eslint-disable-next-line no-sync
-    if (fs.existsSync(fullPath) && fs.statSync(fullPath).isFile()) {
-      return fullPath
-    }
-  }
-  const parentDir = path.dirname(dir)
-  if (parentDir !== dir && (!options?.rootDir || parentDir.startsWith(options?.rootDir))) {
-    return lookupFile(parentDir, formats, options)
-  }
-
-  return undefined
-}

package/src/util/mergeCommands.ts

@@ -1,78 +0,0 @@
-import {find} from 'lodash'
-import semver from 'semver'
-
-import {
-  type CliCommandDefinition,
-  type CliCommandGroupDefinition,
-  type SanityCore,
-  type SanityModuleInternal,
-} from '../types'
-import {dynamicRequire} from './dynamicRequire'
-import {isCommandGroup} from './isCommandGroup'
-
-export interface MergeOptions {
-  cwd: string
-  workDir: string
-  cliVersion: string
-}
-
-export async function mergeCommands(
-  baseCommands: (CliCommandDefinition | CliCommandGroupDefinition)[],
-  corePath: string | undefined,
-  options: MergeOptions,
-): Promise<(CliCommandDefinition | CliCommandGroupDefinition)[]> {
-  if (!corePath) {
-    return baseCommands
-  }
-
-  const {cwd, workDir, cliVersion} = options
-  const coreImport = dynamicRequire<SanityCore | SanityModuleInternal>(corePath)
-  const coercedCliVersion = semver.coerce(cliVersion) || ''
-  const moduleName = /@sanity[/\\]core/.test(corePath) ? '@sanity/core' : 'sanity'
-  const core = 'cliProjectCommands' in coreImport ? coreImport.cliProjectCommands : coreImport
-
-  // @todo the resolving of `sanity`/`@sanity/core` here might find global installs,
-  // which can lead to incorrect versioning being reported. We should only run this
-  // check if we are within a project dir, and even then only if it is not global
-  /*
-  if (
-    core.requiredCliVersionRange &&
-    !semver.satisfies(coercedCliVersion, core.requiredCliVersionRange)
-  ) {
-    const upgradeCmd = chalk.yellow(await getCliUpgradeCommand({cwd, workDir}))
-    console.error(
-      `The version of the \`${moduleName}\` installed in this project requires @sanity/cli @ ${chalk.green(
-        core.requiredCliVersionRange
-      )}. Currently installed version is ${chalk.red(
-        cliVersion
-      )}.\n\nPlease upgrade by running:\n\n  ${upgradeCmd}\n\n`
-    )
-    process.exit(1)
-  }
-  */
-
-  const merged = baseCommands.concat(core.commands).map(addDefaultGroup)
-
-  // Remove duplicate commands when within the same group,
-  // the last defined commands with the given name wins
-  return merged.reverse().reduce(
-    (cmds, cmd) => {
-      const group = isCommandGroup(cmd) ? undefined : cmd.group
-      if (!find(cmds, {name: cmd.name, group})) {
-        cmds.push(cmd)
-      }
-      return cmds
-    },
-    [] as (CliCommandDefinition | CliCommandGroupDefinition)[],
-  )
-}
-
-function addDefaultGroup(
-  cmd: CliCommandDefinition | CliCommandGroupDefinition,
-): CliCommandDefinition | CliCommandGroupDefinition {
-  if (!isCommandGroup(cmd) && !cmd.group) {
-    cmd.group = 'default'
-  }
-
-  return cmd
-}

package/src/util/neatStack.ts

@@ -1,30 +0,0 @@
-/**
- * TypeScript version of the `neat-stack` module by
- * ISC License (ISC)
- * Copyright 2017 - 2019 Shinnosuke Watanabe
- */
-import {inspect} from 'node:util'
-
-import {dim, red} from 'chalk'
-import cleanStack from 'clean-stack'
-
-const options = {pretty: process.platform !== 'win32'}
-
-export function neatStack(error: string | Error): string {
-  if (typeof error === 'string') {
-    return red(cleanStack(error, options))
-  }
-
-  if (error === null || typeof error !== 'object' || typeof error.stack !== 'string') {
-    return red(inspect(error))
-  }
-
-  const title = error.toString()
-  const stack = cleanStack(error.stack, options)
-
-  if (!stack.startsWith(title)) {
-    return red(stack)
-  }
-
-  return red(`${title}${dim(cleanStack(error.stack, options).slice(title.length))}`)
-}