@sanity/cli 3.74.1 → 3.74.2-canary.89

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

@@ -10,8 +10,10 @@ import {copy} from '../../util/copy'
 import {getAndWriteJourneySchemaWorker} from '../../util/journeyConfig'
 import {resolveLatestVersions} from '../../util/resolveLatestVersions'
 import {createCliConfig} from './createCliConfig'
+import {createCoreAppCliConfig} from './createCoreAppCliConfig'
 import {createPackageManifest} from './createPackageManifest'
 import {createStudioConfig, type GenerateConfigOptions} from './createStudioConfig'
+import {determineCoreAppTemplate} from './determineCoreAppTemplate'
 import {type ProjectTemplate} from './initProject'
 import templates from './templates'
 import {updateInitialTemplateMetadata} from './updateInitialTemplateMetadata'
@@ -36,9 +38,9 @@ export async function bootstrapLocalTemplate(
   const {apiClient, cliRoot, output} = context
   const templatesDir = path.join(cliRoot, 'templates')
   const {outputPath, templateName, useTypeScript, packageName, variables} = opts
-  const {projectId} = variables
   const sourceDir = path.join(templatesDir, templateName)
   const sharedDir = path.join(templatesDir, 'shared')
+  const isCoreAppTemplate = determineCoreAppTemplate(templateName)
 
   // Check that we have a template info file (dependencies, plugins etc)
   const template = templates[templateName]
@@ -81,15 +83,16 @@ export async function bootstrapLocalTemplate(
   // Resolve latest versions of Sanity-dependencies
   spinner = output.spinner('Resolving latest module versions').start()
   const dependencyVersions = await resolveLatestVersions({
-    ...studioDependencies.dependencies,
-    ...studioDependencies.devDependencies,
+    ...(isCoreAppTemplate ? {} : studioDependencies.dependencies),
+    ...(isCoreAppTemplate ? {} : studioDependencies.devDependencies),
     ...(template.dependencies || {}),
+    ...(template.devDependencies || {}),
   })
   spinner.succeed()
 
   // Use the resolved version for the given dependency
   const dependencies = Object.keys({
-    ...studioDependencies.dependencies,
+    ...(isCoreAppTemplate ? {} : studioDependencies.dependencies),
     ...template.dependencies,
   }).reduce(
     (deps, dependency) => {
@@ -100,7 +103,7 @@ export async function bootstrapLocalTemplate(
   )
 
   const devDependencies = Object.keys({
-    ...studioDependencies.devDependencies,
+    ...(isCoreAppTemplate ? {} : studioDependencies.devDependencies),
     ...template.devDependencies,
   }).reduce(
     (deps, dependency) => {
@@ -116,32 +119,41 @@ export async function bootstrapLocalTemplate(
     name: packageName,
     dependencies,
     devDependencies,
+    scripts: template.scripts,
   })
 
   // ...and a studio config (`sanity.config.[ts|js]`)
-  const studioConfig = await createStudioConfig({
+  const studioConfig = createStudioConfig({
     template: template.configTemplate,
     variables,
   })
 
   // ...and a CLI config (`sanity.cli.[ts|js]`)
-  const cliConfig = await createCliConfig({
-    projectId: variables.projectId,
-    dataset: variables.dataset,
-    autoUpdates: variables.autoUpdates,
-  })
+  const cliConfig = isCoreAppTemplate
+    ? createCoreAppCliConfig({appLocation: template.appLocation!})
+    : createCliConfig({
+        projectId: variables.projectId,
+        dataset: variables.dataset,
+        autoUpdates: variables.autoUpdates,
+      })
 
   // Write non-template files to disc
   const codeExt = useTypeScript ? 'ts' : 'js'
-  await Promise.all([
-    writeFileIfNotExists(`sanity.config.${codeExt}`, studioConfig),
-    writeFileIfNotExists(`sanity.cli.${codeExt}`, cliConfig),
-    writeFileIfNotExists('package.json', packageManifest),
-    writeFileIfNotExists(
-      'eslint.config.mjs',
-      `import studio from '@sanity/eslint-config-studio'\n\nexport default [...studio]\n`,
-    ),
-  ])
+  await Promise.all(
+    [
+      ...[
+        isCoreAppTemplate
+          ? Promise.resolve(null)
+          : writeFileIfNotExists(`sanity.config.${codeExt}`, studioConfig),
+      ],
+      writeFileIfNotExists(`sanity.cli.${codeExt}`, cliConfig),
+      writeFileIfNotExists('package.json', packageManifest),
+      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}`)

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

@@ -1,6 +1,4 @@
-import traverse from '@babel/traverse'
-import {parse, print} from 'recast'
-import * as parser from 'recast/parsers/typescript'
+import {processTemplate} from './processTemplate'
 
 const defaultTemplate = `
 import {defineCliConfig} from 'sanity/cli'
@@ -25,49 +23,9 @@ export interface GenerateCliConfigOptions {
 }
 
 export function createCliConfig(options: GenerateCliConfigOptions): string {
-  const variables = options
-  const template = defaultTemplate.trimStart()
-  const ast = parse(template, {parser})
-
-  traverse(ast, {
-    StringLiteral: {
-      enter({node}) {
-        const value = node.value
-        if (!value.startsWith('%') || !value.endsWith('%')) {
-          return
-        }
-        const variableName = value.slice(1, -1) as keyof GenerateCliConfigOptions
-        if (!(variableName in variables)) {
-          throw new Error(`Template variable '${value}' not defined`)
-        }
-        const newValue = variables[variableName]
-        /*
-         * although there are valid non-strings in our config,
-         * they're not in StringLiteral nodes, so assume undefined
-         */
-        node.value = typeof newValue === 'string' ? newValue : ''
-      },
-    },
-    Identifier: {
-      enter(path) {
-        if (!path.node.name.startsWith('__BOOL__')) {
-          return
-        }
-        const variableName = path.node.name.replace(
-          /^__BOOL__(.+?)__$/,
-          '$1',
-        ) as keyof GenerateCliConfigOptions
-        if (!(variableName in variables)) {
-          throw new Error(`Template variable '${variableName}' not defined`)
-        }
-        const value = variables[variableName]
-        if (typeof value !== 'boolean') {
-          throw new Error(`Expected boolean value for '${variableName}'`)
-        }
-        path.replaceWith({type: 'BooleanLiteral', value})
-      },
-    },
+  return processTemplate({
+    template: defaultTemplate,
+    variables: options,
+    includeBooleanTransform: true,
   })
-
-  return print(ast, {quote: 'single'}).code
 }

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

@@ -0,0 +1,23 @@
+import {processTemplate} from './processTemplate'
+
+const defaultCoreAppTemplate = `
+import {defineCliConfig} from 'sanity/cli'
+
+export default defineCliConfig({
+  __experimental_coreAppConfiguration: {
+    appLocation: '%appLocation%'
+  },
+})
+`
+
+export interface GenerateCliConfigOptions {
+  organizationId?: string
+  appLocation: string
+}
+
+export function createCoreAppCliConfig(options: GenerateCliConfigOptions): string {
+  return processTemplate({
+    template: defaultCoreAppTemplate,
+    variables: options,
+  })
+}

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

@@ -29,7 +29,7 @@ export function createPackageManifest(
 
     main: 'package.json',
     keywords: ['sanity'],
-    scripts: {
+    scripts: data.scripts || {
       'dev': 'sanity dev',
       'start': 'sanity start',
       'build': 'sanity build',

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

@@ -1,6 +1,4 @@
-import traverse from '@babel/traverse'
-import {parse, print} from 'recast'
-import * as parser from 'recast/parsers/typescript'
+import {processTemplate} from './processTemplate'
 
 const defaultTemplate = `
 import {defineConfig} from 'sanity'
@@ -47,29 +45,8 @@ export function createStudioConfig(options: GenerateConfigOptions): string {
     return options.template(variables).trimStart()
   }
 
-  const template = (options.template || defaultTemplate).trimStart()
-  const ast = parse(template, {parser})
-  traverse(ast, {
-    StringLiteral: {
-      enter({node}) {
-        const value = node.value
-        if (!value.startsWith('%') || !value.endsWith('%')) {
-          return
-        }
-
-        const variableName = value.slice(1, -1) as keyof GenerateConfigOptions['variables']
-        if (!(variableName in variables)) {
-          throw new Error(`Template variable '${value}' not defined`)
-        }
-        const newValue = variables[variableName]
-        /*
-         * although there are valid non-strings in our config,
-         * they're not in this template, so assume undefined
-         */
-        node.value = typeof newValue === 'string' ? newValue : ''
-      },
-    },
+  return processTemplate({
+    template: options.template || defaultTemplate,
+    variables,
   })
-
-  return print(ast, {quote: 'single'}).code
 }

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

@@ -0,0 +1,13 @@
+const coreAppTemplates = ['core-app']
+
+/**
+ * Determine if a given template is a studio template.
+ * This function may need to be more robust once we
+ * introduce remote templates, for example.
+ *
+ * @param templateName - Name of the template
+ * @returns boolean indicating if the template is a studio template
+ */
+export function determineCoreAppTemplate(templateName: string): boolean {
+  return coreAppTemplates.includes(templateName)
+}

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

@@ -49,6 +49,7 @@ import {createProject} from '../project/createProject'
 import {bootstrapLocalTemplate} from './bootstrapLocalTemplate'
 import {bootstrapRemoteTemplate} from './bootstrapRemoteTemplate'
 import {type GenerateConfigOptions} from './createStudioConfig'
+import {determineCoreAppTemplate} from './determineCoreAppTemplate'
 import {absolutify, validateEmptyPath} from './fsUtils'
 import {tryGitInit} from './git'
 import {promptForDatasetName} from './promptForDatasetName'
@@ -97,6 +98,8 @@ export interface ProjectTemplate {
   importPrompt?: string
   configTemplate?: string | ((variables: GenerateConfigOptions['variables']) => string)
   typescriptOnly?: boolean
+  appLocation?: string
+  scripts?: Record<string, string>
 }
 
 export interface ProjectOrganization {
@@ -263,14 +266,21 @@ export default async function initSanity(
     await getOrCreateUser()
   }
 
+  // skip project / dataset prompting
+  const isCoreAppTemplate = cliFlags.template ? determineCoreAppTemplate(cliFlags.template) : false // Default to false
+
   let introMessage = 'Fetching existing projects'
   if (cliFlags.quickstart) {
     introMessage = "Eject your existing project's Sanity configuration"
   }
-  success(introMessage)
-  print('')
+
+  if (!isCoreAppTemplate) {
+    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()
 
@@ -655,11 +665,15 @@ export default async function initSanity(
   const isCurrentDir = outputPath === process.cwd()
   if (isCurrentDir) {
     print(`\n${chalk.green('Success!')} Now, use this command to continue:\n`)
-    print(`${chalk.cyan(devCommand)} - to run Sanity Studio\n`)
+    print(
+      `${chalk.cyan(devCommand)} - to run ${isCoreAppTemplate ? 'your Sanity application' : 'Sanity Studio'}\n`,
+    )
   } else {
     print(`\n${chalk.green('Success!')} Now, use these commands to continue:\n`)
     print(`First: ${chalk.cyan(`cd ${outputPath}`)} - to enter project’s directory`)
-    print(`Then: ${chalk.cyan(devCommand)} - to run Sanity Studio\n`)
+    print(
+      `Then: ${chalk.cyan(devCommand)} -to run ${isCoreAppTemplate ? 'your Sanity application' : 'Sanity Studio'}\n`,
+    )
   }
 
   print(`Other helpful commands`)
@@ -720,6 +734,15 @@ export default async function initSanity(
       return data
     }
 
+    if (isCoreAppTemplate) {
+      return {
+        projectId: '',
+        displayName: '',
+        isFirstProject: false,
+        datasetName: '',
+      }
+    }
+
     debug('Prompting user to select or create a project')
     const project = await getOrCreateProject()
     debug(`Project with name ${project.displayName} selected`)

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

@@ -0,0 +1,55 @@
+import traverse from '@babel/traverse'
+import {parse, print} from 'recast'
+import * as parser from 'recast/parsers/typescript'
+
+interface TemplateOptions<T> {
+  template: string
+  variables: T
+  includeBooleanTransform?: boolean
+}
+
+export function processTemplate<T extends object>(options: TemplateOptions<T>): string {
+  const {template, variables, includeBooleanTransform = false} = options
+  const ast = parse(template.trimStart(), {parser})
+
+  traverse(ast, {
+    StringLiteral: {
+      enter({node}) {
+        const value = node.value
+        if (!value.startsWith('%') || !value.endsWith('%')) {
+          return
+        }
+        const variableName = value.slice(1, -1) as keyof T
+        if (!(variableName in variables)) {
+          throw new Error(`Template variable '${value}' not defined`)
+        }
+        const newValue = variables[variableName]
+        /*
+         * although there are valid non-strings in our config,
+         * they're not in StringLiteral nodes, so assume undefined
+         */
+        node.value = typeof newValue === 'string' ? newValue : ''
+      },
+    },
+    ...(includeBooleanTransform && {
+      Identifier: {
+        enter(path) {
+          if (!path.node.name.startsWith('__BOOL__')) {
+            return
+          }
+          const variableName = path.node.name.replace(/^__BOOL__(.+?)__$/, '$1') as keyof T
+          if (!(variableName in variables)) {
+            throw new Error(`Template variable '${variableName.toString()}' not defined`)
+          }
+          const value = variables[variableName]
+          if (typeof value !== 'boolean') {
+            throw new Error(`Expected boolean value for '${variableName.toString()}'`)
+          }
+          path.replaceWith({type: 'BooleanLiteral', value})
+        },
+      },
+    }),
+  })
+
+  return print(ast, {quote: 'single'}).code
+}

package/src/actions/init-project/templates/coreApp.ts

@@ -0,0 +1,31 @@
+import {type ProjectTemplate} from '../initProject'
+
+const coreAppTemplate: ProjectTemplate = {
+  dependencies: {
+    '@sanity/sdk': '^0.0.0-alpha',
+    '@sanity/sdk-react': '^0.0.0-alpha',
+    'react': '^19',
+    'react-dom': '^19',
+  },
+  devDependencies: {
+    /*
+     * this will be changed to eslint-config sanity,
+     *  eslint.config generation will be a fast follow
+     */
+    '@sanity/eslint-config-studio': '^5.0.1',
+    '@types/react': '^18.0.25',
+    'eslint': '^9.9.0',
+    'prettier': '^3.0.2',
+    'sanity': '^3',
+    'typescript': '^5.1.6',
+  },
+  appLocation: './src/App.tsx',
+  scripts: {
+    // this will eventually run a concurrently process with another in-flight utility
+    dev: 'sanity app dev',
+    build: 'sanity app build',
+    start: 'sanity app start',
+  },
+}
+
+export default coreAppTemplate

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

@@ -1,6 +1,7 @@
 import {type ProjectTemplate} from '../initProject'
 import blog from './blog'
 import clean from './clean'
+import coreAppTemplate from './coreApp'
 import getStartedTemplate from './getStarted'
 import moviedb from './moviedb'
 import quickstart from './quickstart'
@@ -10,6 +11,7 @@ import shopifyOnline from './shopifyOnline'
 const templates: Record<string, ProjectTemplate | undefined> = {
   blog,
   clean,
+  'core-app': coreAppTemplate,
   'get-started': getStartedTemplate,
   moviedb,
   shopify,

package/src/cli.ts

@@ -47,16 +47,17 @@ export async function runCli(cliRoot: string, {cliVersion}: {cliVersion: string}
 
   const args = parseArguments()
   const isInit = args.groupOrCommand === 'init' && args.argsWithoutOptions[0] !== 'plugin'
+  const isCoreApp = args.groupOrCommand === 'app'
   const cwd = getCurrentWorkingDirectory()
   let workDir: string | undefined
   try {
-    workDir = isInit ? process.cwd() : resolveRootDir(cwd)
+    workDir = isInit ? process.cwd() : resolveRootDir(cwd, isCoreApp)
   } catch (err) {
     console.error(chalk.red(err.message))
     process.exit(1)
   }
 
-  loadAndSetEnvFromDotEnvFiles({workDir, cmd: args.groupOrCommand})
+  loadAndSetEnvFromDotEnvFiles({workDir, cmd: args.groupOrCommand, isCoreApp})
   maybeFixMissingWindowsEnvVar()
 
   // Check if there are updates available for the CLI, and notify if there is
@@ -99,6 +100,7 @@ export async function runCli(cliRoot: string, {cliVersion}: {cliVersion: string}
     corePath: await getCoreModulePath(workDir, cliConfig),
     cliConfig,
     telemetry,
+    isCoreApp,
   }
 
   warnOnNonProductionEnvironment()
@@ -274,14 +276,22 @@ function warnOnNonProductionEnvironment(): void {
   )
 }
 
-function loadAndSetEnvFromDotEnvFiles({workDir, cmd}: {workDir: string; cmd: string}) {
+function loadAndSetEnvFromDotEnvFiles({
+  workDir,
+  cmd,
+  isCoreApp,
+}: {
+  workDir: string
+  cmd: string
+  isCoreApp: boolean
+}) {
   /* eslint-disable no-process-env */
 
   // Do a cheap lookup for a sanity.json file. If there is one, assume it is a v2 project,
   // and apply the old behavior for environment variables. Otherwise, use the Vite-style
   // behavior. We need to do this "cheap" lookup because when loading the v3 config, env vars
   // may be used in the configuration file, meaning we'd have to load the config twice.
-  if (existsSync(path.join(workDir, 'sanity.json'))) {
+  if (existsSync(path.join(workDir, 'sanity.json')) && !isCoreApp) {
     // v2
     debug('sanity.json exists, assuming v2 project and loading .env files using old behavior')
     const env = process.env.SANITY_ACTIVE_ENV || process.env.NODE_ENV || 'development'
@@ -309,7 +319,7 @@ function loadAndSetEnvFromDotEnvFiles({workDir, cmd}: {workDir: string; cmd: str
 
   debug('Loading environment files using %s mode', mode)
 
-  const studioEnv = loadEnv(mode, workDir, ['SANITY_STUDIO_'])
+  const studioEnv = loadEnv(mode, workDir, isCoreApp ? ['VITE_'] : ['SANITY_STUDIO_'])
   process.env = {...process.env, ...studioEnv}
   /* eslint-disable no-process-env */
 }

package/src/types.ts

@@ -24,6 +24,7 @@ export interface SanityModuleInternal {
 export interface PackageJson {
   name: string
   version: string
+  scripts?: Record<string, string>
 
   description?: string
   author?: string
@@ -146,6 +147,7 @@ export interface CommandRunnerOptions {
   workDir: string
   corePath: string | undefined
   telemetry: TelemetryLogger<TelemetryUserProperties>
+  isCoreApp: boolean
 }
 
 export interface CliOutputter {
@@ -182,6 +184,7 @@ export type CliStubbedYarn = (args: string[], options?: CliYarnOptions) => Promi
 export interface CliApiConfig {
   projectId?: string
   dataset?: string
+  organizationId?: string
 }
 
 export interface SanityJson {
@@ -344,6 +347,16 @@ export interface CliConfig {
   autoUpdates?: boolean
 
   studioHost?: string
+
+  /**
+   * Parameter used to configure other kinds of applications.
+   * Signals to `sanity` commands that this is not a studio.
+   * @internal
+   */
+  __experimental_coreAppConfiguration?: {
+    appLocation?: string
+    appHost?: string
+  }
 }
 
 export type UserViteConfig =

package/src/util/resolveRootDir.ts

@@ -7,26 +7,27 @@ import {debug} from '../debug'
 /**
  * Resolve project root directory, falling back to cwd if it cannot be found
  */
-export function resolveRootDir(cwd: string): string {
+export function resolveRootDir(cwd: string, isCoreApp = false): string {
   try {
-    return resolveProjectRoot(cwd) || cwd
+    return resolveProjectRoot(cwd, 0, isCoreApp) || cwd
   } catch (err) {
     throw new Error(`Error occurred trying to resolve project root:\n${err.message}`)
   }
 }
 
-function hasStudioConfig(basePath: string): boolean {
+function hasSanityConfig(basePath: string, configName: string): boolean {
   const buildConfigs = [
-    fileExists(path.join(basePath, 'sanity.config.js')),
-    fileExists(path.join(basePath, 'sanity.config.ts')),
+    fileExists(path.join(basePath, `${configName}.js`)),
+    fileExists(path.join(basePath, `${configName}.ts`)),
     isSanityV2StudioRoot(basePath),
   ]
 
   return buildConfigs.some(Boolean)
 }
 
-function resolveProjectRoot(basePath: string, iterations = 0): string | false {
-  if (hasStudioConfig(basePath)) {
+function resolveProjectRoot(basePath: string, iterations = 0, isCoreApp = false): string | false {
+  const configName = isCoreApp ? 'sanity.cli' : 'sanity.config'
+  if (hasSanityConfig(basePath, configName)) {
     return basePath
   }
 
@@ -36,7 +37,7 @@ function resolveProjectRoot(basePath: string, iterations = 0): string | false {
     return false
   }
 
-  return resolveProjectRoot(parentDir, iterations + 1)
+  return resolveProjectRoot(parentDir, iterations + 1, isCoreApp)
 }
 
 function isSanityV2StudioRoot(basePath: string): boolean {

package/templates/core-app/src/App.tsx

@@ -0,0 +1,26 @@
+import {createSanityInstance} from '@sanity/sdk'
+import {SanityProvider} from '@sanity/sdk-react/context'
+
+export function App() {
+
+  const sanityConfig = {
+    auth: {
+      authScope: 'global'
+    }
+    /* 
+     * Apps can access several different projects!
+     * Add the below configuration if you want to connect to a specific project.
+     */
+    // projectId: 'my-project-id',
+    // dataset: 'my-dataset',
+  }
+
+  const sanityInstance = createSanityInstance(sanityConfig)
+  return (
+    <SanityProvider sanityInstance={sanityInstance}>
+      Hello world!
+    </SanityProvider>
+  )
+}
+
+export default App