feat(cli): add app undeploy command

binoy14 · binoy14 · commit ba663e3b7626 · 2025-02-28T11:45:49.000-05:00
diff --git a/packages/sanity/src/_internal/cli/actions/app/__tests__/undeployAction.test.ts b/packages/sanity/src/_internal/cli/actions/app/__tests__/undeployAction.test.ts
@@ -0,0 +1,126 @@
+import {type CliCommandArguments, type CliCommandContext} from '@sanity/cli'
+import {beforeEach, describe, expect, it, type Mock, vi} from 'vitest'
+
+import {type UserApplication} from '../../deploy/helpers'
+import * as _helpers from '../../deploy/helpers'
+import undeployCoreAppAction from '../undeployAction'
+
+// Mock dependencies
+vi.mock('../../deploy/helpers')
+
+const helpers = vi.mocked(_helpers)
+type SpinnerInstance = {
+  start: Mock<() => SpinnerInstance>
+  succeed: Mock<() => SpinnerInstance>
+  fail: Mock<() => SpinnerInstance>
+}
+
+describe('undeployCoreAppAction', () => {
+  let mockContext: CliCommandContext
+
+  const mockApplication: UserApplication = {
+    id: 'app-id',
+    organizationId: 'org-id',
+    appHost: 'app-host',
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    urlType: 'internal',
+    projectId: null,
+    title: null,
+    type: 'coreApp',
+  }
+
+  let spinnerInstance: SpinnerInstance
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+
+    spinnerInstance = {
+      start: vi.fn(() => spinnerInstance),
+      succeed: vi.fn(() => spinnerInstance),
+      fail: vi.fn(() => spinnerInstance),
+    }
+
+    mockContext = {
+      apiClient: vi.fn().mockReturnValue({
+        withConfig: vi.fn().mockReturnThis(),
+      }),
+      chalk: {yellow: vi.fn((str) => str), red: vi.fn((str) => str)},
+      output: {
+        print: vi.fn(),
+        spinner: vi.fn().mockReturnValue(spinnerInstance),
+      },
+      prompt: {single: vi.fn()},
+      cliConfig: {},
+    } as unknown as CliCommandContext
+  })
+
+  it('does nothing if there is no user application', async () => {
+    helpers.getUserApplication.mockResolvedValueOnce(null)
+
+    await undeployCoreAppAction({} as CliCommandArguments<Record<string, unknown>>, mockContext)
+
+    expect(mockContext.output.print).toHaveBeenCalledWith(
+      'Your project has not been assigned a Core application ID',
+    )
+    expect(mockContext.output.print).toHaveBeenCalledWith(
+      'or you do not have __experimental_coreAppConfiguration set in sanity.cli.js or sanity.cli.ts.',
+    )
+    expect(mockContext.output.print).toHaveBeenCalledWith('Nothing to undeploy.')
+  })
+
+  it('prompts the user for confirmation and undeploys if confirmed', async () => {
+    helpers.getUserApplication.mockResolvedValueOnce(mockApplication)
+    helpers.deleteUserApplication.mockResolvedValueOnce(undefined)
+    ;(mockContext.prompt.single as Mock<typeof mockContext.prompt.single>).mockResolvedValueOnce(
+      true,
+    ) // User confirms
+
+    await undeployCoreAppAction({} as CliCommandArguments<Record<string, unknown>>, mockContext)
+
+    expect(mockContext.prompt.single).toHaveBeenCalledWith({
+      type: 'confirm',
+      default: false,
+      message: expect.stringContaining('undeploy'),
+    })
+    expect(helpers.deleteUserApplication).toHaveBeenCalledWith({
+      client: expect.anything(),
+      applicationId: 'app-id',
+      appType: 'coreApp',
+    })
+    expect(mockContext.output.print).toHaveBeenCalledWith(
+      expect.stringContaining('Application undeploy scheduled.'),
+    )
+  })
+
+  it('does not undeploy if the user cancels the prompt', async () => {
+    helpers.getUserApplication.mockResolvedValueOnce(mockApplication)
+    ;(mockContext.prompt.single as Mock<typeof mockContext.prompt.single>).mockResolvedValueOnce(
+      false,
+    ) // User cancels
+
+    await undeployCoreAppAction({} as CliCommandArguments<Record<string, unknown>>, mockContext)
+
+    expect(mockContext.prompt.single).toHaveBeenCalledWith({
+      type: 'confirm',
+      default: false,
+      message: expect.stringContaining('undeploy'),
+    })
+    expect(helpers.deleteUserApplication).not.toHaveBeenCalled()
+  })
+
+  it('handles errors during the undeploy process', async () => {
+    const errorMessage = 'Example error'
+    helpers.getUserApplication.mockResolvedValueOnce(mockApplication)
+    helpers.deleteUserApplication.mockRejectedValueOnce(new Error(errorMessage))
+    ;(mockContext.prompt.single as Mock<typeof mockContext.prompt.single>).mockResolvedValueOnce(
+      true,
+    ) // User confirms
+
+    await expect(
+      undeployCoreAppAction({} as CliCommandArguments<Record<string, unknown>>, mockContext),
+    ).rejects.toThrow(errorMessage)
+
+    expect(mockContext.output.spinner('').fail).toHaveBeenCalled()
+  })
+})
diff --git a/packages/sanity/src/_internal/cli/actions/app/undeployAction.ts b/packages/sanity/src/_internal/cli/actions/app/undeployAction.ts
@@ -0,0 +1,74 @@
+import {type CliCommandArguments, type CliCommandContext} from '@sanity/cli'
+
+import {debug as debugIt} from '../../debug'
+import {deleteUserApplication, getUserApplication} from '../deploy/helpers'
+
+const debug = debugIt.extend('undeploy')
+
+export default async function undeployCoreAppAction(
+  _: CliCommandArguments<Record<string, unknown>>,
+  context: CliCommandContext,
+): Promise<void> {
+  const {apiClient, chalk, output, prompt, cliConfig} = context
+
+  const client = apiClient({
+    requireUser: true,
+    requireProject: false,
+  }).withConfig({apiVersion: 'v2024-08-01'})
+
+  // Check that the project has a Core application ID
+  let spinner = output.spinner('Checking application info').start()
+
+  const userApplication = await getUserApplication({
+    client,
+    appId:
+      cliConfig && '__experimental_coreAppConfiguration' in cliConfig
+        ? cliConfig.__experimental_coreAppConfiguration?.appId
+        : undefined,
+  })
+
+  spinner.succeed()
+
+  if (!userApplication) {
+    output.print('Your project has not been assigned a Core application ID')
+    output.print(
+      'or you do not have __experimental_coreAppConfiguration set in sanity.cli.js or sanity.cli.ts.',
+    )
+    output.print('Nothing to undeploy.')
+    return
+  }
+
+  // Double-check
+  output.print('')
+
+  const url = `https://${chalk.yellow(userApplication.appHost)}.sanity.studio`
+  const shouldUndeploy = await prompt.single({
+    type: 'confirm',
+    default: false,
+    message: `This will undeploy ${url} and make it unavailable for your users.
+  The hostname will be available for anyone to claim.
+  Are you ${chalk.red('sure')} you want to undeploy?`.trim(),
+  })
+
+  if (!shouldUndeploy) {
+    return
+  }
+
+  spinner = output.spinner('Undeploying application').start()
+  try {
+    await deleteUserApplication({
+      client,
+      applicationId: userApplication.id,
+      appType: 'coreApp',
+    })
+    spinner.succeed()
+  } catch (err) {
+    spinner.fail()
+    debug('Error undeploying application', err)
+    throw err
+  }
+
+  output.print(
+    `Application undeploy scheduled. It might take a few minutes before ${url} is unavailable.`,
+  )
+}
diff --git a/packages/sanity/src/_internal/cli/actions/deploy/__tests__/helpers.test.ts b/packages/sanity/src/_internal/cli/actions/deploy/__tests__/helpers.test.ts
@@ -294,11 +294,15 @@ describe('deleteUserApplication', () => {
     await deleteUserApplication({
       client: mockClient,
       applicationId: 'app-id',
+      appType: 'studio',
     })
 
     expect(mockClientRequest).toHaveBeenCalledWith({
       uri: '/user-applications/app-id',
       method: 'DELETE',
+      query: {
+        appType: 'studio',
+      },
     })
   })
 
@@ -307,12 +311,19 @@ describe('deleteUserApplication', () => {
     mockClientRequest.mockRejectedValueOnce(new Error(errorMessage))
 
     await expect(
-      deleteUserApplication({client: mockClient, applicationId: 'app-id'}),
+      deleteUserApplication({
+        client: mockClient,
+        applicationId: 'app-id',
+        appType: 'studio',
+      }),
     ).rejects.toThrow(errorMessage)
 
     expect(mockClientRequest).toHaveBeenCalledWith({
       uri: '/user-applications/app-id',
       method: 'DELETE',
+      query: {
+        appType: 'studio',
+      },
     })
   })
 })
diff --git a/packages/sanity/src/_internal/cli/actions/deploy/__tests__/undeployAction.test.ts b/packages/sanity/src/_internal/cli/actions/deploy/__tests__/undeployAction.test.ts
@@ -21,6 +21,7 @@ describe('undeployStudioAction', () => {
   const mockApplication: UserApplication = {
     id: 'app-id',
     appHost: 'app-host',
+    organizationId: null,
     createdAt: new Date().toISOString(),
     updatedAt: new Date().toISOString(),
     urlType: 'internal',
@@ -85,6 +86,7 @@ describe('undeployStudioAction', () => {
     expect(helpers.deleteUserApplication).toHaveBeenCalledWith({
       client: expect.anything(),
       applicationId: 'app-id',
+      appType: 'studio',
     })
     expect(mockContext.output.print).toHaveBeenCalledWith(
       expect.stringContaining('Studio undeploy scheduled.'),
diff --git a/packages/sanity/src/_internal/cli/actions/deploy/helpers.ts b/packages/sanity/src/_internal/cli/actions/deploy/helpers.ts
@@ -497,13 +497,21 @@ export async function createDeployment({
 export interface DeleteUserApplicationOptions {
   client: SanityClient
   applicationId: string
+  appType: 'coreApp' | 'studio'
 }
 
 export async function deleteUserApplication({
   applicationId,
   client,
+  appType,
 }: DeleteUserApplicationOptions): Promise<void> {
-  await client.request({uri: `/user-applications/${applicationId}`, method: 'DELETE'})
+  await client.request({
+    uri: `/user-applications/${applicationId}`,
+    query: {
+      appType,
+    },
+    method: 'DELETE',
+  })
 }
 
 export async function getInstalledSanityVersion(): Promise<string> {
diff --git a/packages/sanity/src/_internal/cli/actions/deploy/undeployAction.ts b/packages/sanity/src/_internal/cli/actions/deploy/undeployAction.ts
@@ -51,7 +51,11 @@ export default async function undeployStudioAction(
 
   spinner = output.spinner('Undeploying studio').start()
   try {
-    await deleteUserApplication({client, applicationId: userApplication.id})
+    await deleteUserApplication({
+      client,
+      applicationId: userApplication.id,
+      appType: 'studio',
+    })
     spinner.succeed()
   } catch (err) {
     spinner.fail()
diff --git a/packages/sanity/src/_internal/cli/commands/app/undeployCommand.ts b/packages/sanity/src/_internal/cli/commands/app/undeployCommand.ts
@@ -0,0 +1,28 @@
+import {
+  type CliCommandArguments,
+  type CliCommandContext,
+  type CliCommandDefinition,
+} from '@sanity/cli'
+
+const helpText = `
+Examples
+  sanity app undeploy
+`
+
+const appUndeployCommand: CliCommandDefinition = {
+  name: 'undeploy',
+  group: 'app',
+  signature: '',
+  description: 'Removes the deployed Core application from Sanity hosting',
+  action: async (
+    args: CliCommandArguments<Record<string, unknown>>,
+    context: CliCommandContext,
+  ) => {
+    const mod = await import('../../actions/app/undeployAction')
+
+    return mod.default(args, context)
+  },
+  helpText,
+}
+
+export default appUndeployCommand
diff --git a/packages/sanity/src/_internal/cli/commands/index.ts b/packages/sanity/src/_internal/cli/commands/index.ts
@@ -5,6 +5,7 @@ import appBuildCommand from './app/buildCommand'
 import appDeployCommand from './app/deployCommand'
 import appDevCommand from './app/devCommand'
 import appStartCommand from './app/startCommand'
+import appUndeployCommand from './app/undeployCommand'
 import backupGroup from './backup/backupGroup'
 import disableBackupCommand from './backup/disableBackupCommand'
 import downloadBackupCommand from './backup/downloadBackupCommand'
@@ -65,6 +66,7 @@ const commands: (CliCommandDefinition | CliCommandGroupDefinition)[] = [
   appDevCommand,
   appBuildCommand,
   appStartCommand,
+  appUndeployCommand,
   buildCommand,
   datasetGroup,
   deployCommand,
