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.
Python astracloudflarecontrol-panelcyberpaneldnsfablehosting-control-panelhosting-panelkimi-k3server-managementserverkitubuntu-web-panelwebserver
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.pyindex 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 ManagedDatabaserelated['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.pyindex 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'}), 404drop = 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}), 200diff --git a/backend/app/api/shared_resources.py b/backend/app/api/shared_resources.pyindex 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 ManagedDatabasetry:- row = ManagedDatabase.query.get(int(resource_id))+ row = ManagedDatabase.query_active().filter_by(id=int(resource_id)).first()except (TypeError, ValueError):row = Noneif row is None:diff --git a/backend/app/models/managed_database.py b/backend/app/models/managed_database.pyindex b4ae8f6b..3dbf405b 100644--- a/backend/app/models/managed_database.py+++ b/backend/app/models/managed_database.py@@ -1,13 +1,13 @@from datetime import datetimefrom 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 throughan 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.pyindex 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 ManagedDatabasefrom 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.pyindex 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.pyindex 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 Noneif created:managed = ManagedDatabase(engine=engine, name=name, host=host, origin=origin)@@ -75,7 +75,7 @@ class ManagedDatabaseService:@classmethoddef 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.pyindex 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.pyindex 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.pynew file mode 100644index 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.pyindex 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_serviceManagedDatabaseService.protect(managed)assert BackupPolicy.query.filter_by(target_type='database', target_id=managed.id).count() == 1ManagedDatabaseService.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() == 0assert 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 Nonediff --git a/backend/tests/test_managed_database_soft_delete.py b/backend/tests/test_managed_database_soft_delete.pynew file mode 100644index 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.pyindex 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() == 1ManagedDatabaseService.delete(managed, drop=False)+ assert ManagedDatabaseUser.query.count() == 1++ managed.restore()+ ManagedDatabaseService.delete(managed, drop=True)assert ManagedDatabaseUser.query.count() == 0