@sanity/cli 3.93.1-next.9.198ab74452 → 3.94.0

package/src/actions/codemod/types.ts

@@ -1,10 +0,0 @@
-import {type CliCommandContext} from '../../types'
-
-export interface CodeMod {
-  purpose: string
-  description: string
-  verify?: (context: CliCommandContext) => Promise<void>
-
-  // Must match filename in `cli/codemods/`
-  filename: string
-}

package/src/actions/init-plugin/bootstrapFromTemplate.ts

@@ -1,196 +0,0 @@
-import fs from 'node:fs/promises'
-import path from 'node:path'
-
-import {absolutify, pathIsEmpty} from '@sanity/util/fs'
-import decompress from 'decompress'
-import {getIt} from 'get-it'
-import {promise} from 'get-it/middleware'
-import resolveFrom from 'resolve-from'
-import semver from 'semver'
-import validateNpmPackageName from 'validate-npm-package-name'
-
-import {type CliCommandContext} from '../..'
-import {debug} from '../../debug'
-import {type SanityJson} from '../../types'
-import {dynamicRequire} from '../../util/dynamicRequire'
-import {getCliVersion} from '../../util/getCliVersion'
-import {readJson} from '../../util/readJson'
-
-const request = getIt([promise()])
-
-interface TemplateManifest {
-  sanityTemplate: {
-    minimumBaseVersion?: string
-    minimumCliVersion?: string
-    suggestedName?: string
-    requiresConfig?: boolean
-    dependencies?: Record<string, string>
-  }
-}
-
-export async function bootstrapFromTemplate(
-  context: CliCommandContext,
-  url: string,
-): Promise<{
-  name: string
-  outputPath: string
-  inPluginsPath: boolean
-  dependencies: any
-}> {
-  const {prompt, workDir} = context
-  const cliVersion = await getCliVersion()
-  let inProjectContext = false
-  try {
-    const projectManifest = await readJson<SanityJson>(path.join(workDir, 'sanity.json'))
-    inProjectContext = Boolean(projectManifest.root)
-  } catch {
-    // Intentional noop
-  }
-
-  debug(inProjectContext ? 'Project context found' : 'Not in project context')
-
-  let zip: decompress.File[]
-  try {
-    debug('Fetching zip from %s', url)
-    zip = await getZip(url)
-    debug('Zip finished downloading')
-  } catch (err) {
-    err.message = `Failed to get template: ${err.message}`
-    throw err
-  }
-
-  debug('Looking up template manifest from zip')
-  const manifest = zip.find(
-    (file) => path.basename(file.path) === 'package.json' && !file.path.includes('node_modules'),
-  )
-
-  if (!manifest) {
-    throw new Error('Could not find `package.json` in template')
-  }
-
-  // Note: Paths inside the zips are always unix-style, so do not use `path.join` here
-  const baseDir = `${path.dirname(manifest.path)}/template`
-  debug('Manifest path resolved to %s', manifest.path)
-  debug('Base directory resolved to %s', baseDir)
-
-  const templateFiles = zip.filter(
-    (file) => file.type === 'file' && file.path.indexOf(baseDir) === 0,
-  )
-  debug('%d files found in template', templateFiles.length)
-
-  const manifestContent = parseJson<TemplateManifest>(manifest.data.toString())
-  const tplVars = manifestContent?.sanityTemplate || {}
-  const {minimumBaseVersion, minimumCliVersion} = tplVars
-
-  if (minimumBaseVersion) {
-    debug('Template requires Sanity version %s', minimumBaseVersion)
-    const installed = getSanityVersion(workDir, cliVersion)
-    debug('Installed Sanity version is %s', installed)
-
-    if (semver.lt(installed, minimumBaseVersion)) {
-      throw new Error(
-        `Template requires Sanity at version ${minimumBaseVersion}, installed is ${installed}`,
-      )
-    }
-  }
-
-  if (minimumCliVersion) {
-    debug('Template requires Sanity CLI version %s', minimumCliVersion)
-    debug('Installed CLI version is %s', cliVersion)
-
-    if (semver.lt(cliVersion, minimumCliVersion)) {
-      throw new Error(
-        `Template requires @sanity/cli at version ${minimumCliVersion}, installed is ${cliVersion}`,
-      )
-    }
-  }
-
-  const name = await prompt.single({
-    type: 'input',
-    message: 'Plugin name:',
-    default: tplVars.suggestedName || '',
-    validate: async (pkgName) => {
-      const {validForNewPackages} = validateNpmPackageName(pkgName)
-      if (!validForNewPackages) {
-        return 'Name must be a valid npm package name (https://docs.npmjs.com/files/package.json#name)'
-      }
-
-      const outputPath = path.join(workDir, 'plugins', pkgName)
-      const isEmpty = await pathIsEmpty(outputPath)
-      if (inProjectContext && !isEmpty) {
-        return 'Plugin with given name already exists in project'
-      }
-
-      return true
-    },
-  })
-
-  let outputPath = path.join(workDir, 'plugins', name)
-  if (!inProjectContext) {
-    const cwdIsEmpty = await pathIsEmpty(workDir)
-    outputPath = await prompt.single({
-      type: 'input',
-      message: 'Output path:',
-      default: cwdIsEmpty ? workDir : path.join(workDir, name),
-      validate: validateEmptyPath,
-      filter: absolutify,
-    })
-  }
-
-  debug('Output path set to %s', outputPath)
-
-  let createConfig = tplVars.requiresConfig
-  if (typeof createConfig === 'undefined') {
-    createConfig = await prompt.single({
-      type: 'confirm',
-      message: 'Does the plugin need a configuration file?',
-      default: false,
-    })
-  }
-
-  debug('Ensuring directory exists: %s', outputPath)
-  await fs.mkdir(outputPath, {recursive: true})
-
-  await Promise.all(
-    templateFiles.map((file: {path: string; data: string | Buffer}) => {
-      const filename = file.path.slice(baseDir.length)
-
-      debug('Writing template file "%s" to "%s"', filename, outputPath)
-      return fs.writeFile(path.join(outputPath, filename), file.data)
-    }),
-  )
-
-  return {name, outputPath, inPluginsPath: inProjectContext, dependencies: tplVars.dependencies}
-}
-
-async function validateEmptyPath(dir: string) {
-  const isEmpty = await pathIsEmpty(dir)
-  return isEmpty ? true : 'Path is not empty'
-}
-
-function getZip(url: string): Promise<decompress.File[]> {
-  return request({url, rawBody: true}).then(
-    (res: {statusCode: number; statusMessage: string; body: Buffer}) => {
-      if (res.statusCode > 299) {
-        const httpErr = ['HTTP', res.statusCode, res.statusMessage].filter(Boolean).join(' ')
-        throw new Error(`${httpErr} trying to download ${url}`)
-      }
-
-      return decompress(res.body)
-    },
-  )
-}
-
-function parseJson<T = any>(json: string): T | undefined {
-  try {
-    return JSON.parse(json)
-  } catch {
-    return undefined
-  }
-}
-
-function getSanityVersion(workDir: string, fallback: string): string {
-  // This is only used in v2, thus `@sanity/base`
-  const basePkg = resolveFrom.silent(workDir, '@sanity/base/package.json')
-  return basePkg ? dynamicRequire(basePkg).version : fallback
-}

package/src/actions/init-project/bootstrapLocalTemplate.ts

@@ -1,201 +0,0 @@
-import fs from 'node:fs/promises'
-import path from 'node:path'
-
-import chalk from 'chalk'
-import {deburr} from 'lodash'
-
-import {debug} from '../../debug'
-import {studioDependencies} from '../../studioDependencies'
-import {type CliCommandContext} from '../../types'
-import {copy} from '../../util/copy'
-import {getAndWriteJourneySchemaWorker} from '../../util/journeyConfig'
-import {resolveLatestVersions} from '../../util/resolveLatestVersions'
-import {createAppCliConfig} from './createAppCliConfig'
-import {createCliConfig} from './createCliConfig'
-import {createPackageManifest} from './createPackageManifest'
-import {createStudioConfig, type GenerateConfigOptions} from './createStudioConfig'
-import {determineAppTemplate} from './determineAppTemplate'
-import {type ProjectTemplate} from './initProject'
-import templates from './templates'
-import {updateInitialTemplateMetadata} from './updateInitialTemplateMetadata'
-
-export interface BootstrapLocalOptions {
-  packageName: string
-  templateName: string
-  /**
-   * Used for initializing a project from a server schema that is saved in the Journey API
-   * @beta
-   */
-  schemaUrl?: string
-  outputPath: string
-  useTypeScript: boolean
-  variables: GenerateConfigOptions['variables']
-}
-
-export async function bootstrapLocalTemplate(
-  opts: BootstrapLocalOptions,
-  context: CliCommandContext,
-): Promise<ProjectTemplate> {
-  const {apiClient, cliRoot, output} = context
-  const templatesDir = path.join(cliRoot, 'templates')
-  const {outputPath, templateName, useTypeScript, packageName, variables} = opts
-  const sourceDir = path.join(templatesDir, templateName)
-  const sharedDir = path.join(templatesDir, 'shared')
-  const isAppTemplate = determineAppTemplate(templateName)
-
-  // Check that we have a template info file (dependencies, plugins etc)
-  const template = templates[templateName]
-  if (!template) {
-    throw new Error(`Template "${templateName}" not defined`)
-  }
-
-  // Copy template files
-  debug('Copying files from template "%s" to "%s"', templateName, outputPath)
-  let spinner = output
-    .spinner(
-      opts.schemaUrl ? 'Extracting your Sanity configuration' : 'Bootstrapping files from template',
-    )
-    .start()
-
-  await copy(sourceDir, outputPath, {
-    rename: useTypeScript ? toTypeScriptPath : undefined,
-  })
-  await copy(path.join(sharedDir, 'gitignore.txt'), outputPath, {rename: () => '.gitignore'})
-
-  if (useTypeScript) {
-    await fs.copyFile(path.join(sharedDir, 'tsconfig.json'), path.join(outputPath, 'tsconfig.json'))
-  }
-
-  // If we have a schemaUrl, get the schema and write it to disk
-  // At this point the selected template should already have been forced to "clean"
-  if (opts.schemaUrl) {
-    debug('Fetching and writing remote schema "%s"', opts.schemaUrl)
-    await getAndWriteJourneySchemaWorker({
-      schemasPath: path.join(outputPath, 'schemaTypes'),
-      useTypeScript,
-      schemaUrl: opts.schemaUrl,
-    })
-  }
-
-  spinner.succeed()
-
-  // Merge global and template-specific plugins and dependencies
-
-  // Resolve latest versions of Sanity-dependencies
-  spinner = output.spinner('Resolving latest module versions').start()
-  const dependencyVersions = await resolveLatestVersions({
-    ...(isAppTemplate ? {} : studioDependencies.dependencies),
-    ...(isAppTemplate ? {} : studioDependencies.devDependencies),
-    ...template.dependencies,
-    ...template.devDependencies,
-  })
-  spinner.succeed()
-
-  // Use the resolved version for the given dependency
-  const dependencies = Object.keys({
-    ...(isAppTemplate ? {} : studioDependencies.dependencies),
-    ...template.dependencies,
-  }).reduce(
-    (deps, dependency) => {
-      deps[dependency] = dependencyVersions[dependency]
-      return deps
-    },
-    {} as Record<string, string>,
-  )
-
-  const devDependencies = Object.keys({
-    ...(isAppTemplate ? {} : studioDependencies.devDependencies),
-    ...template.devDependencies,
-  }).reduce(
-    (deps, dependency) => {
-      deps[dependency] = dependencyVersions[dependency]
-      return deps
-    },
-    {} as Record<string, string>,
-  )
-
-  let packageJsonName: string = packageName
-
-  /**
-   * Currently app init doesn't ask for a name, so we use the last part of the path
-   */
-  if (isAppTemplate) {
-    packageJsonName = deburr(path.basename(outputPath).toLowerCase())
-      .replace(/\s+/g, '-')
-      .replace(/[^a-z0-9-]/g, '')
-  }
-
-  // Now create a package manifest (`package.json`) with the merged dependencies
-  spinner = output.spinner('Creating default project files').start()
-  const packageManifest = await createPackageManifest({
-    name: packageJsonName,
-    dependencies,
-    devDependencies,
-    scripts: template.scripts,
-    isAppTemplate,
-  })
-
-  // ...and a studio config (`sanity.config.[ts|js]`)
-  const studioConfig = createStudioConfig({
-    template: template.configTemplate,
-    variables,
-  })
-
-  // ...and a CLI config (`sanity.cli.[ts|js]`)
-  const cliConfig = isAppTemplate
-    ? createAppCliConfig({
-        entry: template.entry!,
-        organizationId: variables.organizationId,
-      })
-    : createCliConfig({
-        projectId: variables.projectId,
-        dataset: variables.dataset,
-        autoUpdates: variables.autoUpdates,
-      })
-
-  // Write non-template files to disc
-  const codeExt = useTypeScript ? 'ts' : 'js'
-  await Promise.all(
-    [
-      ...[
-        isAppTemplate
-          ? Promise.resolve(null)
-          : writeFileIfNotExists(`sanity.config.${codeExt}`, studioConfig),
-      ],
-      writeFileIfNotExists(`sanity.cli.${codeExt}`, cliConfig),
-      writeFileIfNotExists('package.json', packageManifest),
-      ...[
-        isAppTemplate
-          ? Promise.resolve(null)
-          : writeFileIfNotExists(
-              'eslint.config.mjs',
-              `import studio from '@sanity/eslint-config-studio'\n\nexport default [...studio]\n`,
-            ),
-      ],
-    ].filter(Boolean),
-  )
-
-  debug('Updating initial template metadata')
-  await updateInitialTemplateMetadata(apiClient, variables.projectId, `cli-${templateName}`)
-
-  // Finish up by providing init process with template-specific info
-  spinner.succeed()
-  return template
-
-  async function writeFileIfNotExists(fileName: string, content: string): Promise<void> {
-    const filePath = path.join(outputPath, fileName)
-    try {
-      await fs.writeFile(filePath, content, {flag: 'wx'})
-    } catch (err) {
-      if (err.code === 'EEXIST') {
-        output.warn(`\n${chalk.yellow('⚠')} File "${filePath}" already exists, skipping`)
-      } else {
-        throw err
-      }
-    }
-  }
-}
-
-function toTypeScriptPath(originalPath: string): string {
-  return originalPath.replace(/\.js$/, '.ts')
-}

package/src/actions/init-project/bootstrapRemoteTemplate.ts

@@ -1,118 +0,0 @@
-import {mkdir} from 'node:fs/promises'
-import {join} from 'node:path'
-
-import {getMonoRepo, GitHubFileReader, validateTemplate} from '@sanity/template-validator'
-import {type Framework, frameworks} from '@vercel/frameworks'
-import {detectFrameworkRecord, LocalFileSystemDetector} from '@vercel/fs-detectors'
-
-import {debug} from '../../debug'
-import {type CliCommandContext} from '../../types'
-import {getDefaultPortForFramework} from '../../util/frameworkPort'
-import {
-  applyEnvVariables,
-  checkIfNeedsApiToken,
-  downloadAndExtractRepo,
-  generateSanityApiToken,
-  getGitHubRawContentUrl,
-  type RepoInfo,
-  setCorsOrigin,
-  tryApplyPackageName,
-} from '../../util/remoteTemplate'
-import {type GenerateConfigOptions} from './createStudioConfig'
-import {tryGitInit} from './git'
-import {updateInitialTemplateMetadata} from './updateInitialTemplateMetadata'
-
-export interface BootstrapRemoteOptions {
-  outputPath: string
-  repoInfo: RepoInfo
-  bearerToken?: string
-  packageName: string
-  variables: GenerateConfigOptions['variables']
-}
-
-const SANITY_DEFAULT_PORT = 3333
-const READ_TOKEN_LABEL = 'Live Preview API'
-const WRITE_TOKEN_LABEL = 'App Write Token'
-const INITIAL_COMMIT_MESSAGE = 'Initial commit from Sanity CLI'
-
-export async function bootstrapRemoteTemplate(
-  opts: BootstrapRemoteOptions,
-  context: CliCommandContext,
-): Promise<void> {
-  const {outputPath, repoInfo, bearerToken, variables, packageName} = opts
-  const {output, apiClient} = context
-  const name = [repoInfo.username, repoInfo.name, repoInfo.filePath].filter(Boolean).join('/')
-  const contentsUrl = getGitHubRawContentUrl(repoInfo)
-  const headers: Record<string, string> = {}
-  if (bearerToken) {
-    headers.Authorization = `Bearer ${bearerToken}`
-  }
-  const spinner = output.spinner(`Bootstrapping files from template "${name}"`).start()
-  const corsAdded: number[] = [SANITY_DEFAULT_PORT]
-
-  debug('Validating remote template')
-  const fileReader = new GitHubFileReader(contentsUrl, headers)
-  const packages = await getMonoRepo(fileReader)
-  const validation = await validateTemplate(fileReader, packages)
-  if (!validation.isValid) {
-    throw new Error(validation.errors.join('\n'))
-  }
-
-  debug('Create new directory "%s"', outputPath)
-  await mkdir(outputPath, {recursive: true})
-
-  debug('Downloading and extracting repo to %s', outputPath)
-  await downloadAndExtractRepo(outputPath, repoInfo, bearerToken)
-
-  debug('Checking if template needs read token')
-  const needsReadToken = await Promise.all(
-    (packages ?? ['']).map((pkg) => checkIfNeedsApiToken(join(outputPath, pkg), 'read')),
-  ).then((results) => results.some(Boolean))
-  const needsWriteToken = await Promise.all(
-    (packages ?? ['']).map((pkg) => checkIfNeedsApiToken(join(outputPath, pkg), 'write')),
-  ).then((results) => results.some(Boolean))
-
-  debug('Applying environment variables')
-  const readToken = needsReadToken
-    ? await generateSanityApiToken(READ_TOKEN_LABEL, 'read', variables.projectId, apiClient)
-    : undefined
-  const writeToken = needsWriteToken
-    ? await generateSanityApiToken(WRITE_TOKEN_LABEL, 'write', variables.projectId, apiClient)
-    : undefined
-
-  for (const pkg of packages ?? ['']) {
-    const packagePath = join(outputPath, pkg)
-    const packageFramework: Framework | null = await detectFrameworkRecord({
-      fs: new LocalFileSystemDetector(packagePath),
-      frameworkList: frameworks as readonly Framework[],
-    })
-
-    const port = getDefaultPortForFramework(packageFramework?.slug)
-    if (corsAdded.includes(port) === false) {
-      debug('Setting CORS origin to http://localhost:%d', port)
-      await setCorsOrigin(`http://localhost:${port}`, variables.projectId, apiClient)
-      corsAdded.push(port)
-    }
-
-    debug('Applying environment variables to %s', pkg)
-    // Next.js uses `.env.local` for local environment variables
-    const envName = packageFramework?.slug === 'nextjs' ? '.env.local' : '.env'
-    await applyEnvVariables(packagePath, {...variables, readToken, writeToken}, envName)
-  }
-
-  debug('Setting package name to %s', packageName)
-  await tryApplyPackageName(outputPath, packageName)
-
-  debug('Initializing git repository')
-  tryGitInit(outputPath, INITIAL_COMMIT_MESSAGE)
-
-  debug('Updating initial template metadata')
-  await updateInitialTemplateMetadata(apiClient, variables.projectId, `external-${name}`)
-
-  spinner.succeed()
-  if (corsAdded.length) {
-    output.success(`CORS origins added (${corsAdded.map((p) => `localhost:${p}`).join(', ')})`)
-  }
-  if (readToken) output.success(`API token generated (${READ_TOKEN_LABEL})`)
-  if (writeToken) output.success(`API token generated (${WRITE_TOKEN_LABEL})`)
-}

package/src/actions/init-project/createAppCliConfig.ts

@@ -1,24 +0,0 @@
-import {processTemplate} from './processTemplate'
-
-const defaultAppTemplate = `
-import {defineCliConfig} from 'sanity/cli'
-
-export default defineCliConfig({
-  app: {
-    organizationId: '%organizationId%',
-    entry: '%entry%',
-  },
-})
-`
-
-export interface GenerateCliConfigOptions {
-  organizationId?: string
-  entry: string
-}
-
-export function createAppCliConfig(options: GenerateCliConfigOptions): string {
-  return processTemplate({
-    template: defaultAppTemplate,
-    variables: options,
-  })
-}

package/src/actions/init-project/createCliConfig.ts

@@ -1,31 +0,0 @@
-import {processTemplate} from './processTemplate'
-
-const defaultTemplate = `
-import {defineCliConfig} from 'sanity/cli'
-
-export default defineCliConfig({
-  api: {
-    projectId: '%projectId%',
-    dataset: '%dataset%'
-  },
-  /**
-   * Enable auto-updates for studios.
-   * Learn more at https://www.sanity.io/docs/cli#auto-updates
-   */
-  autoUpdates: __BOOL__autoUpdates__,
-})
-`
-
-export interface GenerateCliConfigOptions {
-  projectId: string
-  dataset: string
-  autoUpdates: boolean
-}
-
-export function createCliConfig(options: GenerateCliConfigOptions): string {
-  return processTemplate({
-    template: defaultTemplate,
-    variables: options,
-    includeBooleanTransform: true,
-  })
-}

package/src/actions/init-project/createPackageManifest.ts

@@ -1,102 +0,0 @@
-import sortObject from 'deep-sort-object'
-
-import {type PackageJson, type SanityJson} from '../../types'
-
-const manifestPropOrder = [
-  'name',
-  'private',
-  'version',
-  'description',
-  'main',
-  'author',
-  'license',
-  'scripts',
-  'keywords',
-  'dependencies',
-  'devDependencies',
-]
-
-export function createPackageManifest(
-  data: Omit<PackageJson, 'version'> & {gitRemote?: string} & {isAppTemplate?: boolean},
-): string {
-  const {isAppTemplate} = data
-
-  const dependencies = data.dependencies ? {dependencies: sortObject(data.dependencies)} : {}
-
-  const devDependencies = data.devDependencies
-    ? {devDependencies: sortObject(data.devDependencies)}
-    : {}
-
-  // Don't write a prettier config for SDK apps; we want to allow developers to use their own
-  const prettierConfig = isAppTemplate
-    ? {}
-    : {
-        prettier: {
-          semi: false,
-          printWidth: 100,
-          bracketSpacing: false,
-          singleQuote: true,
-        },
-      }
-
-  const pkg = {
-    ...getCommonManifest(data),
-
-    main: 'package.json',
-    keywords: ['sanity'],
-    scripts: data.scripts || {
-      'dev': 'sanity dev',
-      'start': 'sanity start',
-      'build': 'sanity build',
-      'deploy': 'sanity deploy',
-      'deploy-graphql': 'sanity graphql deploy',
-    },
-
-    ...dependencies,
-    ...devDependencies,
-    ...prettierConfig,
-  }
-
-  return serializeManifest(pkg)
-}
-
-function getCommonManifest(data: Omit<PackageJson, 'version'> & {gitRemote?: string}) {
-  const pkg: PackageJson = {
-    name: data.name,
-    version: '1.0.0',
-    description: data.description,
-    author: data.author,
-    license: data.license || 'UNLICENSED',
-    devDependencies: {},
-  }
-
-  if (pkg.license === 'UNLICENSED') {
-    pkg.private = true
-  }
-
-  if (data.gitRemote) {
-    pkg.repository = {
-      type: 'git',
-      url: data.gitRemote,
-    }
-  }
-
-  return pkg
-}
-
-function serializeManifest(src: PackageJson | SanityJson): string {
-  const props = manifestPropOrder.concat(Object.keys(src))
-  const ordered = props.reduce(
-    (target, prop) => {
-      const source = src as any
-      if (typeof source[prop] !== 'undefined' && typeof target[prop] === 'undefined') {
-        target[prop] = source[prop]
-      }
-
-      return target
-    },
-    {} as Record<string, any>,
-  )
-
-  return `${JSON.stringify(ordered, null, 2)}\n`
-}