feat: Unpublish world (#2946)

* feat: WIP unpublish world

* feat: Add decentraland-crypto-fetch

* feat: Support both unpublishing normal and world deployments

* fix: Add tests

* fix: Unskip tests

* fix: Tests

* fix: Tests

Author: fzavalia

package-lock.json

@@ -34,6 +34,7 @@
     "dcl-scene-writer": "^1.1.2",
     "decentraland": "^3.3.0",
     "decentraland-builder-scripts": "^0.24.0",
+    "decentraland-crypto-fetch": "^2.0.1",
     "decentraland-dapps": "^16.10.0",
     "decentraland-ecs": "^6.6.1-20201020183014.commit-bdc29ef-hotfix",
     "decentraland-experiments": "^1.0.2",

package.json

@@ -163,7 +163,7 @@ describe('when decoding an URN', () => {
 
   describe('when a valid entity urn is used', () => {
     describe('and the URN is an entity with a baseUrl', () => {
-      it.only('should decode and return each group', () => {
+      it('should decode and return each group', () => {
         expect(decodeURN('urn:decentraland:entity:anEntityId?=&baseUrl=https://aContentServerUrl')).toEqual({
           type: URNType.ENTITY,
           suffix: 'anEntityId?=&baseUrl=https://aContentServerUrl',

src/lib/urn.spec.ts

@@ -1,8 +1,13 @@
 import { CatalystClient, createCatalystClient, createContentClient } from 'dcl-catalyst-client'
 import { expectSaga } from 'redux-saga-test-plan'
 import * as matchers from 'redux-saga-test-plan/matchers'
+import { call, select } from 'redux-saga/effects'
+import { AuthIdentity } from '@dcl/crypto'
 import { buildEntity } from 'dcl-catalyst-client/dist/client/utils/DeploymentBuilder'
 import { getAddress } from 'decentraland-dapps/dist/modules/wallet/selectors'
+import { DataByKey } from 'decentraland-dapps/dist/lib/types'
+import cryptoFetch from 'decentraland-crypto-fetch'
+import { config } from 'config'
 import { BuilderAPI } from 'lib/api/builder'
 import { getCatalystContentUrl } from 'lib/api/peer'
 import { isLoggedIn } from 'modules/identity/selectors'
@@ -11,9 +16,17 @@ import { getMedia } from 'modules/media/selectors'
 import { objectURLToBlob } from 'modules/media/utils'
 import { getName } from 'modules/profile/selectors'
 import { getData } from 'modules/project/selectors'
+import { getData as getDeployments } from 'modules/deployment/selectors'
 import { createFiles } from 'modules/project/export'
 import { getSceneByProjectId } from 'modules/scene/utils'
-import { deployToWorldRequest, fetchWorldDeploymentsRequest, fetchWorldDeploymentsSuccess } from './actions'
+import {
+  clearDeploymentFailure,
+  clearDeploymentRequest,
+  clearDeploymentSuccess,
+  deployToWorldRequest,
+  fetchWorldDeploymentsRequest,
+  fetchWorldDeploymentsSuccess
+} from './actions'
 import { deploymentSaga } from './sagas'
 import { makeContentFiles } from './contentUtils'
 import { Deployment } from './types'
@@ -148,3 +161,106 @@ describe('when handling fetch worlds deployments request', () => {
       .silentRun()
   })
 })
+
+describe('when handling the clear deployment request action', () => {
+  let deploymentId: string
+  let identity: AuthIdentity | null
+  let deployments: DataByKey<Deployment>
+  let crytoFetchResponse: Response
+
+  beforeEach(() => {
+    deploymentId = 'deploymentId'
+    identity = null
+    deployments = {}
+    crytoFetchResponse = { ok: false, status: 500 } as Response
+  })
+
+  describe('when the stored deployments does not contain a deployment for the provided id', () => {
+    it('should put a clear deployment failure action signaling that the deployment id is invalid', async () => {
+      await expectSaga(deploymentSaga, builderAPI, catalystClient)
+        .provide([[select(getDeployments), deployments]])
+        .put(clearDeploymentFailure(deploymentId, 'Unable to clear deployment: Invalid deployment'))
+        .dispatch(clearDeploymentRequest(deploymentId))
+        .silentRun()
+    })
+  })
+
+  describe('when the stored deployments does contain a deployment for the provided id', () => {
+    beforeEach(() => {
+      deployments[deploymentId] = {} as Deployment
+    })
+
+    describe('when getting the identity returns a null or undefined value', () => {
+      it('should put a clear deployment failure action signaling that the identity cannot be obtained', async () => {
+        await expectSaga(deploymentSaga, builderAPI, catalystClient)
+          .provide([
+            [select(getDeployments), deployments],
+            [call(getIdentity), identity]
+          ])
+          .put(clearDeploymentFailure(deploymentId, 'Unable to clear deployment: Invalid identity'))
+          .dispatch(clearDeploymentRequest(deploymentId))
+          .silentRun()
+      })
+    })
+
+    describe('when getting the identity returns an identity', () => {
+      beforeEach(() => {
+        identity = {} as AuthIdentity
+      })
+
+      describe('when the stored deployment is for a world', () => {
+        let worldsContentServerUrl: string
+
+        beforeEach(() => {
+          deployments[deploymentId].world = 'world'
+          worldsContentServerUrl = 'https://worlds-content-server.com'
+          jest.spyOn(config, 'get').mockReturnValueOnce(worldsContentServerUrl)
+        })
+
+        describe('when the crypto fetch response is not ok', () => {
+          it('should put a clear deployment failure action signaling that the response is not ok', async () => {
+            await expectSaga(deploymentSaga, builderAPI, catalystClient)
+              .provide([
+                [select(getDeployments), deployments],
+                [call(getIdentity), identity],
+                [
+                  call(cryptoFetch, `${worldsContentServerUrl}/entities/world`, {
+                    method: 'DELETE',
+                    identity: identity!
+                  }),
+                  crytoFetchResponse
+                ]
+              ])
+              .put(clearDeploymentFailure(deploymentId, `Unable to clear deployment: Response is not ok, status 500`))
+              .dispatch(clearDeploymentRequest(deploymentId))
+              .silentRun()
+          })
+        })
+
+        describe('when the crypto fetch response is ok', () => {
+          beforeEach(() => {
+            crytoFetchResponse = { ok: true } as Response
+          })
+
+          it('should put a clear deployment success action signaling that the clear deployment executed successfuly', async () => {
+            await expectSaga(deploymentSaga, builderAPI, catalystClient)
+              .provide([
+                [select(getDeployments), deployments],
+                [call(getIdentity), identity],
+                [
+                  call(cryptoFetch, `${worldsContentServerUrl}/entities/world`, {
+                    method: 'DELETE',
+                    identity: identity!
+                  }),
+                  crytoFetchResponse
+                ]
+              ])
+              .put(clearDeploymentSuccess(deploymentId))
+              .dispatch(clearDeploymentRequest(deploymentId))
+              .silentRun()
+          })
+        })
+      })
+    })
+  })
+})

src/modules/deployment/sagas.spec.ts

@@ -1,13 +1,13 @@
+import { createFetchComponent } from '@well-known-components/fetch-component'
 import { CatalystClient, ContentClient, createContentClient } from 'dcl-catalyst-client'
 import { Authenticator, AuthIdentity } from '@dcl/crypto'
 import { Entity, EntityType } from '@dcl/schemas'
-import { createFetchComponent } from '@well-known-components/fetch-component'
+import cryptoFetch from 'decentraland-crypto-fetch'
 import { getAddress } from 'decentraland-dapps/dist/modules/wallet/selectors'
 import { buildEntity } from 'dcl-catalyst-client/dist/client/utils/DeploymentBuilder'
 import { takeLatest, put, select, call, take, all } from 'redux-saga/effects'
 import { config } from 'config'
 import { BuilderAPI, getEmptySceneUrl, getPreviewUrl } from 'lib/api/builder'
-import { getData as getDeployments } from 'modules/deployment/selectors'
 import { Deployment, SceneDefinition, Placement } from 'modules/deployment/types'
 import { takeScreenshot } from 'modules/editor/actions'
 import { fetchENSWorldStatusRequest } from 'modules/ens/actions'
@@ -24,6 +24,7 @@ import { Media } from 'modules/media/types'
 import { getName } from 'modules/profile/selectors'
 import { createFiles, EXPORT_PATH } from 'modules/project/export'
 import { getCurrentProject, getData as getProjects } from 'modules/project/selectors'
+import { getData as getDeployments } from 'modules/deployment/selectors'
 import { Project } from 'modules/project/types'
 import { getSceneByProjectId } from 'modules/scene/utils'
 import { Scene } from 'modules/scene/types'
@@ -59,9 +60,11 @@ import {
   fetchWorldDeploymentsRequest
 } from './actions'
 import { makeContentFiles } from './contentUtils'
-import { getEmptyDeployment, getThumbnail, UNPUBLISHED_PROJECT_ID } from './utils'
+import { UNPUBLISHED_PROJECT_ID, getEmptyDeployment, getThumbnail } from './utils'
 import { ProgressStage } from './types'
 
+const getWorldsContentServerUrl = () => config.get('WORLDS_CONTENT_SERVER', '')
+
 type UnwrapPromise<T> = T extends PromiseLike<infer U> ? U : T
 
 // TODO: Remove this. This is using the store directly which it shouldn't and causes a circular dependency.
@@ -330,7 +333,7 @@ export function* deploymentSaga(builder: BuilderAPI, catalystClient: CatalystCli
   function* handleDeployToWorldRequest(action: DeployToWorldRequestAction) {
     const { world, projectId } = action.payload
     const contentClient = createContentClient({
-      url: config.get('WORLDS_CONTENT_SERVER', ''),
+      url: getWorldsContentServerUrl(),
       fetcher: createFetchComponent()
     })
     try {
@@ -364,57 +367,60 @@ export function* deploymentSaga(builder: BuilderAPI, catalystClient: CatalystCli
   function* handleClearDeploymentRequest(action: ClearDeploymentRequestAction) {
     const { deploymentId } = action.payload
 
-    const deployments: ReturnType<typeof getDeployments> = yield select(getDeployments)
-    const deployment = deployments[deploymentId]
-    if (!deployment) {
-      yield put(deployToLandFailure('Unable to Publish: Invalid deployment'))
-      return
-    }
+    try {
+      const deployments: ReturnType<typeof getDeployments> = yield select(getDeployments)
+      const deployment = deployments[deploymentId]
 
-    let contentClient: ContentClient
-    if (deployment.world) {
-      contentClient = createContentClient({
-        url: config.get('WORLDS_CONTENT_SERVER', ''),
-        fetcher: createFetchComponent()
-      })
-    } else {
-      contentClient = yield call([catalystClient, 'getContentClient'])
-    }
+      if (!deployment) {
+        throw new Error('Unable to clear deployment: Invalid deployment')
+      }
 
-    const identity: AuthIdentity = yield getIdentity()
-    if (!identity) {
-      yield put(deployToLandFailure('Unable to Publish: Invalid identity'))
-      return
-    }
+      const identity: AuthIdentity = yield call(getIdentity)
+
+      if (!identity) {
+        throw new Error('Unable to clear deployment: Invalid identity')
+      }
+
+      if (deployment.world) {
+        const response: Response = yield call(cryptoFetch, `${getWorldsContentServerUrl()}/entities/${deployment.world}`, {
+          method: 'DELETE',
+          identity
+        })
+
+        if (!response.ok) {
+          throw new Error(`Unable to clear deployment: Response is not ok, status ${response.status}`)
+        }
+      } else {
+        const contentClient: ContentClient = yield call([catalystClient, 'getContentClient'])
+        const { placement } = deployment
+        const [emptyProject, emptyScene] = getEmptyDeployment(deployment.projectId || UNPUBLISHED_PROJECT_ID)
+        const files: UnwrapPromise<ReturnType<typeof createFiles>> = yield call(createFiles, {
+          project: emptyProject,
+          scene: emptyScene,
+          point: placement.point,
+          rotation: placement.rotation,
+          thumbnail: getEmptySceneUrl(),
+          author: null,
+          isDeploy: true,
+          isEmpty: true,
+          onProgress: handleProgress(ProgressStage.CREATE_FILES),
+          world: deployment.world ?? undefined
+        })
+        const contentFiles: Map<string, Buffer> = yield call(makeContentFiles, files)
+        const sceneDefinition: SceneDefinition = JSON.parse(files[EXPORT_PATH.SCENE_FILE])
+        const { entityId, files: hashedFiles } = yield call(buildEntity, {
+          type: EntityType.SCENE,
+          pointers: [...sceneDefinition.scene.parcels],
+          metadata: sceneDefinition,
+          files: contentFiles
+        })
+        const authChain = Authenticator.signPayload(identity, entityId)
+        yield call([contentClient, 'deploy'], { entityId, files: hashedFiles, authChain })
+      }
 
-    try {
-      const { placement } = deployment
-      const [emptyProject, emptyScene] = getEmptyDeployment(deployment.projectId || UNPUBLISHED_PROJECT_ID)
-      const files: UnwrapPromise<ReturnType<typeof createFiles>> = yield call(createFiles, {
-        project: emptyProject,
-        scene: emptyScene,
-        point: placement.point,
-        rotation: placement.rotation,
-        thumbnail: getEmptySceneUrl(),
-        author: null,
-        isDeploy: true,
-        isEmpty: true,
-        onProgress: handleProgress(ProgressStage.CREATE_FILES),
-        world: deployment.world ?? undefined
-      })
-      const contentFiles: Map<string, Buffer> = yield call(makeContentFiles, files)
-      const sceneDefinition: SceneDefinition = JSON.parse(files[EXPORT_PATH.SCENE_FILE])
-      const { entityId, files: hashedFiles } = yield call(buildEntity, {
-        type: EntityType.SCENE,
-        pointers: [...sceneDefinition.scene.parcels],
-        metadata: sceneDefinition,
-        files: contentFiles
-      })
-      const authChain = Authenticator.signPayload(identity, entityId)
-      yield call([contentClient, 'deploy'], { entityId, files: hashedFiles, authChain })
       yield put(clearDeploymentSuccess(deploymentId))
-    } catch (error) {
-      yield put(clearDeploymentFailure(deploymentId, error.message))
+    } catch (e) {
+      yield put(clearDeploymentFailure(deploymentId, e.message))
     }
   }
 
@@ -502,7 +508,7 @@ export function* deploymentSaga(builder: BuilderAPI, catalystClient: CatalystCli
 
   function* handleFetchWorldDeploymentsRequest(action: FetchWorldDeploymentsRequestAction) {
     const { worlds } = action.payload
-    const worldContentClient = createContentClient({ url: config.get('WORLDS_CONTENT_SERVER', ''), fetcher: createFetchComponent() })
+    const worldContentClient = createContentClient({ url: getWorldsContentServerUrl(), fetcher: createFetchComponent() })
     try {
       const entities: Entity[] = []