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(sites): base-domain registry so sites can publish under multiple domains

Juan Denisf76da49ab446
diff --git a/backend/app/models/__init__.py b/backend/app/models/__init__.py
index 881e86a2..6e69383b 100644
--- a/backend/app/models/__init__.py
+++ b/backend/app/models/__init__.py
@@ -10,6 +10,7 @@ from app.models.environment import Environment
from app.models.shared_resource import ResourceTag, SharedVariableGroup, SharedVariable, SharedVariableGroupAttachment
from app.models.application_preview import ApplicationPreview, ApplicationPreviewSettings
from app.models.proxy_stack import ProxyStack
+from app.models.site_base_domain import SiteBaseDomain
from app.models.deployment_job import DeploymentJob, DeploymentJobLog
from app.models.system_settings import SystemSettings
from app.models.audit_log import AuditLog
@@ -99,4 +100,5 @@ __all__ = [
'ResourceTag', 'SharedVariableGroup', 'SharedVariable', 'SharedVariableGroupAttachment',
'ApplicationPreview', 'ApplicationPreviewSettings',
'ProxyStack',
+ 'SiteBaseDomain',
]
diff --git a/backend/app/models/site_base_domain.py b/backend/app/models/site_base_domain.py
new file mode 100644
index 00000000..1ecee47c
--- /dev/null
+++ b/backend/app/models/site_base_domain.py
@@ -0,0 +1,52 @@
+"""Base domains that managed sites can be published under.
+
+ServerKit publishes a managed site at ``<slug>.<base_domain>``. Historically
+there was exactly one base domain (the ``sites_base_domain`` setting); this
+model lets an operator register several — e.g. ``example.com`` and ``toto.com`` —
+each with its own DNS provider connection and wildcard certificate, so a new
+site can choose which one to live under (``a.example.com`` vs ``a.toto.com``).
+
+Exactly one row is the default, used when a create request doesn't name a base.
+On upgrade the legacy single setting is lazily materialised into the default row
+(see SiteBaseDomainService.ensure_seeded); a fresh/dev install with no rows keeps
+falling back to the ``sites_base_domain`` setting / ``SITES_BASE_DOMAIN`` config.
+"""
+from datetime import datetime
+
+from app import db
+
+
+class SiteBaseDomain(db.Model):
+ __tablename__ = 'site_base_domains'
+
+ DNS_MODES = ('wildcard', 'per-site')
+
+ id = db.Column(db.Integer, primary_key=True)
+ domain = db.Column(db.String(253), nullable=False, unique=True)
+ is_default = db.Column(db.Boolean, nullable=False, default=False)
+ # wildcard: one *.<domain> record covers every site; per-site: each site gets
+ # its own A record auto-created via the provider.
+ dns_mode = db.Column(db.String(20), nullable=False, default='wildcard')
+ # True once a *.<domain> wildcard certificate exists, so its sites serve TLS.
+ https_enabled = db.Column(db.Boolean, nullable=False, default=False)
+ # The connected DNS provider that owns this domain's zone — used to create the
+ # wildcard record and issue the wildcard cert. Nullable: a domain may be
+ # registered before HTTPS is set up, or have its DNS managed manually.
+ dns_provider_config_id = db.Column(
+ db.Integer,
+ db.ForeignKey('dns_provider_configs.id', ondelete='SET NULL'),
+ nullable=True,
+ )
+ created_at = db.Column(db.DateTime, default=datetime.utcnow)
+ updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+ def to_dict(self):
+ return {
+ 'id': self.id,
+ 'domain': self.domain,
+ 'is_default': self.is_default,
+ 'dns_mode': self.dns_mode if self.dns_mode in self.DNS_MODES else 'wildcard',
+ 'https_enabled': bool(self.https_enabled),
+ 'dns_provider_config_id': self.dns_provider_config_id,
+ 'created_at': self.created_at.isoformat() if self.created_at else None,
+ }
diff --git a/backend/app/services/site_base_domain_service.py b/backend/app/services/site_base_domain_service.py
new file mode 100644
index 00000000..55712eb1
--- /dev/null
+++ b/backend/app/services/site_base_domain_service.py
@@ -0,0 +1,149 @@
+"""CRUD + resolution for the managed-site base-domain registry.
+
+The registry (``site_base_domains``) lets managed sites be published under any of
+several base domains (``example.com``, ``toto.com``, …), each with its own DNS
+provider + wildcard cert. Exactly one row is the default. This service owns the
+writes; SiteDomainService reads through it for routing/cert decisions.
+
+Back-compat: installs that only ever had the single ``sites_base_domain`` setting
+have zero rows. ``ensure_seeded`` materialises that legacy value into the default
+row the moment a second domain is registered, so the two never disagree.
+"""
+import re
+
+from app import db
+from app.models.site_base_domain import SiteBaseDomain
+from app.models.system_settings import SystemSettings
+
+_DOMAIN_RE = re.compile(
+ r'^(?:[a-z0-9](?:[a-z0-9\-]{0,61}[a-z0-9])?\.)+[a-z]{2,63}$'
+)
+
+
+def normalize_domain(value):
+ """Lowercase, trim, drop a leading dot. Returns '' for falsy input."""
+ return (str(value).strip().lstrip('.').lower()) if value else ''
+
+
+class SiteBaseDomainService:
+
+ @staticmethod
+ def is_valid_domain(domain):
+ d = normalize_domain(domain)
+ return bool(d) and len(d) <= 253 and bool(_DOMAIN_RE.match(d))
+
+ # ------------------------------------------------------------------
+ # Seeding / back-compat
+ # ------------------------------------------------------------------
+ @classmethod
+ def ensure_seeded(cls):
+ """If the registry is empty but a legacy ``sites_base_domain`` setting
+ exists, create the default row from the legacy sites settings so the
+ registry and the old single-domain settings agree. No-op otherwise (and
+ deliberately does NOT seed the dev-only ``SITES_BASE_DOMAIN`` config —
+ only a persisted operator setting)."""
+ if SiteBaseDomain.query.first() is not None:
+ return None
+ legacy = normalize_domain(SystemSettings.get('sites_base_domain'))
+ if not legacy:
+ return None
+ mode = (SystemSettings.get('sites_dns_mode') or 'wildcard')
+ row = SiteBaseDomain(
+ domain=legacy,
+ is_default=True,
+ dns_mode=mode if mode in SiteBaseDomain.DNS_MODES else 'wildcard',
+ https_enabled=bool(SystemSettings.get('sites_https_enabled', False)),
+ )
+ db.session.add(row)
+ db.session.commit()
+ return row
+
+ # ------------------------------------------------------------------
+ # Reads
+ # ------------------------------------------------------------------
+ @classmethod
+ def list_rows(cls):
+ return SiteBaseDomain.query.order_by(
+ SiteBaseDomain.is_default.desc(), SiteBaseDomain.domain.asc()).all()
+
+ @classmethod
+ def get(cls, domain):
+ return SiteBaseDomain.query.filter_by(domain=normalize_domain(domain)).first()
+
+ @classmethod
+ def default(cls):
+ """The default row (explicit flag, else the oldest), or None."""
+ return (SiteBaseDomain.query.filter_by(is_default=True).first()
+ or SiteBaseDomain.query.order_by(SiteBaseDomain.id.asc()).first())
+
+ # ------------------------------------------------------------------
+ # Writes
+ # ------------------------------------------------------------------
+ @classmethod
+ def add(cls, domain, dns_provider_config_id=None, dns_mode='wildcard', make_default=False):
+ """Register a base domain. Seeds the legacy default first, so the first
+ added domain doesn't silently become the sole/default and orphan the old
+ single-domain config. Returns ``{'success', 'base'|'error'}``."""
+ d = normalize_domain(domain)
+ if not cls.is_valid_domain(d):
+ return {'success': False, 'error': f'Invalid domain: {domain}'}
+ cls.ensure_seeded()
+ if cls.get(d):
+ return {'success': False, 'error': f'{d} is already registered.'}
+ mode = dns_mode if dns_mode in SiteBaseDomain.DNS_MODES else 'wildcard'
+ first = SiteBaseDomain.query.first() is None
+ row = SiteBaseDomain(
+ domain=d, dns_mode=mode, dns_provider_config_id=dns_provider_config_id,
+ is_default=bool(make_default or first),
+ )
+ db.session.add(row)
+ db.session.flush()
+ if row.is_default:
+ cls._demote_others(row.id)
+ db.session.commit()
+ return {'success': True, 'base': row.to_dict()}
+
+ @classmethod
+ def set_default(cls, domain):
+ row = cls.get(domain)
+ if not row:
+ return {'success': False, 'error': f'{domain} is not registered.'}
+ row.is_default = True
+ cls._demote_others(row.id)
+ db.session.commit()
+ return {'success': True, 'base': row.to_dict()}
+
+ @classmethod
+ def update(cls, domain, dns_mode=None, dns_provider_config_id=None, https_enabled=None):
+ row = cls.get(domain)
+ if not row:
+ return {'success': False, 'error': f'{domain} is not registered.'}
+ if dns_mode is not None and dns_mode in SiteBaseDomain.DNS_MODES:
+ row.dns_mode = dns_mode
+ if dns_provider_config_id is not None:
+ row.dns_provider_config_id = dns_provider_config_id or None
+ if https_enabled is not None:
+ row.https_enabled = bool(https_enabled)
+ db.session.commit()
+ return {'success': True, 'base': row.to_dict()}
+
+ @classmethod
+ def remove(cls, domain):
+ row = cls.get(domain)
+ if not row:
+ return {'success': False, 'error': f'{domain} is not registered.'}
+ was_default = row.is_default
+ db.session.delete(row)
+ db.session.flush()
+ if was_default:
+ # Promote the oldest survivor so there's always a default.
+ successor = SiteBaseDomain.query.order_by(SiteBaseDomain.id.asc()).first()
+ if successor:
+ successor.is_default = True
+ db.session.commit()
+ return {'success': True}
+
+ @staticmethod
+ def _demote_others(keep_id):
+ SiteBaseDomain.query.filter(SiteBaseDomain.id != keep_id).update(
+ {'is_default': False}, synchronize_session=False)
diff --git a/backend/app/services/site_domain_service.py b/backend/app/services/site_domain_service.py
index f1ed6b5f..7ad5fa5e 100644
--- a/backend/app/services/site_domain_service.py
+++ b/backend/app/services/site_domain_service.py
@@ -22,17 +22,73 @@ from app.utils.slug import slugify as _slugify
class SiteDomainService:
DEFAULT_BASE_DOMAIN = 'lvh.me'
+ @staticmethod
+ def _norm(value):
+ return (str(value).strip().lstrip('.').lower()) if value else ''
+
+ @classmethod
+ def _default_row(cls):
+ """The default SiteBaseDomain row, or None when the registry is empty
+ (legacy single-setting / dev installs)."""
+ try:
+ from app.services.site_base_domain_service import SiteBaseDomainService
+ return SiteBaseDomainService.default()
+ except Exception:
+ return None
+
+ @classmethod
+ def _row_for(cls, base):
+ """The registry row for ``base`` (or the default row when base is None),
+ or None when there's no matching/registered row."""
+ try:
+ from app.services.site_base_domain_service import SiteBaseDomainService
+ if not base:
+ return SiteBaseDomainService.default()
+ return SiteBaseDomainService.get(base)
+ except Exception:
+ return None
+
@classmethod
def base_domain(cls):
- """The configured base domain, or '' when site routing is not set up.
+ """The *default* base domain, or '' when site routing is not set up.
- Prefers the runtime setting (editable in-app) over the config default so
- an operator can change it without redeploying.
+ Prefers the registry's default row; falls back to the legacy
+ ``sites_base_domain`` setting, then the ``SITES_BASE_DOMAIN`` config
+ default (so dev / not-yet-migrated installs keep working unchanged).
"""
+ row = cls._default_row()
+ if row:
+ return row.domain
val = SystemSettings.get('sites_base_domain')
if val:
- return str(val).strip().lstrip('.').lower()
- return (current_app.config.get('SITES_BASE_DOMAIN') or '').strip().lstrip('.').lower()
+ return cls._norm(val)
+ return cls._norm(current_app.config.get('SITES_BASE_DOMAIN'))
+
+ @classmethod
+ def all_base_domains(cls):
+ """Every base domain a site may be published under (registry rows, else
+ the single legacy base). Empty when site routing isn't configured."""
+ try:
+ from app.services.site_base_domain_service import SiteBaseDomainService
+ rows = SiteBaseDomainService.list_rows()
+ if rows:
+ return [r.domain for r in rows]
+ except Exception:
+ pass
+ base = cls.base_domain()
+ return [base] if base else []
+
+ @classmethod
+ def resolve_base(cls, base=None):
+ """The concrete base domain to publish under. An explicit ``base`` is
+ honoured only when it's a registered/legacy base — an unknown value falls
+ back to the default rather than publishing under an unmanaged domain."""
+ if not base:
+ return cls.base_domain()
+ b = cls._norm(base)
+ if b in cls.all_base_domains():
+ return b
+ return cls.base_domain()
@classmethod
def server_ip(cls):
@@ -64,29 +120,47 @@ class SiteDomainService:
return None
@classmethod
- def https_enabled(cls):
- """True once the wildcard certificate for the base domain is set up, so
- managed subdomains should be served over HTTPS (Phase 5)."""
- return bool(SystemSettings.get('sites_https_enabled', False))
+ def https_enabled(cls, base=None):
+ """True once the wildcard certificate for the given base (default when
+ None) is set up, so its managed subdomains should be served over HTTPS.
+
+ Reads the registry row when present; falls back to the legacy
+ ``sites_https_enabled`` setting for the default/legacy base."""
+ row = cls._row_for(base)
+ if row is not None:
+ return bool(row.https_enabled)
+ if base is None or cls._norm(base) == cls.base_domain():
+ return bool(SystemSettings.get('sites_https_enabled', False))
+ return False
@classmethod
- def wildcard_cert_paths(cls):
- """(fullchain, privkey) paths for the base domain's wildcard cert, or
- (None, None) when no base domain is configured."""
- base = cls.base_domain()
+ def wildcard_cert_paths(cls, base=None):
+ """(fullchain, privkey) paths for a base's wildcard cert (default base
+ when None), or (None, None) when no base domain is configured."""
+ base = cls.resolve_base(base)
if not base:
return (None, None)
return (f'/etc/letsencrypt/live/{base}/fullchain.pem',
f'/etc/letsencrypt/live/{base}/privkey.pem')
+ @classmethod
+ def covering_base(cls, host):
+ """The registered base domain whose wildcard covers ``host`` (host is the
+ base or a subdomain of it), longest match wins, or None. Used to pick the
+ right per-base certificate for a site's domains."""
+ if not host:
+ return None
+ best = None
+ for base in cls.all_base_domains():
+ if host == base or host.endswith('.' + base):
+ if best is None or len(base) > len(best):
+ best = base
+ return best
+
@classmethod
def covers(cls, host):
- """Whether the base domain's wildcard cert covers ``host`` — i.e. host is
- the base domain or a direct subdomain of it."""
- base = cls.base_domain()
- if not base or not host:
- return False
- return host == base or host.endswith('.' + base)
+ """Whether *any* registered base domain's wildcard cert covers ``host``."""
+ return cls.covering_base(host) is not None
@staticmethod
def slugify(name):
@@ -94,10 +168,10 @@ class SiteDomainService:
return _slugify(name) or 'site'
@classmethod
- def subdomain_for(cls, name):
- """``<slug>.<base_domain>`` for a site name, or ``None`` when no base
- domain is configured (site routing disabled)."""
- base = cls.base_domain()
+ def subdomain_for(cls, name, base=None):
+ """``<slug>.<base>`` for a site name (default base when None), or ``None``
+ when no base domain is configured (site routing disabled)."""
+ base = cls.resolve_base(base)
if not base:
return None
return f'{cls.slugify(name)}.{base}'
@@ -110,24 +184,31 @@ class SiteDomainService:
return f'{scheme}://{host}'
@classmethod
- def dns_mode(cls):
- """How managed-site subdomains get their DNS:
+ def dns_mode(cls, base=None):
+ """How a base's managed-site subdomains get their DNS (default base when
+ None):
- * ``wildcard`` (default) — one ``*.<base_domain>`` record covers every site,
- so a new site needs no per-site DNS work, and
+ * ``wildcard`` (default) — one ``*.<base>`` record covers every site, and
* ``per-site`` — each site gets its own A record, auto-created via a
- connected provider, so every site is an explicit, visible record.
- """
+ connected provider.
+
+ Reads the registry row when present; falls back to the legacy
+ ``sites_dns_mode`` setting for the default/legacy base."""
+ row = cls._row_for(base)
+ if row is not None:
+ return row.dns_mode if row.dns_mode in ('wildcard', 'per-site') else 'wildcard'
val = (SystemSettings.get('sites_dns_mode') or '').strip().lower()
return val if val in ('wildcard', 'per-site') else 'wildcard'
@classmethod
def ensure_site_dns(cls, host):
- """Auto-create a managed site's A record when in ``per-site`` mode (via a
- connected provider, ownership-guarded + logged). In ``wildcard`` mode this is
- a no-op — the single ``*.<base>`` record already covers ``host``. Never raises;
- returns the provider result (or a ``skipped``/``no_server_ip`` descriptor)."""
- if not host or cls.dns_mode() != 'per-site':
+ """Auto-create a managed site's A record when its base is in ``per-site``
+ mode (via a connected provider, ownership-guarded + logged). In ``wildcard``
+ mode this is a no-op — the single ``*.<base>`` record already covers ``host``.
+ Never raises; returns the provider result (or a ``skipped``/``no_server_ip``
+ descriptor)."""
+ base = cls.covering_base(host)
+ if not host or cls.dns_mode(base) != 'per-site':
return {'created': False, 'skipped': True, 'reason': 'wildcard'}
ip = cls.server_ip()
if not ip:
@@ -348,9 +429,9 @@ class SiteDomainService:
Handles all host-nginx app types: docker/wordpress and
python/flask/django reverse-proxy to the app's port; php/static serve a
- filesystem root. Serves the base-domain wildcard cert when HTTPS is
- enabled and every domain is a covered subdomain (custom domains bring
- their own cert). Best-effort — never raises; returns ``{'nginx',
+ filesystem root. Serves a base's wildcard cert when every domain is a
+ subdomain of that *same* base and its HTTPS is enabled (custom domains
+ bring their own cert). Best-effort — never raises; returns ``{'nginx',
'warning'}`` (``nginx`` is ``None`` when nothing was written).
"""
from app.models.domain import Domain
@@ -360,9 +441,12 @@ class SiteDomainService:
if not domains:
return {'nginx': None, 'warning': None}
+ # Pick a wildcard cert only when all domains sit under one base (whichever
+ # base covers them) and that base has HTTPS set up.
ssl_cert = ssl_key = None
- if cls.https_enabled() and all(cls.covers(d) for d in domains):
- ssl_cert, ssl_key = cls.wildcard_cert_paths()
+ cover = cls.covering_base(domains[0])
+ if cover and cls.https_enabled(cover) and all(cls.covering_base(d) == cover for d in domains):
+ ssl_cert, ssl_key = cls.wildcard_cert_paths(cover)
kwargs, reason = cls._vhost_create_kwargs(app, domains, ssl_cert, ssl_key, force_type)
if reason:
@@ -380,11 +464,12 @@ class SiteDomainService:
return {'nginx': res, 'warning': None}
@classmethod
- def give_subdomain(cls, app, label=None):
+ def give_subdomain(cls, app, label=None, base=None):
"""One-click 'give this app a subdomain': publish ``app`` at
- ``<label>.<base_domain>`` (label defaults to the app-name slug). Creates the
- primary Domain row, (re)writes its nginx vhost, and — in per-site DNS mode —
- auto-creates the A record (wildcard mode relies on ``*.<base>``).
+ ``<label>.<base>`` (label defaults to the app-name slug; ``base`` defaults
+ to the default registered base domain). Creates the primary Domain row,
+ (re)writes its nginx vhost, and — in per-site DNS mode — auto-creates the A
+ record (wildcard mode relies on ``*.<base>``).
Returns ``{success, host, url, dns, nginx, warning}`` or
``{success: False, error}``.
@@ -392,7 +477,7 @@ class SiteDomainService:
from app import db
from app.models.domain import Domain
- base = cls.base_domain()
+ base = cls.resolve_base(base)
if not base:
return {'success': False, 'error': 'Set the managed-sites base domain first (Settings).'}
@@ -431,5 +516,5 @@ class SiteDomainService:
cls.notify_publishing_gaps()
return {'success': True, 'host': host,
- 'url': cls.site_url(host, ssl=cls.https_enabled() and cls.covers(host)),
+ 'url': cls.site_url(host, ssl=cls.https_enabled(base) and cls.covers(host)),
'dns': dns, 'nginx': nginx, 'warning': warning}
diff --git a/backend/migrations/versions/040_site_base_domains.py b/backend/migrations/versions/040_site_base_domains.py
new file mode 100644
index 00000000..954d64e3
--- /dev/null
+++ b/backend/migrations/versions/040_site_base_domains.py
@@ -0,0 +1,55 @@
+"""Registry of base domains managed sites can be published under.
+
+Adds:
+- site_base_domains (one row per base domain, e.g. example.com / toto.com; each
+ with its own DNS provider + wildcard-cert state; exactly one is the default)
+
+Rows are seeded lazily by SiteBaseDomainService.ensure_seeded from the legacy
+``sites_base_domain`` setting the first time a second domain is registered, so
+this migration only creates the (empty) table.
+
+Idempotent: MigrationService runs _fix_missing_columns() + db.create_all() on boot
+before Alembic, so guard on the live schema.
+
+Revision ID: 040_site_base_domains
+Revises: 039_deployment_job_links
+Create Date: 2026-07-01
+"""
+from alembic import op
+import sqlalchemy as sa
+
+revision = '040_site_base_domains'
+down_revision = '039_deployment_job_links'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+ conn = op.get_bind()
+ inspector = sa.inspect(conn)
+ existing = set(inspector.get_table_names())
+
+ if 'site_base_domains' not in existing:
+ op.create_table(
+ 'site_base_domains',
+ sa.Column('id', sa.Integer, nullable=False),
+ sa.Column('domain', sa.String(253), nullable=False),
+ sa.Column('is_default', sa.Boolean, nullable=False, server_default=sa.false()),
+ sa.Column('dns_mode', sa.String(20), nullable=False, server_default='wildcard'),
+ sa.Column('https_enabled', sa.Boolean, nullable=False, server_default=sa.false()),
+ sa.Column('dns_provider_config_id', sa.Integer, nullable=True),
+ sa.Column('created_at', sa.DateTime, nullable=True),
+ sa.Column('updated_at', sa.DateTime, nullable=True),
+ sa.PrimaryKeyConstraint('id'),
+ sa.ForeignKeyConstraint(['dns_provider_config_id'], ['dns_provider_configs.id'],
+ ondelete='SET NULL'),
+ sa.UniqueConstraint('domain', name='uq_site_base_domain'),
+ )
+
+
+def downgrade():
+ conn = op.get_bind()
+ inspector = sa.inspect(conn)
+ existing = set(inspector.get_table_names())
+ if 'site_base_domains' in existing:
+ op.drop_table('site_base_domains')
diff --git a/backend/tests/test_site_base_domains.py b/backend/tests/test_site_base_domains.py
new file mode 100644
index 00000000..f1f9639d
--- /dev/null
+++ b/backend/tests/test_site_base_domains.py
@@ -0,0 +1,127 @@
+"""Proving tests for the base-domain registry (multiple base domains).
+
+A managed site can be published under any registered base domain — a.example.com
+or a.toto.com — each with its own DNS mode / HTTPS state, defaulting to the one
+marked default. Back-compat: the legacy single ``sites_base_domain`` setting is
+materialised into the default row the first time a second domain is registered.
+"""
+
+
+def _set(key, value):
+ from app import db
+ from app.services.settings_service import SettingsService
+ SettingsService.set(key, value)
+ db.session.commit()
+
+
+def _mk_app(name='Acme', port=8500, app_type='docker'):
+ from app import db
+ from app.models import User, Application
+ from werkzeug.security import generate_password_hash
+ u = User(email=f'{name}@bd.local', username=f'bd-{name}'.replace(' ', '-').lower(),
+ password_hash=generate_password_hash('x'), role=User.ROLE_ADMIN, is_active=True)
+ db.session.add(u)
+ db.session.commit()
+ a = Application(name=name, app_type=app_type, user_id=u.id, root_path=f'/srv/{name}', port=port)
+ db.session.add(a)
+ db.session.commit()
+ return a
+
+
+# ── seeding + registry CRUD ──────────────────────────────────────────────────
+
+def test_add_seeds_legacy_default_then_registers_new(app, monkeypatch):
+ from app.services.site_base_domain_service import SiteBaseDomainService
+ from app.services.site_domain_service import SiteDomainService
+ _set('sites_base_domain', 'example.com')
+ _set('sites_https_enabled', True)
+
+ res = SiteBaseDomainService.add('toto.com')
+ assert res['success']
+ domains = [r.domain for r in SiteBaseDomainService.list_rows()]
+ assert domains == ['example.com', 'toto.com'] # default sorts first
+ # The legacy domain became the default row, carrying its HTTPS state.
+ assert SiteDomainService.base_domain() == 'example.com'
+ assert SiteBaseDomainService.default().domain == 'example.com'
+ assert SiteBaseDomainService.get('example.com').https_enabled is True
+ assert SiteBaseDomainService.get('toto.com').is_default is False
+
+
+def test_add_make_default_demotes_others(app, monkeypatch):
+ from app.services.site_base_domain_service import SiteBaseDomainService
+ _set('sites_base_domain', 'example.com')
+ SiteBaseDomainService.add('toto.com', make_default=True)
+ assert SiteBaseDomainService.default().domain == 'toto.com'
+ assert SiteBaseDomainService.get('example.com').is_default is False
+
+
+def test_remove_default_promotes_successor(app, monkeypatch):
+ from app.services.site_base_domain_service import SiteBaseDomainService
+ from app.services.site_domain_service import SiteDomainService
+ _set('sites_base_domain', 'example.com')
+ SiteBaseDomainService.add('toto.com')
+ SiteBaseDomainService.remove('example.com')
+ assert SiteDomainService.base_domain() == 'toto.com'
+ assert SiteBaseDomainService.default().domain == 'toto.com'
+
+
+def test_invalid_domain_rejected(app, monkeypatch):
+ from app.services.site_base_domain_service import SiteBaseDomainService
+ assert SiteBaseDomainService.add('not a domain').get('success') is False
+ assert SiteBaseDomainService.add('nodots').get('success') is False
+
+
+# ── base-aware resolution in SiteDomainService ───────────────────────────────
+
+def test_subdomain_for_picks_the_named_base(app, monkeypatch):
+ from app.services.site_base_domain_service import SiteBaseDomainService
+ from app.services.site_domain_service import SiteDomainService
+ _set('sites_base_domain', 'example.com')
+ SiteBaseDomainService.add('toto.com')
+ assert SiteDomainService.subdomain_for('My Blog') == 'my-blog.example.com'
+ assert SiteDomainService.subdomain_for('My Blog', base='toto.com') == 'my-blog.toto.com'
+ # An unregistered base falls back to the default, never publishes under it.
+ assert SiteDomainService.subdomain_for('X', base='unmanaged.net') == 'x.example.com'
+
+
+def test_covering_base_longest_match(app, monkeypatch):
+ from app.services.site_base_domain_service import SiteBaseDomainService
+ from app.services.site_domain_service import SiteDomainService
+ _set('sites_base_domain', 'example.com')
+ SiteBaseDomainService.add('apps.example.com') # more specific base
+ SiteBaseDomainService.add('toto.com')
+ assert SiteDomainService.covering_base('a.toto.com') == 'toto.com'
+ assert SiteDomainService.covering_base('a.apps.example.com') == 'apps.example.com'
+ assert SiteDomainService.covering_base('a.example.com') == 'example.com'
+ assert SiteDomainService.covers('a.nope.net') is False
+
+
+def test_https_and_dns_mode_are_per_base(app, monkeypatch):
+ from app.services.site_base_domain_service import SiteBaseDomainService
+ from app.services.site_domain_service import SiteDomainService
+ _set('sites_base_domain', 'example.com')
+ _set('sites_https_enabled', True) # seeds example.com https=on
+ SiteBaseDomainService.add('toto.com', dns_mode='per-site')
+ assert SiteDomainService.https_enabled('example.com') is True
+ assert SiteDomainService.https_enabled('toto.com') is False
+ assert SiteDomainService.dns_mode('example.com') == 'wildcard'
+ assert SiteDomainService.dns_mode('toto.com') == 'per-site'
+ fc, key = SiteDomainService.wildcard_cert_paths('toto.com')
+ assert fc.endswith('/toto.com/fullchain.pem')
+
+
+def test_give_subdomain_under_chosen_base(app, monkeypatch):
+ from app.services.site_base_domain_service import SiteBaseDomainService
+ from app.services.site_domain_service import SiteDomainService
+ from app.services.nginx_service import NginxService
+ from app.models.domain import Domain
+ _set('sites_base_domain', 'example.com')
+ SiteBaseDomainService.add('toto.com')
+ a = _mk_app(name='Shop', port=8600)
+
+ monkeypatch.setattr(NginxService, 'create_site', staticmethod(lambda **k: {'success': True}))
+ monkeypatch.setattr(NginxService, 'enable_site', staticmethod(lambda name: {'success': True}))
+
+ res = SiteDomainService.give_subdomain(a, base='toto.com')
+ assert res['success'] and res['host'] == 'shop.toto.com'
+ assert Domain.query.filter_by(name='shop.toto.com', application_id=a.id).first() is not None