Merge pull request #798 from decentraland/feat/support-world-and-world-scenes-undeployment

feat: Add support fot world & world scenes undeployment

Author: LautaroPetaccio

package-lock.json

@@ -11,7 +11,7 @@
   "dependencies": {
     "@contentful/rich-text-react-renderer": "^16.1.6",
     "@dcl/hooks": "^1.0.0",
-    "@dcl/schemas": "^22.4.0",
+    "@dcl/schemas": "^24.0.0",
     "@sentry/browser": "^7.120.3",
     "@well-known-components/pushable-channel": "^1.0.3",
     "abort-controller": "^3.0.0",
@@ -100,7 +100,7 @@
     "workbox-cli": "^6.5.2"
   },
   "overrides": {
-    "@dcl/schemas": "^22.4.0"
+    "@dcl/schemas": "^24.0.0"
   },
   "keywords": [
     "gatsby"

package.json

@@ -3,6 +3,7 @@ import { Events } from "@dcl/schemas/dist/platform/events/base"
 import {
   WorldScenesUndeploymentEvent,
   WorldSettingsChangedEvent,
+  WorldUndeploymentEvent,
 } from "@dcl/schemas/dist/platform/events/world"
 import { SQS } from "aws-sdk"
 import logger from "decentraland-gatsby/dist/entities/Development/logger"
@@ -22,6 +23,7 @@ export type WorldSqsMessage =
   | DeploymentToSqs
   | WorldSettingsChangedEvent
   | WorldScenesUndeploymentEvent
+  | WorldUndeploymentEvent
 
 /** Type guard to check if message is a deployment event */
 export function isDeploymentEvent(
@@ -42,8 +44,8 @@ export function isSettingsChangedEvent(
   )
 }
 
-/** Type guard to check if message is an undeployment event */
-export function isUndeploymentEvent(
+/** Type guard to check if message is a scene undeployment event */
+export function isScenesUndeploymentEvent(
   message: WorldSqsMessage
 ): message is WorldScenesUndeploymentEvent {
   return (
@@ -54,6 +56,18 @@ export function isUndeploymentEvent(
   )
 }
 
+/** Type guard to check if message is a full world undeployment event */
+export function isWorldUndeploymentEvent(
+  message: WorldSqsMessage
+): message is WorldUndeploymentEvent {
+  return (
+    "type" in message &&
+    message.type === Events.Type.WORLD &&
+    "subType" in message &&
+    message.subType === Events.SubType.Worlds.WORLD_UNDEPLOYMENT
+  )
+}
+
 export interface TaskQueueMessage {
   id: string
 }
@@ -136,10 +150,14 @@ export class SQSConsumer {
               errorContext = `<${body.contentServerUrls}/contents/${body.entity.entityId}|${body.entity.entityId}>`
             } else if (isSettingsChangedEvent(body)) {
               errorContext = `WorldSettingsChanged: ${body.key}`
-            } else if (isUndeploymentEvent(body)) {
+            } else if (isScenesUndeploymentEvent(body)) {
               errorContext = `WorldScenesUndeployment: ${
                 body.key
-              } - entityIds: ${body.metadata.entityIds.join(", ")}`
+              } - scenes: ${body.metadata.scenes
+                .map((s) => s.entityId)
+                .join(", ")}`
+            } else if (isWorldUndeploymentEvent(body)) {
+              errorContext = `WorldUndeployment: ${body.metadata.worldName}`
             }
 
             notifyError([err.toString(), errorContext])

src/entities/CheckScenes/task/consumer.ts

@@ -0,0 +1,66 @@
+import { WorldScenesUndeploymentEvent } from "@dcl/schemas/dist/platform/events/world"
+import logger from "decentraland-gatsby/dist/entities/Development/logger"
+
+import PlaceModel from "../../Place/model"
+import { notifyError } from "../../Slack/utils"
+
+/**
+ * Handles WorldScenesUndeploymentEvent from the worlds content server.
+ * Deletes the place records corresponding to the undeployed scenes,
+ * identified by world name and each scene's base parcel.
+ */
+export async function handleWorldScenesUndeployment(
+  event: WorldScenesUndeploymentEvent
+): Promise<void> {
+  const worldName = event.metadata.worldName
+
+  if (!worldName) {
+    logger.error("WorldScenesUndeploymentEvent missing world name")
+    return
+  }
+
+  const { scenes } = event.metadata
+
+  if (!scenes || scenes.length === 0) {
+    logger.error("WorldScenesUndeploymentEvent has no scenes")
+    return
+  }
+
+  const loggerExtended = logger.extend({
+    worldName,
+    sceneCount: scenes.length,
+    eventType: "WorldScenesUndeploymentEvent",
+  })
+
+  try {
+    const basePositions = scenes.map((scene) => scene.baseParcel)
+
+    loggerExtended.log(
+      `Processing scene undeployment for world: ${worldName}, parcels: ${basePositions.join(
+        ", "
+      )}`
+    )
+
+    await PlaceModel.deleteByWorldIdAndPositions(
+      worldName,
+      basePositions,
+      event.timestamp
+    )
+
+    loggerExtended.log(
+      `Deleted place records for world: ${worldName} at positions: ${basePositions.join(
+        ", "
+      )}`
+    )
+  } catch (error: any) {
+    loggerExtended.error(
+      `Error handling WorldScenesUndeploymentEvent for ${worldName}: ${error.message}`
+    )
+    notifyError([
+      `Error handling WorldScenesUndeploymentEvent`,
+      `World: ${worldName}`,
+      error.message,
+    ])
+    throw error
+  }
+}

src/entities/CheckScenes/task/handleWorldScenesUndeployment.ts

@@ -0,0 +1,45 @@
+import { WorldUndeploymentEvent } from "@dcl/schemas/dist/platform/events/world"
+import logger from "decentraland-gatsby/dist/entities/Development/logger"
+
+import PlaceModel from "../../Place/model"
+import { notifyError } from "../../Slack/utils"
+
+/**
+ * Handles WorldUndeploymentEvent from the worlds content server.
+ * Deletes all place records associated with the undeployed world.
+ * The world entity itself is not deleted -- it simply won't appear
+ * in queries once it has no associated places.
+ */
+export async function handleWorldUndeployment(
+  event: WorldUndeploymentEvent
+): Promise<void> {
+  const worldName = event.metadata.worldName
+
+  if (!worldName) {
+    logger.error("WorldUndeploymentEvent missing world name")
+    return
+  }
+
+  const loggerExtended = logger.extend({
+    worldName,
+    eventType: "WorldUndeploymentEvent",
+  })
+
+  try {
+    loggerExtended.log(`Processing world undeployment for world: ${worldName}`)
+
+    await PlaceModel.deleteByWorldId(worldName, event.timestamp)
+
+    loggerExtended.log(`Deleted all place records for world: ${worldName}`)
+  } catch (error: any) {
+    loggerExtended.error(
+      `Error handling WorldUndeploymentEvent for ${worldName}: ${error.message}`
+    )
+    notifyError([
+      `Error handling WorldUndeploymentEvent`,
+      `World: ${worldName}`,
+      error.message,
+    ])
+    throw error
+  }
+}

src/entities/CheckScenes/task/handleWorldUndeployment.ts

@@ -3,9 +3,13 @@ import logger from "decentraland-gatsby/dist/entities/Development/logger"
 import {
   WorldSqsMessage,
   isDeploymentEvent,
+  isScenesUndeploymentEvent,
   isSettingsChangedEvent,
+  isWorldUndeploymentEvent,
 } from "./consumer"
+import { handleWorldScenesUndeployment } from "./handleWorldScenesUndeployment"
 import { handleWorldSettingsChanged } from "./handleWorldSettingsChanged"
+import { handleWorldUndeployment } from "./handleWorldUndeployment"
 import { taskRunnerSqs } from "./taskRunnerSqs"
 
 /**
@@ -20,6 +24,20 @@ export async function taskRunnerDispatcher(
     return handleWorldSettingsChanged(message)
   }
 
+  if (isWorldUndeploymentEvent(message)) {
+    logger.log(
+      `Processing WorldUndeploymentEvent for world: ${message.metadata.worldName}`
+    )
+    return handleWorldUndeployment(message)
+  }
+
+  if (isScenesUndeploymentEvent(message)) {
+    logger.log(
+      `Processing WorldScenesUndeploymentEvent for world: ${message.metadata.worldName}`
+    )
+    return handleWorldScenesUndeployment(message)
+  }
+
   if (isDeploymentEvent(message)) {
     logger.log(
       `Processing DeploymentEvent for entity: ${message.entity.entityId}`

src/entities/CheckScenes/task/taskRunnerDispatcher.ts

@@ -469,6 +469,48 @@ export default class PlaceModel extends Model<PlaceAttributes> {
     )
   }
 
+  /**
+   * Delete all place records associated with a world that were deployed
+   * before the given event timestamp. This prevents stale undeployment
+   * events from removing places that were re-deployed after the event
+   * was emitted.
+   */
+  static async deleteByWorldId(
+    worldId: string,
+    eventTimestamp: number
+  ): Promise<void> {
+    const normalizedWorldId = worldId.toLowerCase()
+    const eventDate = new Date(eventTimestamp)
+    const sql = SQL`
+      DELETE FROM ${table(this)}
+      WHERE "world_id" = ${normalizedWorldId}
+        AND "deployed_at" < ${eventDate}
+    `
+    await this.namedQuery("delete_by_world_id", sql)
+  }
+
+  /**
+   * Delete place records matching a world and specific base positions
+   * that were deployed before the given event timestamp. This prevents
+   * stale undeployment events from removing places that were re-deployed
+   * after the event was emitted.
+   */
+  static async deleteByWorldIdAndPositions(
+    worldId: string,
+    basePositions: string[],
+    eventTimestamp: number
+  ): Promise<void> {
+    const normalizedWorldId = worldId.toLowerCase()
+    const eventDate = new Date(eventTimestamp)
+    const sql = SQL`
+      DELETE FROM ${table(this)}
+      WHERE "world_id" = ${normalizedWorldId}
+        AND "base_position" = ANY(${basePositions})
+        AND "deployed_at" < ${eventDate}
+    `
+    await this.namedQuery("delete_by_world_id_and_positions", sql)
+  }
+
   static async updateFavorites(placeId: string) {
     const sql = buildUpdateFavoritesQuery(this, placeId)
     return this.namedQuery("update_favorites", sql)

src/entities/Place/model.ts

@@ -205,6 +205,7 @@ export default class WorldModel extends Model<WorldAttributes> {
         ${conditional(!!options.disabled, SQL`AND w.disabled IS TRUE`)}
         ${conditional(!options.disabled, SQL`AND w.disabled IS FALSE`)}
         AND w.show_in_places IS TRUE
+        AND EXISTS (SELECT 1 FROM places p WHERE p.world_id = w.id)
         ${conditional(
           options.names.length > 0,
           SQL`AND w.id = ANY(${options.names.map((name) =>
@@ -272,6 +273,7 @@ export default class WorldModel extends Model<WorldAttributes> {
         ${conditional(!!options.disabled, SQL`AND w.disabled IS TRUE`)}
         ${conditional(!options.disabled, SQL`AND w.disabled IS FALSE`)}
         AND w.show_in_places IS TRUE
+        AND EXISTS (SELECT 1 FROM places p WHERE p.world_id = w.id)
         ${conditional(
           options.names.length > 0,
           SQL`AND w.id = ANY(${options.names.map((name) =>

src/entities/World/model.ts

@@ -0,0 +1,43 @@
+import { Events } from "@dcl/schemas/dist/platform/events/base"
+import {
+  WorldScenesUndeploymentEvent,
+  WorldUndeploymentEvent,
+} from "@dcl/schemas/dist/platform/events/world"
+
+/**
+ * Creates a WorldUndeploymentEvent for a full world undeployment.
+ */
+export function createWorldUndeploymentEvent(
+  worldName: string,
+  options: { timestamp?: number } = {}
+): WorldUndeploymentEvent {
+  return {
+    type: Events.Type.WORLD,
+    subType: Events.SubType.Worlds.WORLD_UNDEPLOYMENT,
+    key: worldName,
+    timestamp: options.timestamp ?? Date.now(),
+    metadata: {
+      worldName,
+    },
+  }
+}
+
+/**
+ * Creates a WorldScenesUndeploymentEvent for undeploying specific scenes.
+ */
+export function createWorldScenesUndeploymentEvent(
+  worldName: string,
+  scenes: Array<{ entityId: string; baseParcel: string }>,
+  options: { timestamp?: number } = {}
+): WorldScenesUndeploymentEvent {
+  return {
+    type: Events.Type.WORLD,
+    subType: Events.SubType.Worlds.WORLD_SCENES_UNDEPLOYMENT,
+    key: worldName,
+    timestamp: options.timestamp ?? Date.now(),
+    metadata: {
+      worldName,
+      scenes,
+    },
+  }
+}