@sanity/cli 3.59.2-canary.33 → 3.59.2-corel-presentation-lcapi.562

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

@@ -1,16 +1,16 @@
-import {existsSync, readFileSync} from 'node:fs'
+import {existsSync} from 'node:fs'
 import fs from 'node:fs/promises'
 import path from 'node:path'
 
 import {type DatasetAclMode, type SanityProject} from '@sanity/client'
 import {type Framework} from '@vercel/frameworks'
+import {type detectFrameworkRecord} from '@vercel/fs-detectors'
 import dotenv from 'dotenv'
 import execa, {type CommonOptions} from 'execa'
 import {deburr, noop} from 'lodash'
 import pFilter from 'p-filter'
 import resolveFrom from 'resolve-from'
-import {evaluate, patch} from 'silver-fleece'
-import which from 'which'
+import semver from 'semver'
 
 import {CLIInitStepCompleted} from '../../__telemetry__/init.telemetry'
 import {type InitFlags} from '../../commands/init/initCommand'
@@ -33,17 +33,21 @@ import {
   type CliCommandDefinition,
   type SanityCore,
   type SanityModuleInternal,
+  type SanityUser,
 } from '../../types'
 import {getClientWrapper} from '../../util/clientWrapper'
 import {dynamicRequire} from '../../util/dynamicRequire'
 import {getProjectDefaults, type ProjectDefaults} from '../../util/getProjectDefaults'
+import {getProviderName} from '../../util/getProviderName'
 import {getUserConfig} from '../../util/getUserConfig'
 import {isCommandGroup} from '../../util/isCommandGroup'
 import {isInteractive} from '../../util/isInteractive'
 import {fetchJourneyConfig} from '../../util/journeyConfig'
+import {checkIsRemoteTemplate, getGitHubRepoInfo, type RepoInfo} from '../../util/remoteTemplate'
 import {login, type LoginFlags} from '../login/login'
 import {createProject} from '../project/createProject'
-import {type BootstrapOptions, bootstrapTemplate} from './bootstrapTemplate'
+import {bootstrapLocalTemplate} from './bootstrapLocalTemplate'
+import {bootstrapRemoteTemplate} from './bootstrapRemoteTemplate'
 import {type GenerateConfigOptions} from './createStudioConfig'
 import {absolutify, validateEmptyPath} from './fsUtils'
 import {tryGitInit} from './git'
@@ -55,7 +59,7 @@ import {
   promptForNextTemplate,
   promptForStudioPath,
 } from './prompts/nextjs'
-import {reconfigureV2Project} from './reconfigureV2Project'
+import {readPackageJson} from './readPackageJson'
 import templates from './templates'
 import {
   sanityCliTemplate,
@@ -65,19 +69,13 @@ import {
 } from './templates/nextjs'
 
 // eslint-disable-next-line no-process-env
-const isCI = process.env.CI
+const isCI = Boolean(process.env.CI)
 
 /**
  * @deprecated - No longer used
  */
 export interface InitOptions {
   template: string
-  // /**
-  //  * Used for initializing a project from a server schema that is saved in the Journey API
-  //  * This will override the `template` option.
-  //  * @beta
-  //  */
-  // journeyProjectId?: string
   outputDir: string
   name: string
   displayName: string
@@ -110,24 +108,20 @@ export interface ProjectOrganization {
 // eslint-disable-next-line max-statements, complexity
 export default async function initSanity(
   args: CliCommandArguments<InitFlags>,
-  context: CliCommandContext & {detectedFramework: Framework | null},
+  context: CliCommandContext & {
+    detectedFramework: Awaited<ReturnType<typeof detectFrameworkRecord>>
+  },
 ): Promise<void> {
-  const {
-    output,
-    prompt,
-    workDir,
-    apiClient,
-    chalk,
-    sanityMajorVersion,
-    telemetry,
-    detectedFramework,
-  } = context
+  const {output, prompt, workDir, apiClient, chalk, telemetry, detectedFramework} = context
 
   const trace = telemetry.trace(CLIInitStepCompleted)
 
   const cliFlags = args.extOptions
   const unattended = cliFlags.y || cliFlags.yes
   const print = unattended ? noop : output.print
+  const success = output.success
+  const warn = output.warn
+
   const intendedPlan = cliFlags['project-plan']
   const intendedCoupon = cliFlags.coupon
   const reconfigure = cliFlags.reconfigure
@@ -137,6 +131,11 @@ export default async function initSanity(
   const env = cliFlags.env
   const packageManager = cliFlags['package-manager']
 
+  let remoteTemplateInfo: RepoInfo | undefined
+  if (cliFlags.template && checkIsRemoteTemplate(cliFlags.template)) {
+    remoteTemplateInfo = await getGitHubRepoInfo(cliFlags.template, cliFlags['template-token'])
+  }
+
   let defaultConfig = cliFlags['dataset-default']
   let showDefaultConfigPrompt = !defaultConfig
 
@@ -155,9 +154,10 @@ export default async function initSanity(
     },
   })
 
-  if (sanityMajorVersion === 2) {
-    await reconfigureV2Project(args, context)
-    return
+  if (detectedFramework && detectedFramework.slug !== 'sanity' && remoteTemplateInfo) {
+    throw new Error(
+      `A remote template cannot be used with a detected framework. Detected: ${detectedFramework.name}`,
+    )
   }
 
   // Only allow either --project-plan or --coupon
@@ -246,24 +246,8 @@ export default async function initSanity(
   }
   const envFilename = typeof env === 'string' ? env : envFilenameDefault
   if (!envFilename.startsWith('.env')) {
-    throw new Error(`Env filename must start with .env`)
-  }
-
-  const usingBareOrEnv = cliFlags.bare || cliFlags.env
-  print(
-    cliFlags.quickstart
-      ? "You're ejecting a remote Sanity project!"
-      : `You're setting up a new project!`,
-  )
-  print(`We'll make sure you have an account with Sanity.io. ${usingBareOrEnv ? '' : `Then we'll`}`)
-  if (!usingBareOrEnv) {
-    print('install an open-source JS content editor that connects to')
-    print('the real-time hosted API on Sanity.io. Hang on.\n')
+    throw new Error('Env filename must start with .env')
   }
-  print('Press ctrl + C at any time to quit.\n')
-  print('Prefer web interfaces to terminals?')
-  print('You can also set up best practice Sanity projects with')
-  print('your favorite frontends on https://www.sanity.io/templates\n')
 
   // If the user isn't already authenticated, make it so
   const userConfig = getUserConfig()
@@ -272,12 +256,20 @@ export default async function initSanity(
   debug(hasToken ? 'User already has a token' : 'User has no token')
   if (hasToken) {
     trace.log({step: 'login', alreadyLoggedIn: true})
-    print('Looks like you already have a Sanity-account. Sweet!\n')
+    const user = await getUserData(apiClient)
+    success('You are logged in as %s using %s', user.email, getProviderName(user.provider))
   } else if (!unattended) {
     trace.log({step: 'login'})
     await getOrCreateUser()
   }
 
+  let introMessage = 'Fetching existing projects'
+  if (cliFlags.quickstart) {
+    introMessage = "Eject your existing project's Sanity configuration"
+  }
+  success(introMessage)
+  print('')
+
   const flags = await prepareFlags()
   // We're authenticated, now lets select or create a project
   const {projectId, displayName, isFirstProject, datasetName, schemaUrl} = await getProjectDetails()
@@ -288,7 +280,8 @@ export default async function initSanity(
 
   // If user doesn't want to output any template code
   if (bareOutput) {
-    print(`\n${chalk.green('Success!')} Below are your project details:\n`)
+    success('Below are your project details')
+    print('')
     print(`Project ID: ${chalk.cyan(projectId)}`)
     print(`Dataset: ${chalk.cyan(datasetName)}`)
     print(
@@ -298,7 +291,8 @@ export default async function initSanity(
   }
 
   let initNext = false
-  if (detectedFramework?.slug === 'nextjs') {
+  const isNextJs = detectedFramework?.slug === 'nextjs'
+  if (isNextJs) {
     initNext = await prompt.single({
       type: 'confirm',
       message:
@@ -327,6 +321,26 @@ export default async function initSanity(
   // Ensure we are using the output path provided by user
   outputPath = answers.outputPath
 
+  if (isNextJs) {
+    const packageJson = readPackageJson(`${outputPath}/package.json`)
+    const reactVersion = packageJson?.dependencies?.react
+
+    if (reactVersion) {
+      const isUsingReact19 = semver.coerce(reactVersion)?.major === 19
+      const isUsingNextJs15 = semver.coerce(detectedFramework?.detectedVersion)?.major === 15
+
+      if (isUsingNextJs15 && isUsingReact19) {
+        warn('╭────────────────────────────────────────────────────────────╮')
+        warn('│                                                            │')
+        warn('│ It looks like you are using Next.js 15 and React 19        │')
+        warn('│ Please read our compatibility guide.                       │')
+        warn('│ https://www.sanity.io/help/react-19                        │')
+        warn('│                                                            │')
+        warn('╰────────────────────────────────────────────────────────────╯')
+      }
+    }
+  }
+
   if (initNext) {
     const useTypeScript = unattended ? true : await promptForTypeScript(prompt)
     trace.log({step: 'useTypeScript', selectedOption: useTypeScript ? 'yes' : 'no'})
@@ -419,21 +433,6 @@ export default async function initSanity(
 
     await writeSourceFiles(sanityFolder(useTypeScript, templateToUse), undefined, hasSrcFolder)
 
-    // set tsconfig.json target to ES2017
-    const tsConfigPath = path.join(workDir, 'tsconfig.json')
-
-    if (useTypeScript && existsSync(tsConfigPath)) {
-      const tsConfigFile = readFileSync(tsConfigPath, 'utf8')
-      const config = evaluate(tsConfigFile)
-
-      if (config.compilerOptions.target?.toLowerCase() !== 'es2017') {
-        config.compilerOptions.target = 'ES2017'
-
-        const newConfig = patch(tsConfigFile, config)
-        await fs.writeFile(tsConfigPath, Buffer.from(newConfig))
-      }
-    }
-
     const appendEnv = unattended ? true : await promptForAppendEnv(prompt, envFilename)
 
     if (appendEnv) {
@@ -496,7 +495,7 @@ export default async function initSanity(
     }
 
     if (chosen === 'npm') {
-      await execa('npm', ['install', 'next-sanity@9'], execOptions)
+      await execa('npm', ['install', '--legacy-peer-deps', 'next-sanity@9'], execOptions)
     } else if (chosen === 'yarn') {
       await execa('npx', ['install-peerdeps', '--yarn', 'next-sanity@9'], execOptions)
     } else if (chosen === 'pnpm') {
@@ -553,18 +552,20 @@ export default async function initSanity(
   const templateName = await selectProjectTemplate()
   trace.log({step: 'selectProjectTemplate', selectedOption: templateName})
   const template = templates[templateName]
-  if (!template) {
+  if (!remoteTemplateInfo && !template) {
     throw new Error(`Template "${templateName}" not found`)
   }
 
   // Use typescript?
-  const typescriptOnly = template.typescriptOnly === true
   let useTypeScript = true
-  if (!typescriptOnly && typeof cliFlags.typescript === 'boolean') {
-    useTypeScript = cliFlags.typescript
-  } else if (!typescriptOnly && !unattended) {
-    useTypeScript = await promptForTypeScript(prompt)
-    trace.log({step: 'useTypeScript', selectedOption: useTypeScript ? 'yes' : 'no'})
+  if (!remoteTemplateInfo && template) {
+    const typescriptOnly = template.typescriptOnly === true
+    if (!typescriptOnly && typeof cliFlags.typescript === 'boolean') {
+      useTypeScript = cliFlags.typescript
+    } else if (!typescriptOnly && !unattended) {
+      useTypeScript = await promptForTypeScript(prompt)
+      trace.log({step: 'useTypeScript', selectedOption: useTypeScript ? 'yes' : 'no'})
+    }
   }
 
   // we enable auto-updates by default, but allow users to specify otherwise
@@ -573,47 +574,15 @@ export default async function initSanity(
     autoUpdates = cliFlags['auto-updates']
   }
 
-  // Build a full set of resolved options
-  const templateOptions: BootstrapOptions = {
-    outputPath,
-    packageName: sluggedName,
-    templateName,
-    schemaUrl,
-    useTypeScript,
-    variables: {
-      autoUpdates,
-      dataset: datasetName,
-      projectId,
-      projectName: displayName || answers.projectName,
-    },
-  }
-
   // If the template has a sample dataset, prompt the user whether or not we should import it
   const shouldImport =
-    !unattended && template.datasetUrl && (await promptForDatasetImport(template.importPrompt))
+    !unattended && template?.datasetUrl && (await promptForDatasetImport(template.importPrompt))
 
   trace.log({step: 'importTemplateDataset', selectedOption: shouldImport ? 'yes' : 'no'})
 
   const [_, bootstrapPromise] = await Promise.allSettled([
-    // record template files attempted to be created locally
-    apiClient({api: {projectId: projectId}})
-      .request<SanityProject>({uri: `/projects/${projectId}`})
-      .then((project: SanityProject) => {
-        if (!project?.metadata?.cliInitializedAt) {
-          return apiClient({api: {projectId}}).request({
-            method: 'PATCH',
-            uri: `/projects/${projectId}`,
-            body: {metadata: {cliInitializedAt: new Date().toISOString()}},
-          })
-        }
-        return Promise.resolve()
-      })
-      .catch(() => {
-        // Non-critical update
-        debug('Failed to update cliInitializedAt metadata')
-      }),
-    // Bootstrap Sanity, creating required project files, manifests etc
-    bootstrapTemplate(templateOptions, context),
+    updateProjectCliInitializedMetadata(),
+    bootstrapTemplate(),
   ])
 
   if (bootstrapPromise.status === 'rejected' && bootstrapPromise.reason instanceof Error) {
@@ -667,13 +636,11 @@ export default async function initSanity(
       context,
     })
 
-    if (await hasGlobalCli()) {
-      print('')
-      print('If you want to delete the imported data, use')
-      print(`  ${chalk.cyan(`sanity dataset delete ${datasetName}`)}`)
-      print('and create a new clean dataset with')
-      print(`  ${chalk.cyan(`sanity dataset create <name>`)}\n`)
-    }
+    print('')
+    print('If you want to delete the imported data, use')
+    print(`  ${chalk.cyan(`npx sanity dataset delete ${datasetName}`)}`)
+    print('and create a new clean dataset with')
+    print(`  ${chalk.cyan(`npx sanity dataset create <name>`)}\n`)
   }
 
   const devCommandMap: Record<PackageManager, string> = {
@@ -695,12 +662,10 @@ export default async function initSanity(
     print(`Then: ${chalk.cyan(devCommand)} - to run Sanity Studio\n`)
   }
 
-  if (await hasGlobalCli()) {
-    print(`Other helpful commands`)
-    print(`sanity docs - to open the documentation in a browser`)
-    print(`sanity manage - to open the project settings in a browser`)
-    print(`sanity help - to explore the CLI manual`)
-  }
+  print(`Other helpful commands`)
+  print(`npx sanity docs - to open the documentation in a browser`)
+  print(`npx sanity manage - to open the project settings in a browser`)
+  print(`npx sanity help - to explore the CLI manual`)
 
   const sendInvite =
     isFirstProject &&
@@ -725,16 +690,13 @@ export default async function initSanity(
   trace.complete()
 
   async function getOrCreateUser() {
-    print(`We can't find any auth credentials in your Sanity config`)
-    print('- log in or create a new account\n')
+    warn('No authentication credentials found in your Sanity config')
+    print('')
 
     // Provide login options (`sanity login`)
     const {extOptions, ...otherArgs} = args
     const loginArgs: CliCommandArguments<LoginFlags> = {...otherArgs, extOptions: {}}
     await login(loginArgs, {...context, telemetry: trace.newContext('login')})
-
-    print("Good stuff, you're now authenticated. You'll need a project to keep your")
-    print('datasets and collaborators safe and snug.')
   }
 
   async function getProjectDetails(): Promise<{
@@ -795,21 +757,19 @@ export default async function initSanity(
     isFirstProject: boolean
     userAction: 'create' | 'select'
   }> {
-    const spinner = context.output.spinner('Fetching existing projects').start()
+    const client = apiClient({requireUser: true, requireProject: false})
     let projects
     let organizations: ProjectOrganization[]
+
     try {
-      const client = apiClient({requireUser: true, requireProject: false})
       const [allProjects, allOrgs] = await Promise.all([
         client.projects.list({includeMembers: false}),
         client.request({uri: '/organizations'}),
       ])
       projects = allProjects.sort((a, b) => b.createdAt.localeCompare(a.createdAt))
       organizations = allOrgs
-      spinner.succeed()
     } catch (err) {
       if (unattended && flags.project) {
-        spinner.succeed()
         return {
           projectId: flags.project,
           displayName: 'Unknown project',
@@ -817,7 +777,6 @@ export default async function initSanity(
           userAction: 'select',
         }
       }
-      spinner.fail()
       throw new Error(`Failed to communicate with the Sanity API:\n${err.message}`)
     }
 
@@ -887,11 +846,11 @@ export default async function initSanity(
 
     const projectChoices = projects.map((project) => ({
       value: project.id,
-      name: `${project.displayName} [${project.id}]`,
+      name: `${project.displayName} (${project.id})`,
     }))
 
     const selected = await prompt.single({
-      message: 'Select project to use',
+      message: 'Create a new project or select an existing one',
       type: 'list',
       choices: [
         {value: 'new', name: 'Create new project'},
@@ -1070,25 +1029,77 @@ export default async function initSanity(
       type: 'list',
       choices: [
         {
-          value: 'moviedb',
-          name: 'Movie project (schema + sample data)',
-        },
-        {
-          value: 'shopify',
-          name: 'E-commerce (Shopify)',
+          value: 'clean',
+          name: 'Clean project with no predefined schema types',
         },
         {
           value: 'blog',
           name: 'Blog (schema)',
         },
         {
-          value: 'clean',
-          name: 'Clean project with no predefined schema types',
+          value: 'shopify',
+          name: 'E-commerce (Shopify)',
+        },
+        {
+          value: 'moviedb',
+          name: 'Movie project (schema + sample data)',
         },
       ],
     })
   }
 
+  async function updateProjectCliInitializedMetadata() {
+    try {
+      const client = apiClient({api: {projectId}})
+      const project = await client.request<SanityProject>({uri: `/projects/${projectId}`})
+
+      if (!project?.metadata?.cliInitializedAt) {
+        await client.request({
+          method: 'PATCH',
+          uri: `/projects/${projectId}`,
+          body: {metadata: {cliInitializedAt: new Date().toISOString()}},
+        })
+      }
+    } catch (err) {
+      // Non-critical update
+      debug('Failed to update cliInitializedAt metadata')
+    }
+  }
+
+  async function bootstrapTemplate() {
+    const bootstrapVariables: GenerateConfigOptions['variables'] = {
+      autoUpdates,
+      dataset: datasetName,
+      projectId,
+      projectName: displayName || answers.projectName,
+    }
+
+    if (remoteTemplateInfo) {
+      return bootstrapRemoteTemplate(
+        {
+          outputPath,
+          packageName: sluggedName,
+          repoInfo: remoteTemplateInfo,
+          bearerToken: cliFlags['template-token'],
+          variables: bootstrapVariables,
+        },
+        context,
+      )
+    }
+
+    return bootstrapLocalTemplate(
+      {
+        outputPath,
+        packageName: sluggedName,
+        templateName,
+        schemaUrl,
+        useTypeScript,
+        variables: bootstrapVariables,
+      },
+      context,
+    )
+  }
+
   async function getProjectInfo(): Promise<ProjectDefaults & {outputPath: string}> {
     const specifiedPath = flags['output-path'] && path.resolve(flags['output-path'])
 
@@ -1451,6 +1462,16 @@ async function getPlanFromCoupon(apiClient: CliApiClient, couponCode: string): P
   return planId
 }
 
+async function getUserData(apiClient: CliApiClient): Promise<SanityUser> {
+  return await apiClient({
+    requireUser: true,
+    requireProject: false,
+  }).request({
+    method: 'GET',
+    uri: 'users/me',
+  })
+}
+
 async function getPlanFromId(apiClient: CliApiClient, planId: string): Promise<string> {
   const response = await apiClient({
     requireUser: false,
@@ -1509,12 +1530,3 @@ function getImportCommand(
       !isCommandGroup(cmd) && cmd.name === 'import' && cmd.group === 'dataset',
   )
 }
-
-async function hasGlobalCli(): Promise<boolean> {
-  try {
-    const globalCliPath = await which('sanity')
-    return Boolean(globalCliPath)
-  } catch (err) {
-    return false
-  }
-}

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

@@ -0,0 +1,18 @@
+import fs from 'node:fs'
+
+import {type PackageJson} from '../../types'
+
+/**
+ * Read the `package.json` file at the given path
+ *
+ * @param filePath - Path to package.json to read
+ * @returns The parsed package.json
+ */
+export function readPackageJson(filePath: string): PackageJson | undefined {
+  try {
+    // eslint-disable-next-line no-sync
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'))
+  } catch (err) {
+    return undefined
+  }
+}

package/src/actions/init-project/templates/nextjs/index.ts

@@ -165,6 +165,21 @@ export const client = createClient({
 })
 `
 
+const live = `// Querying with "sanityFetch" will keep content automatically updated
+// Before using it, import and render "<SanityLive />" in your layout, see
+// https://github.com/sanity-io/next-sanity#live-content-api for more information.
+import { defineLive } from "next-sanity";
+import { client } from './client'
+
+export const { sanityFetch, SanityLive } = defineLive({ 
+  client: client.withConfig({ 
+    // Live content is currently only available on the experimental API
+    // https://www.sanity.io/docs/api-versioning
+    apiVersion: 'vX' 
+  }) 
+});
+`
+
 const imageTS = `import createImageUrlBuilder from '@sanity/image-url'
 import { SanityImageSource } from "@sanity/image-url/lib/types/types";
 
@@ -201,6 +216,7 @@ export const sanityFolder = (
     'env.': useTypeScript ? envTS : envJS,
     'lib': {
       'client.': client,
+      'live.': live,
       'image.': useTypeScript ? imageTS : imageJS,
     },
   }

package/src/actions/init-project/templates/nextjs/schemaTypes/blog.ts

@@ -186,11 +186,11 @@ export const postType = defineType({
         hotspot: true,
       },
       fields: [
-        {
+        defineField({
           name: 'alt',
           type: 'string',
           title: 'Alternative text',
-        }
+        })
       ]
     }),
     defineField({

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

@@ -0,0 +1,24 @@
+import {debug} from '../../debug'
+import {type CliApiClient} from '../../types'
+
+export async function updateInitialTemplateMetadata(
+  apiClient: CliApiClient,
+  projectId: string,
+  templateName: string,
+): Promise<void> {
+  try {
+    await apiClient({api: {projectId}}).request({
+      method: 'PATCH',
+      uri: `/projects/${projectId}`,
+      body: {metadata: {initialTemplate: templateName}},
+    })
+  } catch (err: unknown) {
+    // Non-critical that we update this metadata, and user does not need to be aware
+    let message = typeof err === 'string' ? err : '<unknown error>'
+    if (err instanceof Error) {
+      message = err.message
+    }
+
+    debug('Failed to update initial template metadata for project: %s', message)
+  }
+}

package/src/actions/login/login.ts

@@ -2,7 +2,6 @@ import http, {type Server} from 'node:http'
 import os from 'node:os'
 
 import {type SanityClient} from '@sanity/client'
-import chalk from 'chalk'
 import open from 'open'
 
 import {debug as debugIt} from '../../debug'
@@ -146,7 +145,7 @@ export async function login(
       })
   }
 
-  output.print(chalk.green('Login successful'))
+  output.success('Login successful')
   trace.complete()
 }
 
@@ -335,7 +334,7 @@ async function promptProviders(
 
   const provider = await prompt.single({
     type: 'list',
-    message: 'Login type',
+    message: 'Please log in or create a new account',
     choices: providers.map((choice) => choice.title),
   })
 

package/src/actions/versions/findSanityModuleVersions.ts

@@ -21,7 +21,6 @@ import {getLocalVersion} from '../../util/getLocalVersion'
 const PACKAGES_TO_EXCLUDE = [
   '@sanity/block-content-to-html',
   '@sanity/block-content-to-react',
-  '@sanity/block-tools',
   '@sanity/client',
 ]