@sanity/cli 3.88.0 → 3.88.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/cli",
-  "version": "3.88.0",
+  "version": "3.88.1",
   "description": "Sanity CLI tool for managing Sanity installations, managing plugins, schemas and datasets",
   "keywords": [
     "sanity",
@@ -59,11 +59,11 @@
   "dependencies": {
     "@babel/traverse": "^7.23.5",
     "@sanity/client": "^7.1.0",
-    "@sanity/codegen": "3.88.0",
-    "@sanity/runtime-cli": "^3.0.0",
+    "@sanity/codegen": "3.88.1",
+    "@sanity/runtime-cli": "^6.1.1",
     "@sanity/telemetry": "^0.8.0",
     "@sanity/template-validator": "^2.4.3",
-    "@sanity/util": "3.88.0",
+    "@sanity/util": "3.88.1",
     "chalk": "^4.1.2",
     "debug": "^4.3.4",
     "decompress": "^4.2.0",
@@ -77,13 +77,13 @@
     "validate-npm-package-name": "^3.0.0"
   },
   "devDependencies": {
-    "@repo/package.config": "3.88.0",
-    "@repo/test-config": "3.88.0",
+    "@repo/package.config": "3.88.1",
+    "@repo/test-config": "3.88.1",
     "@rexxars/gitconfiglocal": "^3.0.1",
     "@rollup/plugin-node-resolve": "^15.2.3",
     "@sanity/eslint-config-studio": "^4.0.0",
     "@sanity/generate-help-url": "^3.0.0",
-    "@sanity/types": "3.88.0",
+    "@sanity/types": "3.88.1",
     "@types/babel__traverse": "^7.20.5",
     "@types/configstore": "^5.0.1",
     "@types/cpx": "^1.5.2",
@@ -135,5 +135,5 @@
   "engines": {
     "node": ">=18"
   },
-  "gitHead": "0e6a13c8ff235c14612a8a0f6cf0cd227a96c275"
+  "gitHead": "26a4552965274b9d35f92b9d1191eb029cb913e8"
 }

package/src/commands/blueprints/addBlueprintsCommand.ts

@@ -2,79 +2,75 @@ import {type CliCommandDefinition} from '../../types'
 
 const helpText = `
 Arguments
-  [type]  Type of Resource to add (currently only 'function' is supported)
+  <type>  Type of Resource to add (currently only 'function' is supported)
 
-Examples
-  # Add a Function Resource
+Options
+  --name <name>                Name of the Resource
+  --fn-type <type>             Type of Function Resource to add (e.g. document-publish)
+  --fn-lang, --lang <ts|js>    Language of the Function Resource
+  --js, --javascript           Use JavaScript for the Function Resource
+
+Examples:
+  # Add a Function Resource (TypeScript by default)
   sanity blueprints add function
+
+  # Add a Function Resource with a specific name
+  sanity blueprints add function --name my-function
+
+  # Add a Function Resource with a specific type
+  sanity blueprints add function --name my-function --fn-type document-publish
+
+  # Add a Function Resource in JavaScript
+  sanity blueprints add function --name my-function --fn-type document-publish --js
 `
 
-const addBlueprintsCommand: CliCommandDefinition = {
+export interface BlueprintsAddFlags {
+  'name'?: string
+  'fn-type'?: string
+  'fn-lang'?: string
+  'language'?: string
+  'lang'?: string
+  'js'?: boolean
+  'javascript'?: boolean
+}
+
+const defaultFlags: BlueprintsAddFlags = {
+  //
+}
+
+const addBlueprintsCommand: CliCommandDefinition<BlueprintsAddFlags> = {
   name: 'add',
   group: 'blueprints',
   helpText,
-  signature: '<type>',
+  signature:
+    '<type> [--name <name>] [--fn-type <document-publish>] [--fn-lang <ts|js>] [--javascript]',
   description: 'Add a Resource to a Blueprint',
-  hideFromHelp: true,
+
   async action(args, context) {
-    const {output, prompt} = context
-    const {print} = output
+    const {output} = context
+    const flags = {...defaultFlags, ...args.extOptions}
 
     const [resourceType] = args.argsWithoutOptions
 
     if (!resourceType) {
-      print('Resource type is required. Available types: function')
-      return
-    }
-
-    const {blueprint: blueprintAction, resources: resourcesAction} = await import(
-      '@sanity/runtime-cli/actions/blueprints'
-    )
-
-    const existingBlueprint = blueprintAction.findBlueprintFile()
-    if (!existingBlueprint) {
-      print('No blueprint file found. Run `sanity blueprints init` first.')
+      output.error('Resource type is required. Available types: function')
       return
     }
 
-    if (resourceType === 'function') {
-      const functionName = await prompt.single({
-        type: 'input',
-        message: 'Enter function name:',
-        validate: (input: string) => input.length > 0 || 'Function name is required',
-      })
-
-      const functionType = await prompt.single({
-        type: 'list',
-        message: 'Choose function type:',
-        choices: [
-          {value: 'document-publish', name: 'Document Publish'},
-          {value: 'document-create', name: 'Document Create (Available soon)', disabled: true},
-          {value: 'document-delete', name: 'Document Delete (Available soon)', disabled: true},
-        ],
-      })
-
-      const {filePath, resourceAdded, resource} = resourcesAction.createFunctionResource({
-        name: functionName,
-        type: functionType,
-        displayName: functionName,
-      })
-
-      print(`\nCreated function: ${filePath}`)
-
-      if (resourceAdded) {
-        // added to blueprint.json
-        print('Function Resource added to Blueprint')
-      } else {
-        // print the resource JSON for manual addition
-        print('\nAdd this Function Resource to your Blueprint:')
-        print(JSON.stringify(resource, null, 2))
-      }
-
-      return
-    }
+    const {blueprintAddCore} = await import('@sanity/runtime-cli/cores/blueprints')
+    const {success, error} = await blueprintAddCore({
+      bin: 'sanity',
+      log: (msg) => output.print(msg),
+      args: {type: resourceType},
+      flags: {
+        'name': flags.name,
+        'fn-type': flags['fn-type'],
+        'language': flags['fn-lang'] ?? flags.language ?? flags.lang,
+        'javascript': flags.js || flags.javascript,
+      },
+    })
 
-    print(`Unsupported resource type: ${resourceType}. Available types: function`)
+    if (!success) throw new Error(error)
   },
 }
 

package/src/commands/blueprints/blueprintsGroup.ts

@@ -5,7 +5,6 @@ const blueprintsGroup: CliCommandGroupDefinition = {
   signature: '[COMMAND]',
   isGroupRoot: true,
   description: 'Deploy and manage Sanity Blueprints and Stacks (IaC)',
-  hideFromHelp: true,
 }
 
 export default blueprintsGroup

package/src/commands/blueprints/configBlueprintsCommand.ts

@@ -2,30 +2,51 @@ import {type CliCommandDefinition} from '../../types'
 
 const helpText = `
 Options
-  --edit  Edit the configuration
+  --edit, -e           Edit the configuration
+  --test, -t           Test the configuration
+  --project-id <id>    Project ID to use
 
-Examples
+Examples:
   # View current configuration
   sanity blueprints config
 
   # Edit configuration
   sanity blueprints config --edit
+
+  # Test configuration
+  sanity blueprints config --test
+
+  # Edit and test configuration
+  sanity blueprints config -et
 `
 
-const defaultFlags = {
-  edit: false,
+export interface BlueprintsConfigFlags {
+  'test-config'?: boolean
+  'test'?: boolean
+  't'?: boolean
+  'edit'?: boolean
+  'e'?: boolean
+  'project-id'?: string
+  'projectId'?: string
+  'project'?: string
+  'stack-id'?: string
+  'stackId'?: string
+  'stack'?: string
+}
+
+const defaultFlags: BlueprintsConfigFlags = {
+  //
 }
 
-const configBlueprintsCommand: CliCommandDefinition = {
+const configBlueprintsCommand: CliCommandDefinition<BlueprintsConfigFlags> = {
   name: 'config',
   group: 'blueprints',
   helpText,
-  signature: '[--edit]',
+  signature: '[--edit] [-e] [--test] [-t] [--project-id <id>]',
   description: 'View or edit local Blueprints configuration',
-  hideFromHelp: true,
+
   async action(args, context) {
-    const {apiClient, output, prompt} = context
-    const {print} = output
+    const {apiClient, output} = context
     const flags = {...defaultFlags, ...args.extOptions}
 
     const client = apiClient({
@@ -33,79 +54,34 @@ const configBlueprintsCommand: CliCommandDefinition = {
       requireProject: false,
     })
     const {token} = client.config()
-    const {
-      blueprint: blueprintAction,
-      projects: projectsAction,
-      stacks: stacksAction,
-    } = await import('@sanity/runtime-cli/actions/blueprints')
-
-    const config = blueprintAction.readConfigFile()
-    if (!config) {
-      print('No configuration found. Run `sanity blueprints init` first.')
-      return
-    }
 
-    print('\nCurrent configuration:')
-    print(JSON.stringify(config, null, 2))
-
-    if (!flags.edit) {
-      return
-    }
+    if (!token) throw new Error('No API token found. Please run `sanity login`.')
 
-    if (!token) {
-      print('No API token found. Please run `sanity login` first.')
-      return
-    }
+    const {blueprintConfigCore} = await import('@sanity/runtime-cli/cores/blueprints')
+    const {getBlueprintAndStack} = await import('@sanity/runtime-cli/actions/blueprints')
+    const {display} = await import('@sanity/runtime-cli/utils')
 
-    const {ok, projects, error} = await projectsAction.listProjects({token})
-    if (!ok) {
-      print(error)
-      return
-    }
+    const {localBlueprint, issues} = await getBlueprintAndStack({token})
 
-    if (!projects || projects.length === 0) {
-      print('No Projects found. Please create a Project in Sanity.io first.')
-      return
+    if (issues) {
+      // print issues and continue
+      output.print(display.errors.presentBlueprintIssues(issues))
     }
 
-    const projectChoices = projects.map(({displayName, id}) => ({
-      value: id,
-      name: `${displayName} <${id}>`,
-    }))
-
-    const projectId = await prompt.single({
-      type: 'list',
-      message: 'Select your Sanity Project:',
-      choices: projectChoices,
-      default: config.projectId,
+    const {success, error} = await blueprintConfigCore({
+      bin: 'sanity',
+      log: (message) => output.print(message),
+      blueprint: localBlueprint,
+      token,
+      flags: {
+        'project-id': flags['project-id'] ?? flags.projectId ?? flags.project,
+        'stack-id': flags['stack-id'] ?? flags.stackId ?? flags.stack,
+        'test-config': flags['test-config'] ?? flags.test ?? flags.t,
+        'edit': flags.edit ?? flags.e,
+      },
     })
 
-    const auth = {token, projectId}
-
-    // get stacks for selected project
-    const {ok: stacksOk, stacks, error: stacksError} = await stacksAction.listStacks(auth)
-    if (!stacksOk) {
-      print(stacksError)
-      return
-    }
-
-    let stackId
-    if (stacks && stacks.length > 0) {
-      const stackChoices = stacks.map(({name, id}) => ({
-        value: id,
-        name: `${name} <${id}>`,
-      }))
-
-      stackId = await prompt.single({
-        type: 'list',
-        message: 'Select a Stack:',
-        choices: stackChoices,
-        default: config.stackId,
-      })
-    }
-
-    blueprintAction.writeConfigFile({projectId, stackId})
-    print('\nConfiguration updated successfully.')
+    if (!success) throw new Error(error)
   },
 }
 

package/src/commands/blueprints/deployBlueprintsCommand.ts

@@ -1,163 +1,71 @@
 import {type CliCommandDefinition} from '../../types'
 
 const helpText = `
-Examples
+Options
+  --no-wait    Do not wait for deployment to complete
+
+Examples:
   # Deploy the current blueprint
   sanity blueprints deploy
+
+  # Deploy the current blueprint without waiting for completion
+  sanity blueprints deploy --no-wait
 `
 
-const deployBlueprintsCommand: CliCommandDefinition = {
+export interface BlueprintsDeployFlags {
+  'no-wait'?: boolean
+}
+
+const defaultFlags: BlueprintsDeployFlags = {
+  //
+}
+
+const deployBlueprintsCommand: CliCommandDefinition<BlueprintsDeployFlags> = {
   name: 'deploy',
   group: 'blueprints',
   helpText,
-  signature: '',
+  signature: '[--no-wait]',
   description: 'Deploy a Blueprint to create or update a Stack',
-  hideFromHelp: true,
-  /* eslint-disable-next-line complexity, max-statements */
+
   async action(args, context) {
-    const {apiClient, output, prompt} = context
-    const {print} = output
+    const {apiClient, output} = context
+    const flags = {...defaultFlags, ...args.extOptions}
 
     const client = apiClient({
       requireUser: true,
       requireProject: false,
     })
     const {token} = client.config()
-    const {
-      blueprint: blueprintAction,
-      stacks: stacksAction,
-      assets: assetsAction,
-    } = await import('@sanity/runtime-cli/actions/blueprints')
-    const {display} = await import('@sanity/runtime-cli/utils')
-
-    if (!token) {
-      print('No API token found. Please run `sanity login` first.')
-      return
-    }
-
-    let blueprint = null
-    try {
-      blueprint = await blueprintAction.readBlueprintOnDisk({getStack: true, token})
-    } catch (error) {
-      print('Unable to read Blueprint manifest file. Run `sanity blueprints init`')
-      return
-    }
-
-    if (!blueprint) {
-      print('Unable to read Blueprint manifest file. Run `sanity blueprints init`')
-      return
-    }
-
-    const {
-      errors,
-      projectId: configuredProjectId,
-      stackId,
-      parsedBlueprint,
-      deployedStack,
-    } = blueprint
-
-    if (errors && errors.length > 0) {
-      print(errors)
-      return
-    }
-
-    if (stackId && !deployedStack) {
-      print('Stack specified in config, but deployed Stack not found.')
-      return
-    }
-
-    const resources = parsedBlueprint.resources || []
+    if (!token) throw new Error('No API token found. Please run `sanity login`.')
 
-    let projectId = configuredProjectId
-    if (!projectId) {
-      print('No Sanity Project context found in Blueprint configuration.')
-
-      const maybeProjectId = await prompt.single({
-        type: 'input',
-        message: 'Enter Sanity Project ID:',
-      })
+    const {blueprintDeployCore} = await import('@sanity/runtime-cli/cores/blueprints')
+    const {getBlueprintAndStack} = await import('@sanity/runtime-cli/actions/blueprints')
+    const {display} = await import('@sanity/runtime-cli/utils')
 
-      projectId = maybeProjectId
-    }
+    const {localBlueprint, deployedStack, issues} = await getBlueprintAndStack({token})
 
-    if (!projectId) {
-      print('Sanity Project context is required')
-      print('To configure this Blueprint, run `sanity blueprints config`')
-      return
+    if (issues) {
+      output.print(display.errors.presentBlueprintIssues(issues))
+      throw new Error('Unable to parse Blueprint file.')
     }
 
+    const {projectId, stackId} = localBlueprint
     const auth = {token, projectId}
 
-    let name = deployedStack?.name
-    if (!name) {
-      const stackName = await prompt.single({
-        type: 'input',
-        message: 'Enter stack name:',
-        validate: (input) => input.length > 0 || 'Stack name is required',
-      })
-
-      name = stackName
-    }
-
-    if (!name) {
-      print('Stack name is required')
-      return
-    }
-
-    const validResources = resources?.filter((r) => r.type)
-    const functionResources = validResources?.filter((r) => r.type.startsWith('sanity.function.'))
-
-    if (functionResources?.length) {
-      for (const resource of functionResources) {
-        print(`Processing ${resource.name}...`)
-        const result = await assetsAction.stashAsset({resource, auth})
-
-        if (result.success && result.assetId) {
-          const src = resource.src
-          resource.src = result.assetId // ! this will change! for now, the API expects the assetId
-          const {yellow} = display.colors
-          print(`${resource.name} <${yellow(result.assetId)}>`)
-          print(`   Source: ${src}`)
-        } else {
-          print(`   Error: ${result.error}`)
-          throw new Error(`Failed to process ${resource.name}`)
-        }
-      }
-    }
-
-    const stackPayload = {
-      name,
+    const {success, error} = await blueprintDeployCore({
+      bin: 'sanity',
+      log: (message) => output.print(message),
+      auth,
       projectId,
-      document: {resources: validResources},
-    }
-
-    print('Deploying stack...')
-
-    const {
-      ok: deployOk,
-      stack,
-      error: deployError,
-    } = deployedStack
-      ? await stacksAction.updateStack({stackId: deployedStack.id, stackPayload, auth})
-      : await stacksAction.createStack({stackPayload, auth})
-
-    if (deployOk) {
-      const {green, bold, yellow} = display.colors
-      print(
-        `${green('Success!')} Stack "${bold(stack.name)}" ${deployedStack ? 'updated' : 'created'} <${yellow(stack.id)}>`,
-      )
-
-      blueprintAction.writeConfigFile({
-        projectId,
-        stackId: stack.id,
-      })
+      stackId,
+      deployedStack,
+      blueprint: localBlueprint,
+      flags: {
+        'no-wait': flags['no-wait'],
+      },
+    })
 
-      print('\nUse `sanity blueprints info` to check deployment status')
-    } else {
-      const {red} = display.colors
-      print(`${red('Failed')} to ${deployedStack ? 'update' : 'create'} stack`)
-      print(`Error: ${deployError || JSON.stringify(stack, null, 2) || 'Unknown error'}`)
-    }
+    if (!success) throw new Error(error)
   },
 }
 

package/src/commands/blueprints/destroyBlueprintsCommand.ts

@@ -0,0 +1,76 @@
+import {type CliCommandDefinition} from '../../types'
+
+const helpText = `
+Options
+  --force, -f    Force destroy without confirmation
+  --no-wait      Do not wait for destroy to complete
+
+Examples:
+  # Destroy the current deployment
+  sanity blueprints destroy
+
+  # Force destroy without confirmation
+  sanity blueprints destroy --force
+
+  # Destroy without waiting for completion
+  sanity blueprints destroy --no-wait
+`
+
+export interface BlueprintsDestroyFlags {
+  'force'?: boolean
+  'f'?: boolean
+  'project-id'?: string
+  'projectId'?: string
+  'project'?: string
+  'stack-id'?: string
+  'stackId'?: string
+  'stack'?: string
+  'no-wait'?: boolean
+}
+
+const defaultFlags: BlueprintsDestroyFlags = {
+  //
+}
+
+const destroyBlueprintsCommand: CliCommandDefinition<BlueprintsDestroyFlags> = {
+  name: 'destroy',
+  group: 'blueprints',
+  helpText,
+  signature: '[--force] [-f] [--no-wait]',
+  description: 'Destroy a Blueprint deployment',
+  hideFromHelp: true,
+
+  async action(args, context) {
+    const {apiClient, output} = context
+    const flags = {...defaultFlags, ...args.extOptions}
+
+    const client = apiClient({
+      requireUser: true,
+      requireProject: false,
+    })
+    const {token} = client.config()
+    if (!token) throw new Error('No API token found. Please run `sanity login`.')
+
+    const {blueprintDestroyCore} = await import('@sanity/runtime-cli/cores/blueprints')
+    const {getBlueprintAndStack} = await import('@sanity/runtime-cli/actions/blueprints')
+
+    const {localBlueprint} = await getBlueprintAndStack({token})
+
+    const {success, error} = await blueprintDestroyCore({
+      bin: 'sanity',
+      log: (message) => output.print(message),
+      token,
+      blueprint: localBlueprint,
+      flags: {
+        'no-wait': flags['no-wait'],
+        'force': flags.force ?? flags.f,
+        'project-id': flags['project-id'] ?? flags.projectId ?? flags.project,
+        'stack-id': flags['stack-id'] ?? flags.stackId ?? flags.stack,
+      },
+    })
+
+    if (!success) throw new Error(error)
+  },
+}
+
+export default destroyBlueprintsCommand