feat(soft-delete): add soft delete for charts, dashboards, and datasets

AGENTS.md

@@ -267,3 +267,7 @@ pre-commit run eslint            # Frontend linting
 ---
 
 **LLM Note**: This codebase is actively modernizing toward full TypeScript and type safety. Always run `pre-commit run` to validate changes. Follow the ongoing refactors section to avoid deprecated patterns.
+
+# Agent Rules <!-- tessl-managed -->
+
+@.tessl/RULES.md follow the [instructions](.tessl/RULES.md)

UPDATING.md

@@ -38,6 +38,41 @@ When the feature flag is enabled, these permissions are enforced on both the fro
 
 **Migration behavior:** All three new permissions are granted to every role that currently has `can_csv`, preserving existing access. Admins can then selectively revoke individual export permissions from specific roles as needed.
 
+### Soft delete for Charts, Dashboards, and Datasets
+
+DELETE API endpoints for charts, dashboards, and datasets now perform **soft delete** — setting a `deleted_at` timestamp instead of removing the row from the database. Soft-deleted objects are automatically excluded from all standard API responses and UI views.
+
+**What changed:**
+- `DELETE /api/v1/chart/<pk>`, `DELETE /api/v1/dashboard/<pk>`, `DELETE /api/v1/dataset/<pk>` now set `deleted_at` instead of removing the row
+- Bulk delete endpoints follow the same behaviour
+- New `POST /api/v1/{chart,dashboard,dataset}/<pk>/restore` endpoints allow restoring soft-deleted objects
+- No cascade: soft-deleting a dashboard or dataset does NOT cascade to dependent charts
+
+**Impact on external integrations:**
+- API callers see no change in request/response format — same endpoints, same status codes
+- External tooling that queries the database directly (bypassing the API) may see "deleted" rows that are still present with `deleted_at IS NOT NULL`
+- The import/export pipeline uses `skip_visibility_filter` to handle soft-deleted rows during re-import
+
+### Listing soft-deleted items per entity
+
+The chart, dashboard, and dataset list endpoints accept a rison filter that surfaces soft-deleted rows. Use it as part of the standard `q=(filters:!((...)))` envelope.
+
+| Entity | Filter `opr` |
+|---|---|
+| `/api/v1/chart/` | `chart_deleted_state` |
+| `/api/v1/dashboard/` | `dashboard_deleted_state` |
+| `/api/v1/dataset/` | `dataset_deleted_state` |
+
+Values:
+
+- `include` — return live rows plus soft-deleted rows
+- `only` — return only soft-deleted rows
+- absent / any other value — default behaviour (live rows only)
+
+Example: `GET /api/v1/chart/?q=(filters:!((col:id,opr:chart_deleted_state,value:only)),order_column:changed_on,order_direction:desc,page:0,page_size:25)`
+
+When the filter is applied, list responses augment each row with a `deleted_at` ISO-8601 timestamp (null for live rows). Row-level access mirrors the standard list endpoints — only the soft-delete visibility filter is bypassed.
+
 ### Deck.gl MapBox viewport and opacity controls are functional
 
 The Deck.gl MapBox chart's **Opacity**, **Default longitude**, **Default latitude**, and **Zoom** controls were previously non-functional — changing them had no effect on the rendered map. These controls are now wired up correctly.

superset/charts/api.py

@@ -35,6 +35,7 @@
     ChartAllTextFilter,
     ChartCertifiedFilter,
     ChartCreatedByMeFilter,
+    ChartDeletedStateFilter,
     ChartFavoriteFilter,
     ChartFilter,
     ChartHasCreatedByFilter,
@@ -63,12 +64,14 @@
     ChartForbiddenError,
     ChartInvalidError,
     ChartNotFoundError,
+    ChartRestoreFailedError,
     ChartUpdateFailedError,
     DashboardsForbiddenError,
 )
 from superset.commands.chart.export import ExportChartsCommand
 from superset.commands.chart.fave import AddFavoriteChartCommand
 from superset.commands.chart.importers.dispatcher import ImportChartsCommand
+from superset.commands.chart.restore import RestoreChartCommand
 from superset.commands.chart.unfave import DelFavoriteChartCommand
 from superset.commands.chart.update import UpdateChartCommand
 from superset.commands.chart.warm_up_cache import ChartWarmUpCacheCommand
@@ -122,6 +125,7 @@ def ensure_thumbnails_enabled(self) -> Optional[Response]:
         RouteMethod.IMPORT,
         RouteMethod.RELATED,
         "bulk_delete",  # not using RouteMethod since locally defined
+        "restore",
         "viz_types",
         "favorite_status",
         "add_favorite",
@@ -220,6 +224,7 @@ def ensure_thumbnails_enabled(self) -> Optional[Response]:
         "id": [
             ChartFavoriteFilter,
             ChartCertifiedFilter,
+            ChartDeletedStateFilter,
             ChartOwnedCreatedFavoredByMeFilter,
         ],
         "slice_name": [ChartAllTextFilter],
@@ -568,6 +573,62 @@ def bulk_delete(self, **kwargs: Any) -> Response:
         except ChartDeleteFailedError as ex:
             return self.response_422(message=str(ex))
 
+    @expose("/<uuid>/restore", methods=("POST",))
+    @protect()
+    @safe
+    @statsd_metrics
+    @event_logger.log_this_with_context(
+        action=lambda self, *args, **kwargs: f"{self.__class__.__name__}.restore",
+        log_to_statsd=False,
+    )
+    def restore(self, uuid: str) -> Response:
+        """Restore a soft-deleted chart.
+        ---
+        post:
+          summary: Restore a soft-deleted chart
+          parameters:
+          - in: path
+            schema:
+              type: string
+              format: uuid
+            name: uuid
+          responses:
+            200:
+              description: Chart restored
+              content:
+                application/json:
+                  schema:
+                    type: object
+                    properties:
+                      message:
+                        type: string
+            401:
+              $ref: '#/components/responses/401'
+            403:
+              $ref: '#/components/responses/403'
+            404:
+              $ref: '#/components/responses/404'
+            422:
+              $ref: '#/components/responses/422'
+            500:
+              $ref: '#/components/responses/500'
+        """
+        try:
+            RestoreChartCommand(uuid).run()
+            return self.response(200, message="OK")
+        except ChartNotFoundError:
+            return self.response_404()
+        except ChartForbiddenError:
+            return self.response_403()
+        except ChartRestoreFailedError as ex:
+            logger.error(
+                "Error restoring model %s: %s",
+                self.__class__.__name__,
+                str(ex),
+                exc_info=True,
+            )
+            return self.response_422(message=str(ex))
+
     @expose("/<pk>/cache_screenshot/", methods=("GET",))
     @protect()
     @parse_rison(screenshot_query_schema)

superset/charts/filters.py

@@ -31,6 +31,7 @@
 from superset.utils.filters import get_dataset_access_filters
 from superset.views.base import BaseFilter
 from superset.views.base_api import BaseFavoriteFilter
+from superset.views.filters import BaseDeletedStateFilter
 
 
 class ChartAllTextFilter(BaseFilter):  # pylint: disable=too-few-public-methods
@@ -180,3 +181,10 @@ def apply(self, query: Query, value: Any) -> Query:
                 FavStar.user_id == get_user_id(),
             )
         )
+
+
+class ChartDeletedStateFilter(BaseDeletedStateFilter):  # pylint: disable=too-few-public-methods
+    """Rison filter for the GET list that exposes soft-deleted charts."""
+
+    arg_name = "chart_deleted_state"
+    model = Slice

superset/commands/chart/delete.py

@@ -46,6 +46,7 @@ def __init__(self, model_ids: list[int]):
     def run(self) -> None:
         self.validate()
         assert self._models
+
         ChartDAO.delete(self._models)
 
     def validate(self) -> None:

superset/commands/chart/exceptions.py

@@ -123,6 +123,10 @@ class ChartDeleteFailedError(DeleteFailedError):
     message = _("Charts could not be deleted.")
 
 
+class ChartRestoreFailedError(CommandException):
+    message = _("Chart could not be restored.")
+
+
 class ChartDeleteFailedReportsExistError(ChartDeleteFailedError):
     message = _("There are associated alerts or reports")
 

superset/commands/chart/importers/v1/utils.py

@@ -49,9 +49,11 @@ def import_chart(
     ignore_permissions: bool = False,
 ) -> Slice:
     can_write = ignore_permissions or security_manager.can_access("can_write", "Chart")
-    existing = db.session.query(Slice).filter_by(uuid=config["uuid"]).first()
+    from superset.commands.importers.v1.utils import find_existing_for_import
+
     user = get_user()
-    if existing:
+
+    if existing := find_existing_for_import(Slice, config["uuid"]):
         if overwrite and can_write and user:
             if not security_manager.can_access_chart(existing) or (
                 user not in existing.owners and not security_manager.is_admin()

superset/commands/chart/restore.py

@@ -0,0 +1,44 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+"""Command to restore a soft-deleted chart."""
+
+import logging
+from functools import partial
+
+from superset.commands.chart.exceptions import (
+    ChartForbiddenError,
+    ChartNotFoundError,
+    ChartRestoreFailedError,
+)
+from superset.commands.restore import BaseRestoreCommand
+from superset.daos.chart import ChartDAO
+from superset.models.slice import Slice
+from superset.utils.decorators import on_error, transaction
+
+logger = logging.getLogger(__name__)
+
+
+class RestoreChartCommand(BaseRestoreCommand[Slice]):
+    """Restore a soft-deleted chart by clearing its ``deleted_at`` field."""
+
+    dao = ChartDAO
+    not_found_exc = ChartNotFoundError
+    forbidden_exc = ChartForbiddenError
+
+    @transaction(on_error=partial(on_error, reraise=ChartRestoreFailedError))
+    def run(self) -> None:
+        super().run()

superset/commands/dashboard/exceptions.py

@@ -20,6 +20,7 @@
 from marshmallow.validate import ValidationError
 
 from superset.commands.exceptions import (
+    CommandException,
     CommandInvalidError,
     CreateFailedError,
     DeleteFailedError,
@@ -70,6 +71,10 @@ class DashboardColorsConfigUpdateFailedError(UpdateFailedError):
     message = _("Dashboard color configuration could not be updated.")
 
 
+class DashboardRestoreFailedError(CommandException):
+    message = _("Dashboard could not be restored.")
+
+
 class DashboardDeleteFailedError(DeleteFailedError):
     message = _("Dashboard could not be deleted.")
 

superset/commands/dashboard/importers/v1/utils.py

@@ -200,9 +200,11 @@ def import_dashboard(  # noqa: C901
         "can_write",
         "Dashboard",
     )
-    existing = db.session.query(Dashboard).filter_by(uuid=config["uuid"]).first()
+    from superset.commands.importers.v1.utils import find_existing_for_import
+
     user = get_user()
-    if existing:
+
+    if existing := find_existing_for_import(Dashboard, config["uuid"]):
         if overwrite and can_write and user:
             if not security_manager.can_access_dashboard(existing) or (
                 user not in existing.owners and not security_manager.is_admin()

superset/commands/dashboard/restore.py

@@ -0,0 +1,44 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+"""Command to restore a soft-deleted dashboard."""
+
+import logging
+from functools import partial
+
+from superset.commands.dashboard.exceptions import (
+    DashboardForbiddenError,
+    DashboardNotFoundError,
+    DashboardRestoreFailedError,
+)
+from superset.commands.restore import BaseRestoreCommand
+from superset.daos.dashboard import DashboardDAO
+from superset.models.dashboard import Dashboard
+from superset.utils.decorators import on_error, transaction
+
+logger = logging.getLogger(__name__)
+
+
+class RestoreDashboardCommand(BaseRestoreCommand[Dashboard]):
+    """Restore a soft-deleted dashboard by clearing its ``deleted_at`` field."""
+
+    dao = DashboardDAO
+    not_found_exc = DashboardNotFoundError
+    forbidden_exc = DashboardForbiddenError
+
+    @transaction(on_error=partial(on_error, reraise=DashboardRestoreFailedError))
+    def run(self) -> None:
+        super().run()

superset/commands/dataset/exceptions.py

@@ -170,6 +170,10 @@ class DatasetUpdateFailedError(UpdateFailedError):
     message = _("Dataset could not be updated.")
 
 
+class DatasetRestoreFailedError(CommandException):
+    message = _("Dataset could not be restored.")
+
+
 class DatasetDeleteFailedError(DeleteFailedError):
     message = _("Datasets could not be deleted.")
 

superset/commands/dataset/importers/v1/utils.py

@@ -112,9 +112,11 @@ def import_dataset(  # noqa: C901
         "can_write",
         "Dataset",
     )
-    existing = db.session.query(SqlaTable).filter_by(uuid=config["uuid"]).first()
+    from superset.commands.importers.v1.utils import find_existing_for_import
+
     user = get_user()
-    if existing:
+
+    if existing := find_existing_for_import(SqlaTable, config["uuid"]):
         if overwrite and can_write and user:
             if user not in existing.owners and not security_manager.is_admin():
                 raise ImportFailedError(

superset/commands/dataset/restore.py

@@ -0,0 +1,44 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+"""Command to restore a soft-deleted dataset."""
+
+import logging
+from functools import partial
+
+from superset.commands.dataset.exceptions import (
+    DatasetForbiddenError,
+    DatasetNotFoundError,
+    DatasetRestoreFailedError,
+)
+from superset.commands.restore import BaseRestoreCommand
+from superset.connectors.sqla.models import SqlaTable
+from superset.daos.dataset import DatasetDAO
+from superset.utils.decorators import on_error, transaction
+
+logger = logging.getLogger(__name__)
+
+
+class RestoreDatasetCommand(BaseRestoreCommand[SqlaTable]):
+    """Restore a soft-deleted dataset by clearing its ``deleted_at`` field."""
+
+    dao = DatasetDAO
+    not_found_exc = DatasetNotFoundError
+    forbidden_exc = DatasetForbiddenError
+
+    @transaction(on_error=partial(on_error, reraise=DatasetRestoreFailedError))
+    def run(self) -> None:
+        super().run()