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(views): per-user saved table views API

Juan Denisb6c257bfc799
diff --git a/backend/app/__init__.py b/backend/app/__init__.py
index 47ae9049..e6b50257 100644
--- a/backend/app/__init__.py
+++ b/backend/app/__init__.py
@@ -478,6 +478,8 @@ def create_app(config_name=None):
# Register blueprints - Themes (plan 60)
from app.api.themes import themes_bp
app.register_blueprint(themes_bp, url_prefix='/api/v1/themes')
+ from app.api.views import views_bp
+ app.register_blueprint(views_bp, url_prefix='/api/v1/views')
# Register blueprints - Dashboard boards (plan 62, per-user widget grid)
from app.api.dashboards import dashboards_bp
diff --git a/backend/app/api/views.py b/backend/app/api/views.py
new file mode 100644
index 00000000..6ed6de45
--- /dev/null
+++ b/backend/app/api/views.py
@@ -0,0 +1,52 @@
+from flask import Blueprint, jsonify, request
+from flask_jwt_extended import jwt_required, get_jwt_identity
+
+from app.services import saved_view_service
+
+views_bp = Blueprint('views', __name__)
+
+
+@views_bp.route('', methods=['GET'])
+@jwt_required()
+def list_views():
+ """List the current user's saved views, optionally for one page."""
+ page = request.args.get('page', '').strip()
+ if not page:
+ return jsonify({'error': 'The page query parameter is required'}), 400
+ return jsonify({'views': saved_view_service.list_views(get_jwt_identity(), page)})
+
+
+@views_bp.route('', methods=['POST'])
+@jwt_required()
+def create_view():
+ body = request.get_json(silent=True) or {}
+ view, err = saved_view_service.create_view(
+ get_jwt_identity(),
+ body.get('page'),
+ body.get('name'),
+ body.get('state'),
+ is_default=bool(body.get('is_default')),
+ )
+ if err:
+ return jsonify({'error': err}), 400
+ return jsonify(view), 201
+
+
+@views_bp.route('/<int:view_id>', methods=['PUT'])
+@jwt_required()
+def update_view(view_id):
+ body = request.get_json(silent=True) or {}
+ view, err = saved_view_service.update_view(get_jwt_identity(), view_id, body)
+ if err:
+ code = 404 if 'not found' in err.lower() else 400
+ return jsonify({'error': err}), code
+ return jsonify(view)
+
+
+@views_bp.route('/<int:view_id>', methods=['DELETE'])
+@jwt_required()
+def delete_view(view_id):
+ _, err = saved_view_service.delete_view(get_jwt_identity(), view_id)
+ if err:
+ return jsonify({'error': err}), 404
+ return jsonify({'success': True})
diff --git a/backend/app/models/__init__.py b/backend/app/models/__init__.py
index 9d8b3058..36e13567 100644
--- a/backend/app/models/__init__.py
+++ b/backend/app/models/__init__.py
@@ -81,6 +81,7 @@ from app.models.server_survey import ServerSurvey
from app.models.dns_cutover_snapshot import DnsCutoverSnapshot
from app.models.theme import Theme
from app.models.plugin_store import PluginStore
+from app.models.saved_view import SavedView
__all__ = [
'User', 'Application', 'Domain', 'EnvironmentVariable', 'EnvironmentVariableHistory',
@@ -133,4 +134,5 @@ __all__ = [
'DnsCutoverSnapshot',
'Theme',
'PluginStore',
+ 'SavedView',
]
diff --git a/backend/app/models/saved_view.py b/backend/app/models/saved_view.py
new file mode 100644
index 00000000..2999a8d8
--- /dev/null
+++ b/backend/app/models/saved_view.py
@@ -0,0 +1,44 @@
+from datetime import datetime
+from app import db
+
+
+class SavedView(db.Model):
+ """A user's saved table view for a list page (Services, Domains, …).
+
+ Captures the page's table state — filter, search, sort levels, hidden
+ columns, page size — as JSON so the frontend can re-apply it verbatim.
+ Built-in views ship in the frontend; only user-created views live here.
+ At most one view per (user, page) is the default, enforced by the service.
+ """
+
+ __tablename__ = 'saved_views'
+
+ id = db.Column(db.Integer, primary_key=True)
+ user_id = db.Column(db.Integer, db.ForeignKey('users.id', ondelete='CASCADE'), nullable=False)
+ page = db.Column(db.String(80), nullable=False)
+ name = db.Column(db.String(120), nullable=False)
+ state = db.Column(db.JSON, nullable=False, default=dict)
+ is_default = db.Column(db.Boolean, nullable=False, default=False)
+ created_at = db.Column(db.DateTime, default=datetime.utcnow)
+ updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+ __table_args__ = (
+ db.UniqueConstraint('user_id', 'page', 'name', name='uq_saved_views_user_page_name'),
+ )
+
+ user = db.relationship('User', backref=db.backref('saved_views', cascade='all, delete-orphan'))
+
+ def to_dict(self):
+ return {
+ 'id': self.id,
+ 'user_id': self.user_id,
+ 'page': self.page,
+ 'name': self.name,
+ 'state': self.state or {},
+ 'is_default': self.is_default,
+ 'created_at': self.created_at.isoformat() if self.created_at else None,
+ 'updated_at': self.updated_at.isoformat() if self.updated_at else None,
+ }
+
+ def __repr__(self):
+ return f'<SavedView {self.page}/{self.name} user={self.user_id}>'
diff --git a/backend/app/services/saved_view_service.py b/backend/app/services/saved_view_service.py
new file mode 100644
index 00000000..2d5b6162
--- /dev/null
+++ b/backend/app/services/saved_view_service.py
@@ -0,0 +1,96 @@
+import logging
+
+from app import db
+from app.models.saved_view import SavedView
+
+logger = logging.getLogger(__name__)
+
+MAX_VIEWS_PER_PAGE = 50
+
+
+def list_views(user_id, page):
+ """All saved views a user has for one list page, defaults first."""
+ views = (SavedView.query
+ .filter_by(user_id=user_id, page=page)
+ .order_by(SavedView.is_default.desc(), SavedView.name.asc())
+ .all())
+ return [v.to_dict() for v in views]
+
+
+def _validate(page, name, state):
+ if not page or not isinstance(page, str) or len(page) > 80:
+ return 'A view needs a page key (max 80 chars)'
+ if not name or not isinstance(name, str) or not name.strip():
+ return 'A view needs a name'
+ if len(name) > 120:
+ return 'View names are limited to 120 characters'
+ if not isinstance(state, dict):
+ return 'View state must be an object'
+ return None
+
+
+def _clear_default(user_id, page):
+ (SavedView.query
+ .filter_by(user_id=user_id, page=page, is_default=True)
+ .update({'is_default': False}))
+
+
+def create_view(user_id, page, name, state, is_default=False):
+ """Create a saved view. Returns ``(view_dict, error)``."""
+ err = _validate(page, name, state)
+ if err:
+ return None, err
+ name = name.strip()
+ if SavedView.query.filter_by(user_id=user_id, page=page).count() >= MAX_VIEWS_PER_PAGE:
+ return None, f'You can save at most {MAX_VIEWS_PER_PAGE} views per page'
+ if SavedView.query.filter_by(user_id=user_id, page=page, name=name).first():
+ return None, f'You already have a "{name}" view on this page'
+ if is_default:
+ _clear_default(user_id, page)
+ view = SavedView(user_id=user_id, page=page, name=name, state=state, is_default=bool(is_default))
+ db.session.add(view)
+ db.session.commit()
+ return view.to_dict(), None
+
+
+def update_view(user_id, view_id, data):
+ """Rename / restate / (un)default a saved view. Returns ``(view_dict, error)``."""
+ view = SavedView.query.filter_by(id=view_id, user_id=user_id).first()
+ if not view:
+ return None, 'View not found'
+
+ if 'name' in data:
+ err = _validate(view.page, data['name'], view.state or {})
+ if err:
+ return None, err
+ name = data['name'].strip()
+ clash = (SavedView.query
+ .filter_by(user_id=user_id, page=view.page, name=name)
+ .filter(SavedView.id != view.id)
+ .first())
+ if clash:
+ return None, f'You already have a "{name}" view on this page'
+ view.name = name
+
+ if 'state' in data:
+ if not isinstance(data['state'], dict):
+ return None, 'View state must be an object'
+ view.state = data['state']
+
+ if 'is_default' in data:
+ if data['is_default']:
+ _clear_default(user_id, view.page)
+ view.is_default = bool(data['is_default'])
+
+ db.session.commit()
+ return view.to_dict(), None
+
+
+def delete_view(user_id, view_id):
+ """Delete a saved view. Returns ``(True, error)``."""
+ view = SavedView.query.filter_by(id=view_id, user_id=user_id).first()
+ if not view:
+ return None, 'View not found'
+ db.session.delete(view)
+ db.session.commit()
+ return True, None
diff --git a/backend/migrations/versions/082_saved_views.py b/backend/migrations/versions/082_saved_views.py
new file mode 100644
index 00000000..598d8014
--- /dev/null
+++ b/backend/migrations/versions/082_saved_views.py
@@ -0,0 +1,51 @@
+"""Per-user saved table views.
+
+Stores named table states (filter/search/sort/columns/page-size) per list
+page, with one default per (user, page).
+
+Idempotent: guards on table presence like the other migrations here.
+
+Revision ID: 082_saved_views
+Revises: 081_monitors_first_class
+Create Date: 2026-08-09
+"""
+from alembic import op
+import sqlalchemy as sa
+
+revision = '082_saved_views'
+down_revision = '081_monitors_first_class'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+ conn = op.get_bind()
+ inspector = sa.inspect(conn)
+ if 'saved_views' in set(inspector.get_table_names()):
+ return
+ op.create_table(
+ 'saved_views',
+ sa.Column('id', sa.Integer(), nullable=False),
+ sa.Column('user_id', sa.Integer(), nullable=False),
+ sa.Column('page', sa.String(length=80), nullable=False),
+ sa.Column('name', sa.String(length=120), nullable=False),
+ sa.Column('state', sa.JSON(), nullable=False),
+ sa.Column('is_default', sa.Boolean(), nullable=False, server_default=sa.false()),
+ sa.Column('created_at', sa.DateTime(), nullable=True),
+ sa.Column('updated_at', sa.DateTime(), nullable=True),
+ sa.ForeignKeyConstraint(['user_id'], ['users.id'], ondelete='CASCADE'),
+ sa.PrimaryKeyConstraint('id'),
+ sa.UniqueConstraint('user_id', 'page', 'name', name='uq_saved_views_user_page_name'),
+ )
+ op.create_index('ix_saved_views_user_id', 'saved_views', ['user_id'])
+ op.create_index('ix_saved_views_page', 'saved_views', ['page'])
+
+
+def downgrade():
+ conn = op.get_bind()
+ inspector = sa.inspect(conn)
+ if 'saved_views' not in set(inspector.get_table_names()):
+ return
+ op.drop_index('ix_saved_views_page', table_name='saved_views')
+ op.drop_index('ix_saved_views_user_id', table_name='saved_views')
+ op.drop_table('saved_views')
diff --git a/backend/tests/test_views.py b/backend/tests/test_views.py
new file mode 100644
index 00000000..b944c02b
--- /dev/null
+++ b/backend/tests/test_views.py
@@ -0,0 +1,112 @@
+"""Tests for the saved table views API (/api/v1/views)."""
+
+import pytest
+
+
+def _create(client, headers, page='services', name='Running', state=None, is_default=False):
+ return client.post('/api/v1/views', headers=headers, json={
+ 'page': page,
+ 'name': name,
+ 'state': state if state is not None else {'filter': 'running'},
+ 'is_default': is_default,
+ })
+
+
+def test_views_require_auth(client):
+ assert client.get('/api/v1/views?page=services').status_code == 401
+ assert client.post('/api/v1/views', json={}).status_code == 401
+
+
+def test_list_requires_page_param(client, auth_headers):
+ resp = client.get('/api/v1/views', headers=auth_headers)
+ assert resp.status_code == 400
+
+
+def test_create_and_list_view(client, auth_headers):
+ resp = _create(client, auth_headers)
+ assert resp.status_code == 201
+ view = resp.get_json()
+ assert view['name'] == 'Running'
+ assert view['page'] == 'services'
+ assert view['state'] == {'filter': 'running'}
+ assert view['is_default'] is False
+
+ resp = client.get('/api/v1/views?page=services', headers=auth_headers)
+ assert resp.status_code == 200
+ views = resp.get_json()['views']
+ assert len(views) == 1
+ assert views[0]['id'] == view['id']
+
+ # A different page does not see the view
+ resp = client.get('/api/v1/views?page=domains', headers=auth_headers)
+ assert resp.get_json()['views'] == []
+
+
+def test_create_validates_input(client, auth_headers):
+ assert _create(client, auth_headers, page='').status_code == 400
+ assert _create(client, auth_headers, name='').status_code == 400
+ assert _create(client, auth_headers, state=['not', 'a', 'dict']).status_code == 400
+
+
+def test_duplicate_name_rejected(client, auth_headers):
+ assert _create(client, auth_headers).status_code == 201
+ resp = _create(client, auth_headers)
+ assert resp.status_code == 400
+ assert 'already' in resp.get_json()['error']
+
+
+def test_only_one_default_per_page(client, auth_headers):
+ first = _create(client, auth_headers, name='One', is_default=True).get_json()
+ second = _create(client, auth_headers, name='Two', is_default=True).get_json()
+
+ views = client.get('/api/v1/views?page=services', headers=auth_headers).get_json()['views']
+ by_id = {v['id']: v for v in views}
+ assert by_id[first['id']]['is_default'] is False
+ assert by_id[second['id']]['is_default'] is True
+
+ # Un-defaulting leaves no default
+ resp = client.put(f"/api/v1/views/{second['id']}", headers=auth_headers,
+ json={'is_default': False})
+ assert resp.status_code == 200
+ views = client.get('/api/v1/views?page=services', headers=auth_headers).get_json()['views']
+ assert all(v['is_default'] is False for v in views)
+
+
+def test_update_rename_and_state(client, auth_headers):
+ view = _create(client, auth_headers).get_json()
+ resp = client.put(f"/api/v1/views/{view['id']}", headers=auth_headers,
+ json={'name': 'Renamed', 'state': {'filter': 'stopped'}})
+ assert resp.status_code == 200
+ updated = resp.get_json()
+ assert updated['name'] == 'Renamed'
+ assert updated['state'] == {'filter': 'stopped'}
+
+
+def test_views_are_scoped_to_their_owner(client, app, auth_headers):
+ view = _create(client, auth_headers).get_json()
+
+ # A second user must not see, update, or delete the first user's view
+ from app import db
+ from app.models import User
+ from flask_jwt_extended import create_access_token
+ from werkzeug.security import generate_password_hash
+ with app.app_context():
+ other = User(email='[email protected]', username='other',
+ password_hash=generate_password_hash('pass'),
+ role=User.ROLE_ADMIN, is_active=True)
+ db.session.add(other)
+ db.session.commit()
+ token = create_access_token(identity=other.id)
+ other_headers = {'Authorization': f'Bearer {token}'}
+
+ resp = client.get('/api/v1/views?page=services', headers=other_headers)
+ assert resp.get_json()['views'] == []
+ assert client.put(f"/api/v1/views/{view['id']}", headers=other_headers,
+ json={'name': 'Hijack'}).status_code == 404
+ assert client.delete(f"/api/v1/views/{view['id']}", headers=other_headers).status_code == 404
+
+
+def test_delete_view(client, auth_headers):
+ view = _create(client, auth_headers).get_json()
+ assert client.delete(f"/api/v1/views/{view['id']}", headers=auth_headers).status_code == 200
+ assert client.delete(f"/api/v1/views/{view['id']}", headers=auth_headers).status_code == 404