feat: support multi scene deployment (#1355)

* feat: support multi scene deployment

* feat: validate that user is not uploading the same parcels

* feat: move parcel checking to another function

* feat: remove unused errors

* feat: handle missing delete signature and fix parcel overlap check for world
  deploys

* feat: remove logs

Author: alejandralevy

packages/@dcl/sdk-commands/src/commands/deploy/index.ts

@@ -12,7 +12,16 @@ import { printProgressInfo, printSuccess } from '../../logic/beautiful-logs'
 import { getPackageJson, b64HashingFunction } from '../../logic/project-files'
 import { Events } from '../../components/analytics'
 import { Result } from 'arg'
-import { getAddressAndSignature, getCatalyst, sceneHasWorldCfg } from './utils'
+import {
+  getAddressAndSignature,
+  getCatalyst,
+  sceneHasWorldCfg,
+  buildDeleteScenesFromWorldPayload,
+  deleteWorldScenes,
+  fetchWorldScenes,
+  getScenesOnOtherParcels,
+  promptUser
+} from './utils'
 import { buildScene } from '../build'
 import { getValidWorkspace } from '../../logic/workspace-validations'
 import { LinkerResponse } from '../../linker-dapp/routes'
@@ -51,7 +60,8 @@ export const args = declareArgs({
   '-b': '--no-browser',
   '--port': Number,
   '-p': '--port',
-  '--programmatic': Boolean
+  '--programmatic': Boolean,
+  '--multi-scene': Boolean
 })
 
 export function help(options: Options) {
@@ -67,6 +77,7 @@ export function help(options: Options) {
       --skip-build              Skip build before deploy
       --skip-validations        Skip permissions verifications on the client side when deploying content
       --programmatic            Enable programmatic mode - returns a promise that resolves when deployment completes
+      --multi-scene             Deploy alongside existing scenes in a world (additive deploy, no deletion)
 
     Example:
     - Deploy your scene:
@@ -86,6 +97,9 @@ export async function main(options: Options): Promise<ProgrammaticDeployResult |
   const skipBuild = options.args['--skip-build']
   const linkerPort = options.args['--port']
   const isProgrammatic = options.args['--programmatic']
+  const multiScene = !!options.args['--multi-scene']
+  const autoYes = !!options.args['--yes']
+  const targetContent = options.args['--target-content']
 
   if (workspace.projects.length !== 1) {
     throw new CliError('DEPLOY_WORKSPACE_NOT_SUPPORTED', i18next.t('errors.deploy.workspace_not_supported'))
@@ -101,18 +115,69 @@ export async function main(options: Options): Promise<ProgrammaticDeployResult |
   const sceneJson = { sdkVersion, ...(await getValidSceneJson(options.components, projectRoot, { log: true })) }
   const coords = getBaseCoords(sceneJson)
   const isWorld = sceneHasWorldCfg(sceneJson)
+  const worldName = sceneJson.worldConfiguration?.name
+
+  if (isWorld) {
+    options.components.logger.info(
+      `[DEPLOY] deploying in world:${isWorld}, multi scene world:${multiScene}, world name:${worldName}`
+    )
+  }
+
   const trackProps: Events['Scene deploy started'] = {
     projectHash: b64HashingFunction(projectRoot),
     coords,
     isWorld
   }
+
   const packageJson = await getPackageJson(options.components, projectRoot)
   const dependencies = Array.from(
     new Set([...Object.keys(packageJson.dependencies || {}), ...Object.keys(packageJson.devDependencies || {})])
   )
 
   options.components.analytics.track('Scene deploy started', trackProps)
 
+  let needsDelete = false
+  if (isWorld && !multiScene && worldName) {
+    options.components.logger.info(`[DEPLOY] checking existing scenes for world "${worldName}"...`)
+    try {
+      const existingScenes = await fetchWorldScenes(options.components.logger, worldName, targetContent)
+
+      if (existingScenes.length > 0) {
+        const scenesOnOtherParcels = getScenesOnOtherParcels(existingScenes, sceneJson.scene.parcels)
+
+        if (scenesOnOtherParcels.length > 0) {
+          options.components.logger.warn(
+            `World "${worldName}" has ${scenesOnOtherParcels.length} other scene(s) that will be removed:`
+          )
+
+          for (const scene of scenesOnOtherParcels) {
+            const title = scene.entity?.metadata?.display?.title || 'Untitled'
+            const parcels = scene.parcels?.join(', ') || 'unknown parcels'
+            options.components.logger.log(`  - "${title}" at parcels ${parcels}`)
+          }
+
+          options.components.logger.log('')
+          options.components.logger.warn(
+            'Deploying without --multi-scene will DELETE all existing scenes in world first.'
+          )
+
+          if (!autoYes) {
+            const confirmed = await promptUser('Continue? (y/N) ')
+            if (!confirmed) {
+              throw new CliError('DEPLOY_CANCELLED', 'Deployment cancelled by user.')
+            }
+          }
+          needsDelete = true
+        } else {
+          options.components.logger.warn(`[DEPLOY] no existing scenes in other parcels, deployment will continue`)
+        }
+      }
+    } catch (e: any) {
+      if (e instanceof CliError) throw e
+      options.components.logger.warn(`Could not check existing world scenes: ${e.message}`)
+    }
+  }
+
   if (!skipBuild) {
     await buildScene(
       { ...options, args: { '--dir': projectRoot, '--watch': false, '--production': true, _: [] } },
@@ -134,11 +199,11 @@ export async function main(options: Options): Promise<ProgrammaticDeployResult |
     metadata: sceneJson
   })
 
-  // Signing message
   const messageToSign = entityId
 
-  // Start the linker dapp and wait for the user to sign in (linker response).
-  // And then close the program
+  const deleteScenesFromWorldPayload =
+    needsDelete && worldName ? buildDeleteScenesFromWorldPayload(worldName) : undefined
+
   const awaitResponse = future<void>()
   const { program } = await getAddressAndSignature(
     options.components,
@@ -152,7 +217,8 @@ export async function main(options: Options): Promise<ProgrammaticDeployResult |
       linkerPort,
       isHttps: !!options.args['--https']
     },
-    deployEntity
+    deployEntity,
+    deleteScenesFromWorldPayload
   )
 
   // Programmatic mode early return
@@ -182,6 +248,40 @@ export async function main(options: Options): Promise<ProgrammaticDeployResult |
     // Uploading data
     const { client, url } = await getCatalyst(chainId, options.args['--target'], options.args['--target-content'])
 
+    if (needsDelete && worldName && !linkerResponse.deleteSignature) {
+      throw new CliError(
+        'DEPLOY_DELETE_FAILED',
+        `Cannot delete existing scenes from "${worldName}": there's not signatur for deleting the scenes.`
+      )
+    }
+
+    if (needsDelete && worldName && linkerResponse.deleteSignature) {
+      options.components.logger.info(`[DEPLOY] deleting scenes for "${worldName}"`)
+
+      try {
+        const deleteResponse = await deleteWorldScenes(
+          options.components,
+          worldName,
+          linkerResponse.deleteSignature,
+          targetContent
+        )
+
+        if (deleteResponse.ok) {
+          options.components.logger.info(`[DEPLOY] existing scenes for "${worldName} deleted successfully"`)
+        } else {
+          const errorText = await deleteResponse.text()
+          options.components.logger.info(`[DEPLOY] DELETE FAILED: status=${deleteResponse.status} body=${errorText}`)
+          throw new CliError(
+            'DEPLOY_DELETE_FAILED',
+            `Failed to delete existing scenes from "${worldName}" (status ${deleteResponse.status}): ${errorText}\n`
+          )
+        }
+      } catch (e: any) {
+        if (e instanceof CliError) throw e
+        throw new CliError('DEPLOY_DELETE_FAILED', `Error deleting existing scenes from "${worldName}": ${e.message}\n`)
+      }
+    }
+
     printProgressInfo(options.components.logger, `Uploading data to: ${url}...`)
 
     const deployData = { entityId, files: entityFiles, authChain }

packages/@dcl/sdk-commands/src/commands/deploy/utils.ts

@@ -1,4 +1,6 @@
+import * as readline from 'readline'
 import { ChainId, Scene } from '@dcl/schemas'
+import { AuthChain } from '@dcl/crypto'
 import { Lifecycle } from '@well-known-components/interfaces'
 import { createCatalystClient, createContentClient, CatalystClient, ContentClient } from 'dcl-catalyst-client'
 import { getCatalystServersFromCache } from 'dcl-catalyst-client/dist/contracts-snapshots'
@@ -67,6 +69,44 @@ export async function getCatalyst(
   }
 }
 
+export function buildDeleteScenesFromWorldPayload(worldName: string): string {
+  const encodedName = encodeURIComponent(worldName)
+  const path = `/entities/${encodedName}`
+  const timestamp = String(Date.now())
+  const metadata = '{}'
+  return ['delete', path, timestamp, metadata].join(':').toLowerCase()
+}
+
+export async function deleteWorldScenes(
+  components: Pick<CliComponents, 'logger'>,
+  worldName: string,
+  deleteSignature: string,
+  targetContent?: string
+): Promise<Response> {
+  const { logger } = components
+
+  const encodedName = encodeURIComponent(worldName)
+  const deleteUrl = `${targetContent}/entities/${encodedName}`
+
+  const authChain: AuthChain = JSON.parse(deleteSignature)
+  const lastLink = authChain[authChain.length - 1]
+  const payloadParts = lastLink.payload.split(':')
+  const timestamp = payloadParts[2] || String(Date.now())
+  const metadata = payloadParts[3] || '{}'
+
+  const headers: Record<string, string> = {
+    'x-identity-timestamp': timestamp,
+    'x-identity-metadata': metadata
+  }
+  authChain.forEach((link, i) => {
+    headers[`x-identity-auth-chain-${i}`] = JSON.stringify(link)
+  })
+
+  const response = await fetch(deleteUrl, { method: 'DELETE', headers })
+  logger.info(`[DELETE] deleting world scenes status=${response.status}`)
+  return response
+}
+
 export async function getAddressAndSignature(
   components: CliComponents,
   awaitResponse: IFuture<void>,
@@ -75,7 +115,8 @@ export async function getAddressAndSignature(
   files: IFile[],
   skipValidations: boolean,
   linkOptions: Omit<dAppOptions, 'uri'>,
-  deployCallback: (response: LinkerResponse) => Promise<void>
+  deployCallback: (response: LinkerResponse) => Promise<void>,
+  deleteScenesFromWorldPayload?: string
 ): Promise<{ program?: Lifecycle.ComponentBasedProgram<unknown> }> {
   if (process.env.DCL_PRIVATE_KEY) {
     const wallet = createWallet(process.env.DCL_PRIVATE_KEY)
@@ -84,13 +125,13 @@ export async function getAddressAndSignature(
       wallet.address,
       ethSign(hexToBytes(wallet.privateKey), messageToSign)
     )
-    const linkerResponse = { authChain, address: wallet.address }
+    const linkerResponse: LinkerResponse = { authChain, address: wallet.address }
     await deployCallback(linkerResponse)
     awaitResponse.resolve()
     return {}
   }
 
-  const sceneInfo = await getSceneInfo(components, scene, messageToSign, skipValidations)
+  const sceneInfo = await getSceneInfo(components, scene, messageToSign, skipValidations, deleteScenesFromWorldPayload)
   const { router: commonRouter } = setRoutes(components, sceneInfo)
   const router = setDeployRoutes(commonRouter, components, awaitResponse, sceneInfo, files, deployCallback)
 
@@ -109,7 +150,6 @@ function setDeployRoutes(
 ): Router<object> {
   const { logger } = components
 
-  // We need to wait so the linker-dapp can receive the response and show a nice message.
   const resolveLinkerPromise = () => setTimeout(() => awaitResponse.resolve(), 100)
   const rejectLinkerPromise = (e: Error) => setTimeout(() => awaitResponse.reject(e), 100)
   let linkerResponse: LinkerResponse
@@ -129,8 +169,6 @@ function setDeployRoutes(
     const value = await getPointers(components, pointer, network)
     const deployedToAll = new Set(value.map((c) => c.entityId)).size === 1
 
-    // Deployed to every catalyst, close the linker dapp and
-    // exit the command automatically so the user dont have to.
     if (deployedToAll) resolveLinkerPromise()
 
     return {
@@ -140,21 +178,17 @@ function setDeployRoutes(
 
   router.post('/api/deploy', async (ctx) => {
     const value = (await ctx.request.json()) as LinkerResponse
-
     if (!value.address || !value.authChain || !value.chainId) {
       const errorMessage = `Invalid payload: ${Object.keys(value).join(' - ')}`
       logger.error(errorMessage)
       resolveLinkerPromise()
       return { status: 400, body: { message: errorMessage } }
     }
 
-    // Store the chainId so we can use it on the catalyst pointers.
     linkerResponse = value
 
     try {
       await deployCallback(value)
-      // If its a world we dont wait for the catalyst pointers.
-      // Close the program.
       if (sceneInfo.isWorld) {
         resolveLinkerPromise()
       }
@@ -185,13 +219,15 @@ export interface SceneInfo {
   isPortableExperience: boolean
   isWorld: boolean
   world?: string
+  deleteScenesFromWorldPayload?: string
 }
 
 export async function getSceneInfo(
   components: Pick<CliComponents, 'config'>,
   scene: Scene,
   rootCID: string,
-  skipValidations: boolean
+  skipValidations: boolean,
+  deleteScenesFromWorldPayload?: string
 ) {
   const {
     scene: { parcels, base },
@@ -211,6 +247,54 @@ export async function getSceneInfo(
     skipValidations,
     isPortableExperience: !!isPortableExperience,
     isWorld: sceneHasWorldCfg(scene),
-    world: scene.worldConfiguration?.name
+    world: scene.worldConfiguration?.name,
+    deleteScenesFromWorldPayload
   }
 }
+
+export interface WorldScene {
+  entityId: string
+  parcels?: string[]
+  entity?: { metadata?: { display?: { title?: string } } }
+}
+
+export function getScenesOnOtherParcels(existingScenes: WorldScene[], deployingParcels: string[]): WorldScene[] {
+  const parcelsSet = new Set(deployingParcels)
+  return existingScenes.filter((scene) => {
+    const sceneParcels = scene.parcels || []
+    return sceneParcels.every((p) => !parcelsSet.has(p))
+  })
+}
+
+interface WorldScenesResponse {
+  scenes: WorldScene[]
+  total: number
+}
+
+export async function fetchWorldScenes(
+  logger: { info: (msg: string) => void },
+  worldName: string,
+  targetContent?: string
+): Promise<WorldScene[]> {
+  const encodedName = encodeURIComponent(worldName)
+  const url = `${targetContent}/world/${encodedName}/scenes`
+  const response = await fetch(url)
+  if (!response.ok) {
+    const text = await response.text()
+    logger.info(`[DEPLOY] fetching scenes from world -  error: ${text}`)
+    throw new Error(`Failed to fetch world scenes: ${response.status} ${response.statusText}`)
+  }
+  const data = (await response.json()) as WorldScenesResponse
+  logger.info(`[DEPLOY] fetching scenes from world success: total=${data.total}, scenes=${data.scenes?.length}`)
+  return data.scenes || []
+}
+
+export function promptUser(question: string): Promise<boolean> {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close()
+      resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes')
+    })
+  })
+}

packages/@dcl/sdk-commands/src/linker-dapp/routes.ts

@@ -127,4 +127,5 @@ export interface LinkerResponse {
   address: string
   authChain: AuthChain
   chainId?: ChainId
+  deleteSignature?: string
 }

packages/@dcl/sdk-commands/src/logic/error.ts

@@ -7,6 +7,8 @@ export type CliErrorName =
   | 'DEPLOY_INVALID_PROJECT_TYPE'
   | 'DEPLOY_INVALID_ARGUMENTS'
   | 'DEPLOY_UPLOAD_FAILED'
+  | 'DEPLOY_CANCELLED'
+  | 'DEPLOY_DELETE_FAILED'
   // Export static errors
   | 'EXPORT_STATIC_BASE_URL_REQUIRED'
   | 'EXPORT_STATIC_INVALID_REALM_NAME'