Skip to content

ServerKit is a lightweight, modern server control panel for managing web applications, databases, and services on your VPS or dedicated server. Built with Python/Flask backend and React frontend.

feat(databases): ManagedDatabase adopts SoftDelete into the Recycle Bin (plan 77 B5)

Juan Denisf237d4f3b4da
diff --git a/backend/app/api/apps.py b/backend/app/api/apps.py
index 7a9d115c..6f663647 100644
--- a/backend/app/api/apps.py
+++ b/backend/app/api/apps.py
@@ -2043,7 +2043,7 @@ def get_app_related(app_id):
from app.models.managed_database import ManagedDatabase
related['databases'] = [
{'id': m.id, 'name': m.name, 'engine': getattr(m, 'engine', '')}
- for m in ManagedDatabase.query.filter_by(owner_application_id=app.id).all()
+ for m in ManagedDatabase.query_active().filter_by(owner_application_id=app.id).all()
]
except Exception:
current_app.logger.warning('related: databases failed', exc_info=True)
diff --git a/backend/app/api/databases.py b/backend/app/api/databases.py
index 5b61df52..63084906 100644
--- a/backend/app/api/databases.py
+++ b/backend/app/api/databases.py
@@ -855,7 +855,8 @@ def delete_managed_database(managed_id):
if not managed:
return jsonify({'error': 'Managed database not found'}), 404
drop = str(request.args.get('drop', '')).lower() in ('1', 'true', 'yes')
- ManagedDatabaseService.delete(managed, drop=drop)
+ from flask_jwt_extended import get_jwt_identity
+ ManagedDatabaseService.delete(managed, drop=drop, user_id=get_jwt_identity())
return jsonify({'success': True, 'dropped': drop}), 200
diff --git a/backend/app/api/shared_resources.py b/backend/app/api/shared_resources.py
index 36a07190..6f5eeb3f 100644
--- a/backend/app/api/shared_resources.py
+++ b/backend/app/api/shared_resources.py
@@ -148,7 +148,7 @@ def _check_resource_write(resource_type, resource_id):
if resource_type == 'database':
from app.models.managed_database import ManagedDatabase
try:
- row = ManagedDatabase.query.get(int(resource_id))
+ row = ManagedDatabase.query_active().filter_by(id=int(resource_id)).first()
except (TypeError, ValueError):
row = None
if row is None:
diff --git a/backend/app/models/managed_database.py b/backend/app/models/managed_database.py
index b4ae8f6b..3dbf405b 100644
--- a/backend/app/models/managed_database.py
+++ b/backend/app/models/managed_database.py
@@ -1,13 +1,13 @@
from datetime import datetime
from app import db
-from app.models.mixins import EncryptedSecret
+from app.models.mixins import EncryptedSecret, SoftDeleteMixin
# Engines whose lifecycle ServerKit actually drives (Mongo stays read-first).
VALID_DB_ENGINES = ('mysql', 'postgresql', 'mongodb')
-class ManagedDatabase(db.Model):
+class ManagedDatabase(SoftDeleteMixin, db.Model):
"""A database ServerKit tracks as a first-class resource.
Adds durable state (backups, connection strings, ownership) **beside** the
@@ -18,6 +18,12 @@ class ManagedDatabase(db.Model):
The admin secret is Fernet-encrypted at rest (same helper as
``SourceConnection``); it is masked in API responses and revealed only through
an explicit, audited action.
+
+ Soft-deletable (plan 77 B5): a plain delete tombstones the row into the
+ Recycle Bin — the actual database server-side is untouched and any managed
+ backup policy keeps running, so restore brings everything back intact. The
+ explicit ``?drop=true`` path stays immediately destructive. Read paths use
+ ``query_active()``.
"""
__tablename__ = 'managed_databases'
diff --git a/backend/app/services/backup_policy_service.py b/backend/app/services/backup_policy_service.py
index e7c10f9d..3c998f51 100644
--- a/backend/app/services/backup_policy_service.py
+++ b/backend/app/services/backup_policy_service.py
@@ -232,6 +232,9 @@ class BackupPolicyService:
if meta.get('managed'):
from app.models.managed_database import ManagedDatabase
from app.services.managed_database_service import ManagedDatabaseService
+ # Deliberately tombstone-blind: a soft-deleted managed DB
+ # keeps its backup policy running until PURGE, so the data
+ # stays recoverable for the whole Recycle Bin window.
managed = ManagedDatabase.query.get(policy.target_id)
if managed is None:
raise BackupPolicyError('Managed database is no longer tracked')
diff --git a/backend/app/services/env_reference_service.py b/backend/app/services/env_reference_service.py
index 38996236..3b4bb8de 100644
--- a/backend/app/services/env_reference_service.py
+++ b/backend/app/services/env_reference_service.py
@@ -104,7 +104,7 @@ class EnvReferenceResolver:
# db sibling first (ManagedDatabase by name within the workspace)
from app.models.managed_database import ManagedDatabase
- managed = ManagedDatabase.query.filter_by(name=service_name).first()
+ managed = ManagedDatabase.query_active().filter_by(name=service_name).first()
if managed is not None:
return cls._db_property(managed, prop)
diff --git a/backend/app/services/managed_database_service.py b/backend/app/services/managed_database_service.py
index 4edc09e6..c9e2101f 100644
--- a/backend/app/services/managed_database_service.py
+++ b/backend/app/services/managed_database_service.py
@@ -37,7 +37,7 @@ class ManagedDatabaseService:
ServerKit already provisioned never downgrades its origin."""
engine = (engine or '').strip().lower()
host = (host or 'localhost').strip() or 'localhost'
- managed = ManagedDatabase.query.filter_by(engine=engine, host=host, name=name).first()
+ managed = ManagedDatabase.query_active().filter_by(engine=engine, host=host, name=name).first()
created = managed is None
if created:
managed = ManagedDatabase(engine=engine, name=name, host=host, origin=origin)
@@ -75,7 +75,7 @@ class ManagedDatabaseService:
@classmethod
def list(cls, workspace_id=None):
- q = ManagedDatabase.query
+ q = ManagedDatabase.query_active()
if workspace_id is not None:
q = q.filter(db.or_(
ManagedDatabase.workspace_id == workspace_id,
@@ -87,22 +87,33 @@ class ManagedDatabaseService:
def get(cls, managed_id):
if not managed_id:
return None
- return ManagedDatabase.query.get(managed_id)
+ return ManagedDatabase.query_active().filter_by(id=managed_id).first()
@classmethod
- def delete(cls, managed, drop=False):
- """Untrack a managed database. With ``drop=True`` also DROP it on the
- server (host engines only). Any managed BackupPolicy pointing at it is
- removed so no policy is left dangling."""
- if drop and managed.host_kind == 'host':
- if managed.engine == 'mysql':
- DatabaseService.mysql_drop_database(managed.name)
- elif managed.engine == 'postgresql':
- DatabaseService.pg_drop_database(managed.name)
- # mongodb drop is out of scope (read-first); untrack only.
-
- cls._delete_managed_policy(managed)
- db.session.delete(managed)
+ def delete(cls, managed, drop=False, user_id=None):
+ """Delete a managed database (plan 77 B5, plan-70 semantics).
+
+ - ``drop=False``: SOFT delete — the row tombstones into the Recycle
+ Bin. The actual database on the server is untouched and any managed
+ BackupPolicy keeps running, so a restore brings everything back
+ intact.
+ - ``drop=True``: the operator explicitly asked to DROP the data —
+ stays the immediate destructive path (host engines only; policy
+ removed, row hard-deleted, nothing to restore).
+ """
+ if drop:
+ if managed.host_kind == 'host':
+ if managed.engine == 'mysql':
+ DatabaseService.mysql_drop_database(managed.name)
+ elif managed.engine == 'postgresql':
+ DatabaseService.pg_drop_database(managed.name)
+ # mongodb drop is out of scope (read-first); untrack only.
+ cls._delete_managed_policy(managed)
+ db.session.delete(managed)
+ db.session.commit()
+ return
+
+ managed.soft_delete(user_id)
db.session.commit()
# ── connection string ──
diff --git a/backend/app/services/manifest_apply_service.py b/backend/app/services/manifest_apply_service.py
index c964c923..714f60b9 100644
--- a/backend/app/services/manifest_apply_service.py
+++ b/backend/app/services/manifest_apply_service.py
@@ -286,7 +286,7 @@ class ManifestApplyService:
f'managed by ServerKit yet — declared but not provisioned',
'payload': {},
}]
- existing = ManagedDatabase.query.filter_by(engine=engine, name=name).first()
+ existing = ManagedDatabase.query_active().filter_by(engine=engine, name=name).first()
steps: List[Dict[str, Any]] = []
if not existing:
steps.append({
@@ -1099,7 +1099,7 @@ class ManifestApplyService:
'retention_count': payload['retain']}
if payload['target'] == 'database':
from app.services.managed_database_service import ManagedDatabaseService
- managed = ManagedDatabase.query.filter_by(
+ managed = ManagedDatabase.query_active().filter_by(
engine=payload['engine'], name=payload['db_name']).first()
if not managed:
raise RuntimeError('managed database not found for backup policy')
diff --git a/backend/app/services/recycle_bin_service.py b/backend/app/services/recycle_bin_service.py
index ddc9a847..989c5360 100644
--- a/backend/app/services/recycle_bin_service.py
+++ b/backend/app/services/recycle_bin_service.py
@@ -238,3 +238,20 @@ def register_builtin_types():
description=lambda v: f'{v.page} view',
pre_restore=_pre_restore_view,
)
+
+ from app.models.managed_database import ManagedDatabase
+
+ def _on_purge_managed_database(managed):
+ # Purge removes the managed BackupPolicy that kept running while the
+ # row sat in the bin. It NEVER drops the database content — the only
+ # destructive path for data is the explicit ?drop=true delete.
+ from app.services.managed_database_service import ManagedDatabaseService
+ ManagedDatabaseService._delete_managed_policy(managed)
+
+ register(
+ 'managed_database', ManagedDatabase, noun='managed database',
+ label=lambda m: m.name,
+ description=lambda m: f'{m.engine} on {m.host}'
+ + (f':{m.port}' if m.port else ''),
+ on_purge=_on_purge_managed_database,
+ )
diff --git a/backend/migrations/versions/088_soft_delete_managed_databases.py b/backend/migrations/versions/088_soft_delete_managed_databases.py
new file mode 100644
index 00000000..51f09191
--- /dev/null
+++ b/backend/migrations/versions/088_soft_delete_managed_databases.py
@@ -0,0 +1,37 @@
+"""SoftDelete adoption for managed databases (plan 77 B5).
+
+Adds the tombstone pair to managed_databases (migration 083 pattern). No
+unique constraints exist on the table, so no partial-unique-index rewrite is
+needed.
+
+Revision ID: 088_soft_delete_managed_databases
+Revises: 087_run_log_entries
+"""
+import sqlalchemy as sa
+from alembic import op
+
+revision = '088_soft_delete_managed_databases'
+down_revision = '087_run_log_entries'
+branch_labels = None
+depends_on = None
+
+
+def _has_column(table, column):
+ bind = op.get_bind()
+ return column in [c['name'] for c in sa.inspect(bind).get_columns(table)]
+
+
+def upgrade():
+ if not _has_column('managed_databases', 'deleted_at'):
+ op.add_column('managed_databases', sa.Column('deleted_at', sa.DateTime(), nullable=True))
+ op.create_index('ix_managed_databases_deleted_at', 'managed_databases', ['deleted_at'])
+ if not _has_column('managed_databases', 'deleted_by_id'):
+ op.add_column('managed_databases', sa.Column('deleted_by_id', sa.Integer(), nullable=True))
+
+
+def downgrade():
+ if _has_column('managed_databases', 'deleted_at'):
+ op.drop_index('ix_managed_databases_deleted_at', table_name='managed_databases')
+ op.drop_column('managed_databases', 'deleted_at')
+ if _has_column('managed_databases', 'deleted_by_id'):
+ op.drop_column('managed_databases', 'deleted_by_id')
diff --git a/backend/tests/test_managed_database.py b/backend/tests/test_managed_database.py
index f4604bdc..a1bad8c5 100644
--- a/backend/tests/test_managed_database.py
+++ b/backend/tests/test_managed_database.py
@@ -118,11 +118,16 @@ def test_legacy_json_descriptor_policy_still_resolves(app):
assert target['db_config']['user'] == 'legacy'
-def test_untrack_removes_managed_policy(app, managed):
+def test_soft_delete_keeps_policy_until_purge(app, managed):
+ # Plan 77 B5: the tombstoned DB keeps its backup policy running so the
+ # data stays recoverable for the Recycle Bin window; PURGE removes it.
from app.models.backup_policy import BackupPolicy
+ from app.services import recycle_bin_service
ManagedDatabaseService.protect(managed)
assert BackupPolicy.query.filter_by(target_type='database', target_id=managed.id).count() == 1
ManagedDatabaseService.delete(managed, drop=False)
+ assert BackupPolicy.query.filter_by(target_type='database', target_id=managed.id).count() == 1
+ recycle_bin_service.purge('managed_database', managed.id)
assert BackupPolicy.query.filter_by(target_type='database', target_id=managed.id).count() == 0
assert ManagedDatabase.query.get(managed.id) is None
@@ -165,4 +170,9 @@ def test_api_adopt_requires_admin(client, app):
def test_api_untrack(client, auth_headers, app, managed):
resp = client.delete(f'/api/v1/databases/managed/{managed.id}', headers=auth_headers)
assert resp.status_code == 200
- assert ManagedDatabase.query.get(managed.id) is None
+ # Plan 77 B5: a plain delete tombstones into the Recycle Bin — hidden
+ # from active reads, physically retained until purge.
+ row = ManagedDatabase.query.get(managed.id)
+ assert row is not None and row.is_deleted
+ from app.services.managed_database_service import ManagedDatabaseService
+ assert ManagedDatabaseService.get(managed.id) is None
diff --git a/backend/tests/test_managed_database_soft_delete.py b/backend/tests/test_managed_database_soft_delete.py
new file mode 100644
index 00000000..3b3697d5
--- /dev/null
+++ b/backend/tests/test_managed_database_soft_delete.py
@@ -0,0 +1,74 @@
+"""Plan 77 B5 — ManagedDatabase soft delete: tombstone, restore, purge.
+
+DELETE keeps the actual database and its backup policy (recoverable);
+?drop=true stays the immediate destructive path; PURGE removes the policy
+but never database content.
+"""
+import pytest
+
+from app import db
+from app.models.managed_database import ManagedDatabase
+from app.services import recycle_bin_service
+from app.services.managed_database_service import ManagedDatabaseService
+
+
+def _mk(name='sd-db', engine='mysql'):
+ row = ManagedDatabase(engine=engine, name=name, host='localhost')
+ db.session.add(row)
+ db.session.commit()
+ return row
+
+
+def test_soft_delete_hides_from_reads_but_keeps_row(app):
+ row = _mk()
+ ManagedDatabaseService.delete(row, user_id=42)
+
+ assert row.deleted_at is not None and row.deleted_by_id == 42
+ assert ManagedDatabaseService.get(row.id) is None
+ assert row.id not in [m.id for m in ManagedDatabase.query_active().all()]
+ # tombstone still physically present
+ assert ManagedDatabase.query.get(row.id) is not None
+
+
+def test_recycle_bin_lists_and_restores(app):
+ row = _mk(name='sd-restore')
+ ManagedDatabaseService.delete(row)
+
+ listed = recycle_bin_service.list_deleted('managed_database')
+ assert any(item['id'] == row.id for item in listed)
+
+ result = recycle_bin_service.restore('managed_database', row.id)
+ assert result.get('error') is None if isinstance(result, dict) else True
+ assert ManagedDatabaseService.get(row.id) is not None
+
+
+def test_purge_removes_row_and_policy_never_content(app, monkeypatch):
+ row = _mk(name='sd-purge')
+ dropped = []
+ from app.services.database_service import DatabaseService
+ monkeypatch.setattr(DatabaseService, 'mysql_drop_database',
+ staticmethod(lambda name: dropped.append(name)), raising=False)
+ policy_removed = []
+ monkeypatch.setattr(ManagedDatabaseService, '_delete_managed_policy',
+ staticmethod(lambda managed: policy_removed.append(managed.id)))
+
+ ManagedDatabaseService.delete(row)
+ recycle_bin_service.purge('managed_database', row.id)
+
+ assert ManagedDatabase.query.get(row.id) is None
+ assert policy_removed == [row.id]
+ assert dropped == [], 'purge must never drop database content'
+
+
+def test_drop_true_stays_immediately_destructive(app, monkeypatch):
+ row = _mk(name='sd-drop')
+ dropped = []
+ from app.services.database_service import DatabaseService
+ monkeypatch.setattr(DatabaseService, 'mysql_drop_database',
+ staticmethod(lambda name: dropped.append(name)), raising=False)
+ monkeypatch.setattr(ManagedDatabaseService, '_delete_managed_policy',
+ staticmethod(lambda managed: None))
+
+ ManagedDatabaseService.delete(row, drop=True)
+ assert dropped == ['sd-drop']
+ assert ManagedDatabase.query.get(row.id) is None, 'drop=true is a hard delete'
diff --git a/backend/tests/test_managed_db_users.py b/backend/tests/test_managed_db_users.py
index 7fbdf4ce..a181ad2b 100644
--- a/backend/tests/test_managed_db_users.py
+++ b/backend/tests/test_managed_db_users.py
@@ -82,10 +82,17 @@ def test_username_unique_per_database(app, managed):
db.session.rollback()
-def test_rows_cascade_with_managed_database(app, managed):
+def test_rows_survive_soft_delete_and_cascade_on_hard_delete(app, managed):
+ # Plan 77 B5: a plain delete tombstones the managed DB, so its user rows
+ # must SURVIVE (restore needs them). The hard-delete path (?drop=true /
+ # purge) is what cascades them away.
ManagedDbUserService.ensure_recorded(managed, 'orphan_check')
assert ManagedDatabaseUser.query.count() == 1
ManagedDatabaseService.delete(managed, drop=False)
+ assert ManagedDatabaseUser.query.count() == 1
+
+ managed.restore()
+ ManagedDatabaseService.delete(managed, drop=True)
assert ManagedDatabaseUser.query.count() == 0