fix: Delete widgets when a dashboard is removed

Author: pnrgenc

CHANGELOG.md

@@ -2,6 +2,7 @@
 Fixes:
 - [core] Fix user analytics widget chart
 - [core] Fix mongo connection url parsing
+- [dashboards] Delete associated widgets and reports when a dashboard is removed
 
 ## Version 25.03.10
 Enterprise Fixes:

bin/scripts/fix-data/delete_widgets_of_deleted_dashboards.js

@@ -0,0 +1,106 @@
+/**
+ *  Description : Remove orphan widget and long_tasks records left behind after a dashboard is deleted
+ *  Server  : countly
+ *  Path    : $(countly dir)/bin/scripts/fix-data
+ *  Command : node delete_widgets_of_deleted_dashboards.js [--dry-run]
+ *  Usage   :
+ *      # Preview only
+ *      node delete_widgets_of_deleted_dashboards.js --dry-run
+ *      # Actual deletion
+ *      node delete_widgets_of_deleted_dashboards.js
+ */
+const DRY_RUN = process.argv.includes('--dry-run');
+
+const BATCH_SIZE = 1000;
+const pluginManager = require('../../../plugins/pluginManager.js');
+
+/**
+ * Deletes documents in batches to avoid oversized commands
+ * @param {Object} db - MongoDB connection
+ * @param {String} collection - Collection name
+ * @param {Array} ids - List of document ids to delete
+ */
+async function deleteByChunks(db, collection, ids) {
+    let bucket = [];
+
+    for (const id of ids) {
+        bucket.push(id);
+
+        if (bucket.length === BATCH_SIZE) {
+            await runDelete(bucket);
+            bucket = [];
+        }
+    }
+
+    if (bucket.length) {
+        await runDelete(bucket);
+    }
+
+    /**
+     * Executes the delete operation for a batch of ids
+     * @param {Array} batch - Array of document ids to delete
+     * @returns {Promise<void>}
+     * */
+    async function runDelete(batch) {
+        if (DRY_RUN) {
+            console.log(`[dry-run] ${collection}: would delete ${batch.length}`);
+        }
+        else {
+            const res = await db.collection(collection).deleteMany({ _id: { $in: batch } });
+            console.log(`[deleted] ${collection}: ${res.deletedCount}`);
+        }
+    }
+}
+
+(async() => {
+    const db = await pluginManager.dbConnection('countly');
+
+    try {
+        const dashboardWidgets = [];
+
+        const dashCursor = db.collection('dashboards').find({widgets: {$exists: true, $not: {$size: 0}}}, {projection: {widgets: 1}});
+
+        while (await dashCursor.hasNext()) {
+            const dash = await dashCursor.next();
+            for (const w of dash.widgets) {
+                const idStr = (w && w.$oid) ? w.$oid : (w + '');
+                if (idStr && !dashboardWidgets.includes(idStr)) {
+                    dashboardWidgets.push(idStr);
+                }
+            }
+        }
+
+        await dashCursor.close();
+
+        const orphanWidgetIds = [];
+        const orphanLongTaskIds = [];
+
+        const widgetCursor = db.collection('widgets').find({}, {projection: {_id: 1, drill_report: 1}});
+
+        while (await widgetCursor.hasNext()) {
+            const w = await widgetCursor.next();
+            if (!dashboardWidgets.includes(String(w._id))) {
+                orphanWidgetIds.push(w._id);
+                if (Array.isArray(w.drill_report)) {
+                    orphanLongTaskIds.push(...w.drill_report);
+                }
+            }
+        }
+        await widgetCursor.close();
+
+        console.log(`Orphan widgets found: ${orphanWidgetIds.length}`);
+        console.log(`Linked long_tasks to drop: ${orphanLongTaskIds.length}`);
+
+        await deleteByChunks(db, 'widgets', orphanWidgetIds);
+        await deleteByChunks(db, 'long_tasks', orphanLongTaskIds);
+
+
+        console.log(DRY_RUN ? 'Dry-run finished' : 'Cleanup completed.');
+    }
+    catch (err) {
+        console.error(err);
+    }
+    finally {
+        db.close();
+    }
+})();

plugins/dashboards/api/api.js

@@ -1093,30 +1093,53 @@ plugins.setConfigs("dashboards", {
                 filterCond.owner_id = memberId;
             }
 
-            common.db.collection("dashboards").findOne({_id: common.db.ObjectID(dashboardId)}, function(err, dashboard) {
+            common.db.collection("dashboards").findOne({_id: common.db.ObjectID(dashboardId)}, async function(err, dashboard) {
                 if (err || !dashboard) {
                     common.returnMessage(params, 400, "Dashboard with the given id doesn't exist");
                 }
                 else {
-                    hasViewAccessToDashboard(params.member, dashboard, function(er, status) {
+                    hasViewAccessToDashboard(params.member, dashboard, async function(er, status) {
                         if (er || !status) {
                             return common.returnOutput(params, {error: true, dashboard_access_denied: true});
                         }
 
-                        common.db.collection("dashboards").remove(
-                            filterCond,
-                            function(error, result) {
-                                if (!error && result) {
-                                    if (result && result.result && result.result.n === 1) {
-                                        plugins.dispatch("/systemlogs", {params: params, action: "dashboard_deleted", data: dashboard});
+                        try {
+                            // Remove the dashboard
+                            const result = await common.db.collection("dashboards").deleteOne(filterCond);
+
+                            if (result && result.deletedCount > 0) {
+                                // Collect widget IDs from the dashboard
+                                const widgetIds = (dashboard.widgets || []).map(w => common.db.ObjectID(w.$oid || w));
+
+                                // Delete widgets from the widgets collection
+                                if (widgetIds.length) {
+                                    const widgets = await common.db.collection("widgets").find({_id: {$in: widgetIds}}).toArray();
+                                    const drillReportIds = widgets.reduce((acc, widget) => {
+                                        if (Array.isArray(widget.drill_report)) {
+                                            acc.push(...widget.drill_report);
+                                        }
+                                        return acc;
+                                    }, []);
+
+                                    await common.db.collection("widgets").deleteMany({_id: {$in: widgetIds}});
+
+                                    // Delete drill_reports from the long_tasks collection
+                                    if (drillReportIds.length) {
+                                        await common.db.collection("long_tasks").deleteMany({_id: {$in: drillReportIds}});
                                     }
-                                    common.returnOutput(params, result);
-                                }
-                                else {
-                                    common.returnMessage(params, 500, "Failed to delete dashboard");
                                 }
+
+                                plugins.dispatch("/systemlogs", {params: params, action: "dashboard_deleted", data: dashboard});
+                                common.returnOutput(params, result);
                             }
-                        );
+                            else {
+                                common.returnMessage(params, 500, "Failed to delete dashboard");
+                            }
+                        }
+                        catch (error) {
+                            console.error("Error during dashboard deletion:", error);
+                            common.returnMessage(params, 500, "An error occurred while deleting the dashboard");
+                        }
                     });
                 }
             });