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(dns): unify Cloudflare credentials behind one connection + shared client

Juan Denis1127243d1d06
diff --git a/.gitignore b/.gitignore
index 5fb1d6fb..ff9f7468 100644
--- a/.gitignore
+++ b/.gitignore
@@ -142,3 +142,4 @@ docs/UI_CONSISTENCY_AUDIT.md
docs/REMOTE_ACCESS_ROADMAP.md
docs/NOTIFICATIONS_ROADMAP.md
docs/ORCHESTRATION_ROADMAP.md
+docs/DNS_ROADMAP.md
diff --git a/backend/app/__init__.py b/backend/app/__init__.py
index abf6d105..1ec09286 100644
--- a/backend/app/__init__.py
+++ b/backend/app/__init__.py
@@ -391,12 +391,17 @@ def create_app(config_name=None):
n_store = StorageProviderService.encrypt_legacy_secrets()
n_cloud = CloudProvisioningService.encrypt_legacy_secrets()
n_settings = SettingsService.migrate_legacy_secrets()
- if n_dns or n_store or n_cloud or n_settings:
+ # Migrate DNS zones with an inline Cloudflare token onto the canonical
+ # connection store (idempotent), so every zone resolves creds the same way.
+ from app.services.dns_zone_service import DNSZoneService
+ n_zones = DNSZoneService.link_legacy_zones()
+ if n_dns or n_store or n_cloud or n_settings or n_zones:
import logging as _logging
_logging.getLogger(__name__).info(
f'Encrypted legacy secrets at rest: {n_dns} DNS provider(s), '
f'{n_store} storage field(s), {n_cloud} cloud provider(s), '
- f'{n_settings} system setting(s)')
+ f'{n_settings} system setting(s); linked {n_zones} DNS zone(s) '
+ f'to a connection')
except Exception as e:
import logging as _logging
_logging.getLogger(__name__).warning(f'Legacy secret encryption skipped: {e}')
diff --git a/backend/app/models/dns_zone.py b/backend/app/models/dns_zone.py
index 63743190..f2e29aee 100644
--- a/backend/app/models/dns_zone.py
+++ b/backend/app/models/dns_zone.py
@@ -11,7 +11,13 @@ class DNSZone(db.Model):
domain = db.Column(db.String(256), nullable=False, unique=True)
provider = db.Column(db.String(64)) # cloudflare, route53, digitalocean, manual
provider_zone_id = db.Column(db.String(128))
- provider_config_json = db.Column(db.Text) # encrypted credentials
+ provider_config_json = db.Column(db.Text) # legacy inline credentials (pre-unification)
+
+ # Canonical credential link: the DNSProviderConfig (Settings -> Connections)
+ # whose API token manages this zone. Supersedes the inline token in
+ # provider_config_json; nullable so manual zones and not-yet-migrated rows work.
+ dns_provider_config_id = db.Column(
+ db.Integer, db.ForeignKey('dns_provider_configs.id'), nullable=True)
status = db.Column(db.String(32), default='active')
last_sync_at = db.Column(db.DateTime)
@@ -35,6 +41,7 @@ class DNSZone(db.Model):
'domain': self.domain,
'provider': self.provider,
'provider_zone_id': self.provider_zone_id,
+ 'dns_provider_config_id': self.dns_provider_config_id,
'status': self.status,
'record_count': self.records.count(),
'last_sync_at': self.last_sync_at.isoformat() if self.last_sync_at else None,
diff --git a/backend/app/services/dns/__init__.py b/backend/app/services/dns/__init__.py
new file mode 100644
index 00000000..0fdd69b8
--- /dev/null
+++ b/backend/app/services/dns/__init__.py
@@ -0,0 +1,23 @@
+"""Shared, provider-agnostic DNS client layer.
+
+Both ``DNSProviderService`` (provider/credentials layer) and ``DNSZoneService``
+(zone/records layer) build a :class:`DnsCredential` + :class:`DnsRecordSpec` and
+talk to a provider through :func:`get_client`, so the API wire format for a given
+provider lives in exactly one module.
+"""
+from app.services.dns.base import DnsCredential, DnsRecordSpec
+from app.services.dns.cloudflare import CloudflareClient
+
+__all__ = ['DnsCredential', 'DnsRecordSpec', 'CloudflareClient', 'get_client']
+
+
+def get_client(credential: DnsCredential):
+ """Return the API client for ``credential.provider``.
+
+ Only Cloudflare is shared today (it was the duplicated path); Route53 /
+ DigitalOcean / GoDaddy still live in ``DNSProviderService`` and can move
+ behind this factory later without changing callers.
+ """
+ if credential.provider == 'cloudflare':
+ return CloudflareClient(credential)
+ raise ValueError(f'No shared DNS client for provider: {credential.provider}')
diff --git a/backend/app/services/dns/base.py b/backend/app/services/dns/base.py
new file mode 100644
index 00000000..b9e338b0
--- /dev/null
+++ b/backend/app/services/dns/base.py
@@ -0,0 +1,68 @@
+"""Provider-agnostic DNS primitives shared by both Cloudflare code paths.
+
+A single :class:`~app.services.dns.cloudflare.CloudflareClient` is driven from
+*both* layers that talk to Cloudflare:
+
+* ``DNSProviderService`` — credentials in the ``DNSProviderConfig`` table
+ (email DKIM/SPF/DMARC + WordPress custom-domain auto-DNS), and
+* ``DNSZoneService`` — the ``/dns`` Zones page and Dynamic DNS.
+
+Before this, each maintained its *own* Cloudflare request/payload code, so
+wire-format fixes (e.g. CAA's structured ``data`` object) had to be made twice
+and drifted apart. These dataclasses are the normalized inputs both callers
+build, so the API specifics live in exactly one place.
+"""
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class DnsCredential:
+ """Normalized DNS-provider credential, decoupled from where it's stored."""
+
+ provider: str
+ token: Optional[str] = None # bearer token / primary API key
+ email: Optional[str] = None # set => Cloudflare global-key auth mode
+ secret: Optional[str] = None # second secret (Route53 / GoDaddy)
+
+ @classmethod
+ def from_provider_config(cls, config) -> 'DnsCredential':
+ """Build from a ``DNSProviderConfig`` row, decrypting secrets at point of
+ use (never read ``config.api_key`` directly — it's encrypted at rest)."""
+ from app.services.dns_provider_service import DNSProviderService
+ creds = DNSProviderService.decrypted_credentials(config)
+ return cls(
+ provider=config.provider,
+ token=creds.get('api_key'),
+ email=creds.get('api_email'),
+ secret=creds.get('api_secret'),
+ )
+
+ @classmethod
+ def cloudflare_token(cls, token: str) -> 'DnsCredential':
+ """Build a scoped-token Cloudflare credential (legacy zone-config path)."""
+ return cls(provider='cloudflare', token=token)
+
+
+@dataclass
+class DnsRecordSpec:
+ """A DNS record to create/update, independent of the provider wire format."""
+
+ record_type: str
+ name: str # FQDN (e.g. "www.example.com" or the apex)
+ content: str
+ ttl: int = 3600
+ priority: Optional[int] = None # MX / SRV
+ proxied: bool = False # Cloudflare orange-cloud
+
+ @classmethod
+ def from_record(cls, record) -> 'DnsRecordSpec':
+ """Build from a ``DNSRecord`` ORM row."""
+ return cls(
+ record_type=record.record_type,
+ name=record.name,
+ content=record.content,
+ ttl=record.ttl or 3600,
+ priority=record.priority,
+ proxied=bool(record.proxied),
+ )
diff --git a/backend/app/services/dns/cloudflare.py b/backend/app/services/dns/cloudflare.py
new file mode 100644
index 00000000..5bfc1a13
--- /dev/null
+++ b/backend/app/services/dns/cloudflare.py
@@ -0,0 +1,184 @@
+"""The single Cloudflare DNS API client used by every Cloudflare path in ServerKit.
+
+Centralizes, in one place:
+
+* **auth** — scoped API token (``Authorization: Bearer``) *or* global key
+ (``X-Auth-Email`` + ``X-Auth-Key``),
+* the **CAA** structured-``data`` wire format (Cloudflare rejects a flat
+ ``content`` string for CAA),
+* **MX/SRV priority** parsing (a leading integer in the value), and
+* **idempotent upsert** — update an existing record (by id when known, else by
+ name) instead of blindly POSTing a duplicate.
+
+Both ``DNSProviderService`` (provider layer) and ``DNSZoneService`` (zone layer)
+delegate here, so a wire-format fix is made once rather than twice.
+"""
+import logging
+
+import requests
+
+from app.services.dns.base import DnsCredential, DnsRecordSpec
+
+logger = logging.getLogger(__name__)
+
+API_BASE = 'https://api.cloudflare.com/client/v4'
+
+
+def parse_caa_value(value: str) -> dict:
+ """Parse a BIND-style CAA value (``0 issue "letsencrypt.org"``) into the
+ ``{flags, tag, value}`` object Cloudflare expects. The CA value is unquoted.
+ Kept here so the CAA wire format lives in exactly one place."""
+ parts = (value or '').strip().split(None, 2)
+ flags = int(parts[0]) if parts and parts[0].lstrip('-').isdigit() else 0
+ tag = parts[1] if len(parts) > 1 else 'issue'
+ ca = parts[2].strip().strip('"') if len(parts) > 2 else ''
+ return {'flags': flags, 'tag': tag, 'value': ca}
+
+
+def _first_error(data: dict) -> str:
+ try:
+ return (data.get('errors') or [{}])[0].get('message', 'Unknown error')
+ except Exception:
+ return 'Unknown error'
+
+
+class CloudflareClient:
+ """Stateless wrapper around the Cloudflare v4 DNS API for one credential."""
+
+ def __init__(self, credential: DnsCredential):
+ self.cred = credential
+
+ # ── auth ────────────────────────────────────────────────────────────────
+ def _headers(self) -> dict:
+ if self.cred.email:
+ return {
+ 'X-Auth-Email': self.cred.email,
+ 'X-Auth-Key': self.cred.token or '',
+ 'Content-Type': 'application/json',
+ }
+ return {
+ 'Authorization': f'Bearer {self.cred.token or ""}',
+ 'Content-Type': 'application/json',
+ }
+
+ # ── connection / zones ──────────────────────────────────────────────────
+ def verify(self) -> dict:
+ """Verify the credential (token scope check)."""
+ try:
+ resp = requests.get(f'{API_BASE}/user/tokens/verify',
+ headers=self._headers(), timeout=15)
+ data = resp.json()
+ if data.get('success'):
+ return {'success': True, 'message': 'Cloudflare connection successful'}
+ return {'success': False, 'error': _first_error(data)}
+ except Exception as e:
+ return {'success': False, 'error': str(e)}
+
+ def list_zones(self) -> dict:
+ """List the zones this credential can manage."""
+ try:
+ resp = requests.get(f'{API_BASE}/zones?per_page=50',
+ headers=self._headers(), timeout=15)
+ data = resp.json()
+ if not data.get('success'):
+ return {'success': False, 'error': _first_error(data) or 'Failed to list zones'}
+ zones = [{'id': z['id'], 'name': z['name'], 'status': z['status']}
+ for z in data.get('result', [])]
+ return {'success': True, 'zones': zones}
+ except Exception as e:
+ return {'success': False, 'error': str(e)}
+
+ # ── records ─────────────────────────────────────────────────────────────
+ def _payload(self, spec: DnsRecordSpec) -> dict:
+ """Render a record spec into a Cloudflare ``dns_records`` payload."""
+ payload = {'type': spec.record_type, 'name': spec.name, 'ttl': spec.ttl}
+
+ # CAA needs Cloudflare's structured `data` object, not a flat `content`
+ # string (and `proxied`/`priority` are meaningless for it).
+ if spec.record_type == 'CAA':
+ payload['data'] = parse_caa_value(spec.content)
+ return payload
+
+ content, priority = spec.content, spec.priority
+ # MX/SRV may carry a leading priority in the value ("10 mail.example.com")
+ # — split it out so Cloudflare gets a separate `priority` field.
+ if spec.record_type in ('MX', 'SRV') and priority is None:
+ head, _, rest = (spec.content or '').strip().partition(' ')
+ if head.isdigit() and rest.strip():
+ priority, content = int(head), rest.strip()
+
+ payload['content'] = content
+ payload['proxied'] = bool(spec.proxied)
+ if priority is not None:
+ payload['priority'] = priority
+ return payload
+
+ def find_record_id(self, zone_id: str, record_type: str, name: str,
+ caa: dict = None):
+ """Return the id of an existing record matching ``type``+``name`` (and, for
+ CAA, the same CA), or ``None``. CAA is matched on tag+value so a *different*
+ CA's authorization is never clobbered."""
+ resp = requests.get(
+ f'{API_BASE}/zones/{zone_id}/dns_records?type={record_type}&name={name}',
+ headers=self._headers(), timeout=15,
+ )
+ existing = (resp.json() or {}).get('result', []) or []
+ if caa is not None:
+ existing = [
+ r for r in existing
+ if (r.get('data') or {}).get('tag') == caa['tag']
+ and str((r.get('data') or {}).get('value', '')).strip('"').rstrip('.').lower()
+ == caa['value'].rstrip('.').lower()
+ ]
+ return existing[0]['id'] if existing else None
+
+ def upsert(self, zone_id: str, spec: DnsRecordSpec, record_id: str = None) -> dict:
+ """Create or update a record idempotently.
+
+ If ``record_id`` is known, PUT it directly; otherwise look up a matching
+ record by name and PUT it, else POST a new one. Returns
+ ``{success, record_id?, error?}`` so callers can persist the id.
+ """
+ try:
+ base = f'{API_BASE}/zones/{zone_id}/dns_records'
+ payload = self._payload(spec)
+
+ if record_id is None:
+ caa = payload.get('data') if spec.record_type == 'CAA' else None
+ record_id = self.find_record_id(zone_id, spec.record_type, spec.name, caa=caa)
+
+ if record_id:
+ resp = requests.put(f'{base}/{record_id}', headers=self._headers(),
+ json=payload, timeout=15)
+ else:
+ resp = requests.post(base, headers=self._headers(),
+ json=payload, timeout=15)
+
+ data = resp.json()
+ if data.get('success'):
+ rid = (data.get('result') or {}).get('id') or record_id
+ return {'success': True, 'record_id': rid,
+ 'message': f'{spec.record_type} record set for {spec.name}'}
+ return {'success': False, 'error': _first_error(data)}
+ except Exception as e:
+ return {'success': False, 'error': str(e)}
+
+ def delete(self, zone_id: str, *, record_id: str = None,
+ record_type: str = None, name: str = None) -> dict:
+ """Delete by ``record_id`` when known, else by ``type``+``name`` (removes
+ every match). A missing record is treated as success (already gone)."""
+ try:
+ base = f'{API_BASE}/zones/{zone_id}/dns_records'
+ if record_id:
+ ids = [record_id]
+ else:
+ resp = requests.get(f'{base}?type={record_type}&name={name}',
+ headers=self._headers(), timeout=15)
+ ids = [r['id'] for r in (resp.json() or {}).get('result', []) or []]
+ if not ids:
+ return {'success': True, 'message': 'Record not found (already deleted)'}
+ for rid in ids:
+ requests.delete(f'{base}/{rid}', headers=self._headers(), timeout=15)
+ return {'success': True, 'message': 'Record deleted'}
+ except Exception as e:
+ return {'success': False, 'error': str(e)}
diff --git a/backend/app/services/dns_provider_service.py b/backend/app/services/dns_provider_service.py
index 05973ec7..09628c0c 100644
--- a/backend/app/services/dns_provider_service.py
+++ b/backend/app/services/dns_provider_service.py
@@ -142,14 +142,17 @@ class DNSProviderService:
@classmethod
def set_record(cls, provider_id: int, zone_id: str, record_type: str,
- name: str, value: str, ttl: int = 3600) -> Dict:
- """Create or update a DNS record."""
+ name: str, value: str, ttl: int = 3600,
+ proxied: bool = False, priority: int = None) -> Dict:
+ """Create or update a DNS record. ``proxied``/``priority`` are honored by
+ the Cloudflare path; other providers ignore them."""
config = DNSProviderConfig.query.get(provider_id)
if not config:
return {'success': False, 'error': 'Provider not found'}
if config.provider == 'cloudflare':
- return cls._cloudflare_set_record(config, zone_id, record_type, name, value, ttl)
+ return cls._cloudflare_set_record(config, zone_id, record_type, name, value, ttl,
+ proxied=proxied, priority=priority)
elif config.provider == 'route53':
return cls._route53_set_record(config, zone_id, record_type, name, value, ttl)
elif config.provider == 'digitalocean':
@@ -257,12 +260,10 @@ class DNSProviderService:
def parse_caa_value(value: str) -> Dict:
"""Parse a BIND-style CAA value (``0 issue "letsencrypt.org"``) into the
``{flags, tag, value}`` object that Cloudflare/DigitalOcean expect. The
- CA value is returned unquoted."""
- parts = (value or '').strip().split(None, 2)
- flags = int(parts[0]) if parts and parts[0].lstrip('-').isdigit() else 0
- tag = parts[1] if len(parts) > 1 else 'issue'
- ca = parts[2].strip().strip('"') if len(parts) > 2 else ''
- return {'flags': flags, 'tag': tag, 'value': ca}
+ CA value is returned unquoted. Delegates to the shared Cloudflare client
+ so the CAA wire format is defined in exactly one place."""
+ from app.services.dns.cloudflare import parse_caa_value as _parse
+ return _parse(value)
@classmethod
def ensure_caa_record(cls, domain: str, ca: str = 'letsencrypt.org') -> Dict:
@@ -300,130 +301,48 @@ class DNSProviderService:
# ── Cloudflare Implementation ──
+ # The Cloudflare API calls live in the shared CloudflareClient so the
+ # provider layer (here) and the zone layer (DNSZoneService) share one
+ # implementation — auth, the CAA `data` wire format, and idempotent upsert
+ # are defined once rather than maintained in two places.
+
@classmethod
- def _cloudflare_headers(cls, config: DNSProviderConfig) -> Dict:
- """Build Cloudflare API headers."""
- if config.api_email:
- return {
- 'X-Auth-Email': config.api_email,
- 'X-Auth-Key': cls._api_key(config),
- 'Content-Type': 'application/json',
- }
- return {
- 'Authorization': f'Bearer {cls._api_key(config)}',
- 'Content-Type': 'application/json',
- }
+ def _cloudflare_client(cls, config: DNSProviderConfig):
+ from app.services.dns import CloudflareClient
+ from app.services.dns.base import DnsCredential
+ return CloudflareClient(DnsCredential.from_provider_config(config))
@classmethod
def _test_cloudflare(cls, config: DNSProviderConfig) -> Dict:
"""Test Cloudflare API connection."""
- try:
- resp = requests.get(
- 'https://api.cloudflare.com/client/v4/user/tokens/verify',
- headers=cls._cloudflare_headers(config),
- timeout=15,
- )
- data = resp.json()
- if data.get('success'):
- return {'success': True, 'message': 'Cloudflare connection successful'}
- return {'success': False, 'error': data.get('errors', [{}])[0].get('message', 'Unknown error')}
- except Exception as e:
- return {'success': False, 'error': str(e)}
+ return cls._cloudflare_client(config).verify()
@classmethod
def _cloudflare_list_zones(cls, config: DNSProviderConfig) -> Dict:
"""List Cloudflare zones."""
- try:
- resp = requests.get(
- 'https://api.cloudflare.com/client/v4/zones?per_page=50',
- headers=cls._cloudflare_headers(config),
- timeout=15,
- )
- data = resp.json()
- if not data.get('success'):
- return {'success': False, 'error': 'Failed to list zones'}
- zones = [{'id': z['id'], 'name': z['name'], 'status': z['status']}
- for z in data.get('result', [])]
- return {'success': True, 'zones': zones}
- except Exception as e:
- return {'success': False, 'error': str(e)}
+ return cls._cloudflare_client(config).list_zones()
@classmethod
def _cloudflare_set_record(cls, config: DNSProviderConfig, zone_id: str,
- record_type: str, name: str, value: str, ttl: int) -> Dict:
- """Create or update a Cloudflare DNS record."""
- try:
- headers = cls._cloudflare_headers(config)
- base = f'https://api.cloudflare.com/client/v4/zones/{zone_id}/dns_records'
-
- # CAA records need Cloudflare's structured `data` object, not a flat
- # `content` string — sending `content` for a CAA record is rejected.
- caa = cls.parse_caa_value(value) if record_type == 'CAA' else None
- payload = {'type': record_type, 'name': name, 'ttl': ttl}
- if caa is not None:
- payload['data'] = caa
- else:
- payload['content'] = value
-
- # Check if a matching record exists. For CAA there can legitimately be
- # several records at the same name (one per CA), so match on tag+value
- # to avoid overwriting a *different* CA's authorization.
- resp = requests.get(
- f'{base}?type={record_type}&name={name}',
- headers=headers, timeout=15,
- )
- data = resp.json()
- existing = data.get('result', [])
- if caa is not None:
- existing = [
- r for r in existing
- if (r.get('data') or {}).get('tag') == caa['tag']
- and str((r.get('data') or {}).get('value', '')).strip('"').rstrip('.').lower()
- == caa['value'].rstrip('.').lower()
- ]
-
- if existing:
- # Update existing record
- record_id = existing[0]['id']
- resp = requests.put(
- f'{base}/{record_id}',
- headers=headers, json=payload, timeout=15,
- )
- else:
- # Create new record
- resp = requests.post(base, headers=headers, json=payload, timeout=15)
-
- data = resp.json()
- if data.get('success'):
- return {'success': True, 'message': f'{record_type} record set for {name}'}
- return {'success': False, 'error': data.get('errors', [{}])[0].get('message', 'Unknown error')}
- except Exception as e:
- return {'success': False, 'error': str(e)}
+ record_type: str, name: str, value: str, ttl: int,
+ proxied: bool = False, priority: int = None) -> Dict:
+ """Create or update a Cloudflare DNS record (idempotent upsert by name)."""
+ from app.services.dns.base import DnsRecordSpec
+ spec = DnsRecordSpec(record_type=record_type, name=name, content=value,
+ ttl=ttl, priority=priority, proxied=proxied)
+ res = cls._cloudflare_client(config).upsert(zone_id, spec)
+ # Preserve the historical {success, message|error} contract callers expect.
+ if res.get('success'):
+ return {'success': True,
+ 'message': res.get('message', f'{record_type} record set for {name}')}
+ return {'success': False, 'error': res.get('error', 'Unknown error')}
@classmethod
def _cloudflare_delete_record(cls, config: DNSProviderConfig, zone_id: str,
record_type: str, name: str) -> Dict:
- """Delete a Cloudflare DNS record."""
- try:
- headers = cls._cloudflare_headers(config)
- base = f'https://api.cloudflare.com/client/v4/zones/{zone_id}/dns_records'
-
- resp = requests.get(
- f'{base}?type={record_type}&name={name}',
- headers=headers, timeout=15,
- )
- data = resp.json()
- existing = data.get('result', [])
-
- if not existing:
- return {'success': True, 'message': 'Record not found (already deleted)'}
-
- for record in existing:
- requests.delete(f'{base}/{record["id"]}', headers=headers, timeout=15)
-
- return {'success': True, 'message': f'{record_type} record deleted for {name}'}
- except Exception as e:
- return {'success': False, 'error': str(e)}
+ """Delete a Cloudflare DNS record (by type+name)."""
+ return cls._cloudflare_client(config).delete(
+ zone_id, record_type=record_type, name=name)
@staticmethod
def _host_relative_to_zone(name: str, zone: str) -> str:
diff --git a/backend/app/services/dns_zone_service.py b/backend/app/services/dns_zone_service.py
index 5ebf9640..2ceb2671 100644
--- a/backend/app/services/dns_zone_service.py
+++ b/backend/app/services/dns_zone_service.py
@@ -55,13 +55,82 @@ class DNSZoneService:
provider=data.get('provider', 'manual'),
provider_zone_id=data.get('provider_zone_id'),
)
- if data.get('provider_config'):
+
+ # Preferred path: link an existing connection (Settings -> Connections).
+ # The zone adopts its provider, and we look up the provider-side zone id
+ # for this domain so records sync without a second token.
+ config_id = data.get('dns_provider_config_id')
+ if config_id:
+ from app.models.email import DNSProviderConfig
+ from app.services.dns_provider_service import DNSProviderService
+ config = DNSProviderConfig.query.get(int(config_id))
+ if not config:
+ raise ValueError('Selected DNS connection not found')
+ zone.provider = config.provider
+ zone.dns_provider_config_id = config.id
+ if not zone.provider_zone_id:
+ zres = DNSProviderService.list_zones(config.id)
+ if not zres.get('success'):
+ raise ValueError(
+ f"Couldn't reach {config.name}: {zres.get('error', 'unknown error')}")
+ match = next((z for z in zres.get('zones', [])
+ if (z.get('name') or '').lower().rstrip('.') == domain), None)
+ if not match:
+ raise ValueError(f'{config.name} does not manage {domain}')
+ zone.provider_zone_id = match['id']
+ elif data.get('provider_config'):
+ # Legacy inline-token path, kept for backward compatibility.
zone.provider_config = data['provider_config']
db.session.add(zone)
db.session.commit()
return zone
+ @classmethod
+ def link_legacy_zones(cls):
+ """One-time, idempotent: migrate Cloudflare zones that still carry an inline
+ token in ``provider_config_json`` onto the canonical ``DNSProviderConfig``
+ store, so every zone resolves its credentials the same way.
+
+ For each such zone: reuse an existing connection whose decrypted key matches
+ the token, else mint one (encrypted at rest), link it, and strip the now
+ redundant plaintext token from the zone. API-free — uses the token already
+ on the zone. Returns the number of zones migrated."""
+ from app.models.email import DNSProviderConfig
+ from app.services.dns_provider_service import DNSProviderService
+ from app.utils.crypto import encrypt_secret
+
+ migrated = 0
+ zones = DNSZone.query.filter(
+ DNSZone.provider == 'cloudflare',
+ DNSZone.dns_provider_config_id.is_(None),
+ ).all()
+ for zone in zones:
+ token = (zone.provider_config or {}).get('api_token')
+ if not token:
+ continue
+ match = None
+ for cfg in DNSProviderConfig.query.filter_by(provider='cloudflare').all():
+ if DNSProviderService._api_key(cfg) == token:
+ match = cfg
+ break
+ if match is None:
+ match = DNSProviderConfig(
+ name=f'Cloudflare ({zone.domain})',
+ provider='cloudflare',
+ api_key=encrypt_secret(token),
+ )
+ db.session.add(match)
+ db.session.flush() # assign id
+ zone.dns_provider_config_id = match.id
+ cfg_json = dict(zone.provider_config or {})
+ cfg_json.pop('api_token', None)
+ zone.provider_config = cfg_json
+ migrated += 1
+ if migrated:
+ db.session.commit()
+ return migrated
+
@staticmethod
def delete_zone(zone_id):
zone = DNSZone.query.get(zone_id)
@@ -255,53 +324,82 @@ class DNSZoneService:
@staticmethod
def _sync_record_to_provider(zone, record, action):
- """Sync a DNS record change to the configured provider."""
- provider = zone.provider
- config = zone.provider_config
-
+ """Sync a DNS record change to Cloudflare (the only provider the zone layer
+ syncs — Route53/DigitalOcean/GoDaddy are managed via DNSProviderService)."""
+ if zone.provider != 'cloudflare':
+ return
+ credential = DNSZoneService._resolve_credential(zone)
+ if not credential:
+ return
try:
- if provider == 'cloudflare':
- DNSZoneService._cloudflare_sync(zone, record, action, config)
+ DNSZoneService._cloudflare_sync(zone, record, action, credential)
except Exception as e:
logger.error(f'DNS provider sync failed: {e}')
@staticmethod
- def _cloudflare_sync(zone, record, action, config):
- """Sync record to Cloudflare API."""
- import requests
+ def _resolve_credential(zone):
+ """Resolve the Cloudflare credential for a zone, preferring the canonical
+ connection store and persisting the discovered link.
+
+ Order:
+ 1. The linked DNSProviderConfig (``zone.dns_provider_config_id``).
+ 2. Auto-discovery — the connected provider whose account contains this
+ domain; the link + ``provider_zone_id`` are backfilled so step 1 wins
+ next time (no repeat API call).
+ 3. Legacy fallback — a token still stored inline on the zone.
+ Returns a :class:`DnsCredential`, or ``None`` when nothing manages the zone.
+ """
+ from app.models.email import DNSProviderConfig
from app.services.dns_provider_service import DNSProviderService
+ from app.services.dns.base import DnsCredential
- api_token = config.get('api_token')
- if not api_token:
- return
-
- headers = {'Authorization': f'Bearer {api_token}', 'Content-Type': 'application/json'}
- base_url = f'https://api.cloudflare.com/client/v4/zones/{zone.provider_zone_id}/dns_records'
+ if zone.dns_provider_config_id:
+ config = DNSProviderConfig.query.get(zone.dns_provider_config_id)
+ if config:
+ return DnsCredential.from_provider_config(config)
- def _payload():
- # CAA needs Cloudflare's structured `data` object, not a flat
- # `content` string (and `proxied` is meaningless for it).
- p = {'type': record.record_type, 'name': record.name, 'ttl': record.ttl}
- if record.record_type == 'CAA':
- p['data'] = DNSProviderService.parse_caa_value(record.content)
- else:
- p['content'] = record.content
- p['proxied'] = record.proxied
- if record.priority is not None:
- p['priority'] = record.priority
- return p
-
- if action == 'create':
- resp = requests.post(base_url, json=_payload(), headers=headers, timeout=10)
- if resp.ok:
- data = resp.json()
- record.provider_record_id = data.get('result', {}).get('id')
+ try:
+ config, zinfo = DNSProviderService.find_zone_for_domain(zone.domain)
+ except Exception:
+ config, zinfo = None, None
+ if config:
+ zone.dns_provider_config_id = config.id
+ if zinfo and not zone.provider_zone_id:
+ zone.provider_zone_id = zinfo.get('id')
+ try:
db.session.commit()
+ except Exception:
+ db.session.rollback()
+ return DnsCredential.from_provider_config(config)
- elif action == 'update' and record.provider_record_id:
- url = f'{base_url}/{record.provider_record_id}'
- requests.put(url, json=_payload(), headers=headers, timeout=10)
+ token = (zone.provider_config or {}).get('api_token')
+ if token:
+ return DnsCredential.cloudflare_token(token)
+ return None
+ @staticmethod
+ def _cloudflare_sync(zone, record, action, credential):
+ """Push a single record change to Cloudflare via the shared client.
+
+ ``upsert`` is idempotent: it updates by ``provider_record_id`` when known,
+ otherwise finds the record by name (so a re-create doesn't duplicate and an
+ update doesn't silently no-op when the id was never captured)."""
+ from app.services.dns import CloudflareClient
+ from app.services.dns.base import DnsRecordSpec
+
+ client = CloudflareClient(credential)
+ zone_id = zone.provider_zone_id
+
+ if action in ('create', 'update'):
+ res = client.upsert(zone_id, DnsRecordSpec.from_record(record),
+ record_id=record.provider_record_id)
+ if res.get('success'):
+ rid = res.get('record_id')
+ if rid and rid != record.provider_record_id:
+ record.provider_record_id = rid
+ db.session.commit()
+ else:
+ logger.error('Cloudflare sync %s failed for %s: %s',
+ action, record.name, res.get('error'))
elif action == 'delete' and record.provider_record_id:
- url = f'{base_url}/{record.provider_record_id}'
- requests.delete(url, headers=headers, timeout=10)
+ client.delete(zone_id, record_id=record.provider_record_id)
diff --git a/backend/migrations/versions/025_dns_provider_link.py b/backend/migrations/versions/025_dns_provider_link.py
new file mode 100644
index 00000000..779cb317
--- /dev/null
+++ b/backend/migrations/versions/025_dns_provider_link.py
@@ -0,0 +1,46 @@
+"""Link DNS zones to a canonical DNS provider connection.
+
+Adds:
+- dns_zones.dns_provider_config_id (-> dns_provider_configs.id)
+
+So the /dns Zones page and Dynamic DNS resolve Cloudflare credentials from the
+same DNSProviderConfig store used by Settings -> Connections, instead of a second
+token stashed inline in dns_zones.provider_config_json.
+
+Idempotent: MigrationService runs _fix_missing_columns() + db.create_all() on boot
+before Alembic, so guard on the live schema. The column is added without a DB-level
+FK constraint (SQLite can't ALTER one in), matching how the boot column-sync adds
+it; the ORM model carries the ForeignKey for relationship metadata.
+
+Revision ID: 025_dns_provider_link
+Revises: 024_email_providers
+Create Date: 2026-06-22
+"""
+from alembic import op
+import sqlalchemy as sa
+
+revision = '025_dns_provider_link'
+down_revision = '024_email_providers'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+ conn = op.get_bind()
+ inspector = sa.inspect(conn)
+ if 'dns_zones' not in set(inspector.get_table_names()):
+ return
+ cols = {c['name'] for c in inspector.get_columns('dns_zones')}
+ if 'dns_provider_config_id' not in cols:
+ op.add_column('dns_zones',
+ sa.Column('dns_provider_config_id', sa.Integer, nullable=True))
+
+
+def downgrade():
+ conn = op.get_bind()
+ inspector = sa.inspect(conn)
+ if 'dns_zones' not in set(inspector.get_table_names()):
+ return
+ cols = {c['name'] for c in inspector.get_columns('dns_zones')}
+ if 'dns_provider_config_id' in cols:
+ op.drop_column('dns_zones', 'dns_provider_config_id')
diff --git a/backend/tests/test_dns_cloudflare_client.py b/backend/tests/test_dns_cloudflare_client.py
new file mode 100644
index 00000000..3c4e5875
--- /dev/null
+++ b/backend/tests/test_dns_cloudflare_client.py
@@ -0,0 +1,188 @@
+"""Proving tests for the shared Cloudflare client (DNS unification #2).
+
+Both the provider layer (DNSProviderService) and the zone layer (DNSZoneService)
+now talk to Cloudflare through ``app.services.dns.cloudflare.CloudflareClient``.
+These tests pin the behavior that used to be duplicated (and had drifted):
+
+* auth header shape — scoped token vs global key,
+* CAA structured ``data`` (never a flat ``content``),
+* MX priority parsed out of the value,
+* idempotent upsert — PUT an existing record instead of POSTing a duplicate,
+* delete by id (no lookup) vs by name (lookup-then-delete),
+* and the zone path capturing ``provider_record_id`` after a create.
+
+Requests are stubbed by monkeypatching the ``requests`` object the client
+imported; ``requests`` is a shared module, so this also covers the provider
+layer's delegations.
+"""
+
+
+class _Resp:
+ def __init__(self, js):
+ self._js = js
+
+ def json(self):
+ return self._js
+
+
+def _client(token='tok', email=None):
+ from app.services.dns import cloudflare as cf
+ from app.services.dns.base import DnsCredential
+ return cf.CloudflareClient(DnsCredential(provider='cloudflare', token=token, email=email))
+
+
+# ── auth headers ─────────────────────────────────────────────────────────────
+
+def test_headers_scoped_token_vs_global_key():
+ bearer = _client(token='tok')._headers()
+ assert bearer['Authorization'] == 'Bearer tok'
+ assert 'X-Auth-Email' not in bearer
+
+ gk = _client(token='globalkey', email='[email protected]')._headers()
+ assert gk['X-Auth-Email'] == '[email protected]' and gk['X-Auth-Key'] == 'globalkey'
+ assert 'Authorization' not in gk
+
+
+# ── payload wire format ──────────────────────────────────────────────────────
+
+def test_payload_a_record_carries_proxied_not_data():
+ from app.services.dns.base import DnsRecordSpec
+ p = _client()._payload(DnsRecordSpec('A', 'www.example.com', '1.2.3.4', proxied=True))
+ assert p['content'] == '1.2.3.4' and p['proxied'] is True
+ assert 'data' not in p
+
+
+def test_payload_caa_uses_structured_data():
+ from app.services.dns.base import DnsRecordSpec
+ p = _client()._payload(DnsRecordSpec('CAA', 'example.com', '0 issue "letsencrypt.org"'))
+ assert p['data'] == {'flags': 0, 'tag': 'issue', 'value': 'letsencrypt.org'}
+ assert 'content' not in p and 'proxied' not in p
+
+
+def test_payload_mx_priority_parsed_from_value():
+ from app.services.dns.base import DnsRecordSpec
+ p = _client()._payload(DnsRecordSpec('MX', 'example.com', '10 mail.example.com'))
+ assert p['priority'] == 10 and p['content'] == 'mail.example.com'
+
+
+def test_payload_mx_explicit_priority_wins():
+ from app.services.dns.base import DnsRecordSpec
+ p = _client()._payload(DnsRecordSpec('MX', 'example.com', 'mail.example.com', priority=20))
+ assert p['priority'] == 20 and p['content'] == 'mail.example.com'
+
+
+# ── upsert (idempotent) ──────────────────────────────────────────────────────
+
+def test_upsert_posts_when_absent(monkeypatch):
+ from app.services.dns import cloudflare as cf
+ from app.services.dns.base import DnsRecordSpec
+ monkeypatch.setattr(cf.requests, 'get',
+ lambda url, headers=None, timeout=None: _Resp({'result': []}))
+ seen = {}
+ monkeypatch.setattr(cf.requests, 'post',
+ lambda url, headers=None, json=None, timeout=None:
+ (seen.update(verb='post', url=url) or
+ _Resp({'success': True, 'result': {'id': 'NEW'}})))
+ monkeypatch.setattr(cf.requests, 'put',
+ lambda *a, **k: (seen.update(verb='put') or _Resp({'success': False})))
+
+ res = _client().upsert('zoneABC', DnsRecordSpec('A', 'www.example.com', '1.2.3.4'))
+ assert res['success'] is True and res['record_id'] == 'NEW'
+ assert seen['verb'] == 'post' and seen['url'].endswith('/zones/zoneABC/dns_records')
+
+
+def test_upsert_puts_existing_match_by_name(monkeypatch):
+ from app.services.dns import cloudflare as cf
+ from app.services.dns.base import DnsRecordSpec
+ monkeypatch.setattr(cf.requests, 'get',
+ lambda url, headers=None, timeout=None: _Resp({'result': [{'id': 'rec1'}]}))
+ seen = {}
+ monkeypatch.setattr(cf.requests, 'put',
+ lambda url, headers=None, json=None, timeout=None:
+ (seen.update(url=url) or _Resp({'success': True, 'result': {'id': 'rec1'}})))
+ monkeypatch.setattr(cf.requests, 'post',
+ lambda *a, **k: (seen.update(verb='post') or _Resp({'success': False})))
+
+ res = _client().upsert('z', DnsRecordSpec('A', 'www.example.com', '5.6.7.8'))
+ assert res['record_id'] == 'rec1'
+ assert seen.get('verb') != 'post' and seen['url'].endswith('/rec1')
+
+
+def test_upsert_by_record_id_skips_lookup(monkeypatch):
+ from app.services.dns import cloudflare as cf
+ from app.services.dns.base import DnsRecordSpec
+ counters = {'get': 0}
+ monkeypatch.setattr(cf.requests, 'get',
+ lambda *a, **k: (counters.update(get=counters['get'] + 1) or _Resp({'result': []})))
+ seen = {}
+ monkeypatch.setattr(cf.requests, 'put',
+ lambda url, headers=None, json=None, timeout=None:
+ (seen.update(url=url) or _Resp({'success': True, 'result': {'id': 'rid'}})))
+
+ res = _client().upsert('z', DnsRecordSpec('A', 'www.example.com', '1.2.3.4'), record_id='rid')
+ assert res['success'] is True and counters['get'] == 0
+ assert seen['url'].endswith('/rid')
+
+
+# ── delete ───────────────────────────────────────────────────────────────────
+
+def test_delete_by_record_id_skips_lookup(monkeypatch):
+ from app.services.dns import cloudflare as cf
+ counters = {'get': 0}
+ monkeypatch.setattr(cf.requests, 'get',
+ lambda *a, **k: (counters.update(get=counters['get'] + 1) or _Resp({'result': []})))
+ deleted = []
+ monkeypatch.setattr(cf.requests, 'delete',
+ lambda url, headers=None, timeout=None: (deleted.append(url) or _Resp({'success': True})))
+
+ res = _client().delete('z', record_id='rid')
+ assert res['success'] is True and counters['get'] == 0
+ assert deleted == ['https://api.cloudflare.com/client/v4/zones/z/dns_records/rid']
+
+
+def test_delete_by_name_removes_all_matches(monkeypatch):
+ from app.services.dns import cloudflare as cf
+ monkeypatch.setattr(cf.requests, 'get',
+ lambda url, headers=None, timeout=None: _Resp({'result': [{'id': 'a'}, {'id': 'b'}]}))
+ deleted = []
+ monkeypatch.setattr(cf.requests, 'delete',
+ lambda url, headers=None, timeout=None: (deleted.append(url) or _Resp({'success': True})))
+
+ res = _client().delete('z', record_type='A', name='www.example.com')
+ assert res['success'] is True and len(deleted) == 2
+
+
+def test_delete_missing_is_success(monkeypatch):
+ from app.services.dns import cloudflare as cf
+ monkeypatch.setattr(cf.requests, 'get',
+ lambda url, headers=None, timeout=None: _Resp({'result': []}))
+ monkeypatch.setattr(cf.requests, 'delete',
+ lambda *a, **k: _Resp({'success': True}))
+ res = _client().delete('z', record_type='A', name='gone.example.com')
+ assert res['success'] is True and 'already deleted' in res['message']
+
+
+# ── zone layer regression: capture provider_record_id on create ──────────────
+
+def test_zone_create_record_persists_provider_record_id(app, monkeypatch):
+ """DNSZoneService.create_record on a Cloudflare zone must store the id Cloudflare
+ returns, so later updates/deletes address the record directly."""
+ from app import db
+ from app.models.dns_zone import DNSZone
+ from app.services.dns_zone_service import DNSZoneService
+ from app.services.dns import cloudflare as cf
+
+ zone = DNSZone(domain='example.com', provider='cloudflare', provider_zone_id='zoneABC')
+ zone.provider_config = {'api_token': 'tok'}
+ db.session.add(zone)
+ db.session.commit()
+
+ monkeypatch.setattr(cf.requests, 'get',
+ lambda url, headers=None, timeout=None: _Resp({'result': []}))
+ monkeypatch.setattr(cf.requests, 'post',
+ lambda url, headers=None, json=None, timeout=None:
+ _Resp({'success': True, 'result': {'id': 'CFREC'}}))
+
+ rec = DNSZoneService.create_record(
+ zone.id, {'record_type': 'A', 'name': 'www.example.com', 'content': '1.2.3.4'})
+ assert rec.provider_record_id == 'CFREC'
diff --git a/backend/tests/test_dns_credential_resolution.py b/backend/tests/test_dns_credential_resolution.py
new file mode 100644
index 00000000..fac87fa3
--- /dev/null
+++ b/backend/tests/test_dns_credential_resolution.py
@@ -0,0 +1,166 @@
+"""Proving tests for single-source DNS credentials (DNS unification #1).
+
+The /dns Zones page and Dynamic DNS used to keep their *own* Cloudflare token in
+``dns_zones.provider_config_json`` — separate from the connection in
+Settings -> Connections (``DNSProviderConfig``). These tests prove the zone layer
+now resolves credentials from the canonical store:
+
+* an explicit link wins,
+* otherwise the connection managing the domain is auto-discovered and the link is
+ persisted (with the provider-side zone id),
+* a legacy inline token still works until migrated,
+* ``link_legacy_zones`` converges inline tokens onto encrypted connections
+ (reusing a matching one, else minting), and
+* Dynamic DNS rides all of this for free — an IP update syncs through the linked
+ connection.
+"""
+
+
+class _Resp:
+ def __init__(self, js):
+ self._js = js
+
+ def json(self):
+ return self._js
+
+
+def _add_connection(name='cf', token='tok'):
+ """Create an encrypted Cloudflare connection and return the row."""
+ from app.models.email import DNSProviderConfig
+ from app.services.dns_provider_service import DNSProviderService
+ DNSProviderService.add_provider(name=name, provider='cloudflare', api_key=token)
+ return DNSProviderConfig.query.filter_by(name=name).first()
+
+
+# ── _resolve_credential ──────────────────────────────────────────────────────
+
+def test_resolve_prefers_linked_connection(app):
+ from app import db
+ from app.models.dns_zone import DNSZone
+ from app.services.dns_zone_service import DNSZoneService
+
+ conn = _add_connection(token='linked-token')
+ zone = DNSZone(domain='example.com', provider='cloudflare',
+ provider_zone_id='zoneABC', dns_provider_config_id=conn.id)
+ db.session.add(zone)
+ db.session.commit()
+
+ cred = DNSZoneService._resolve_credential(zone)
+ assert cred.provider == 'cloudflare' and cred.token == 'linked-token'
+
+
+def test_resolve_auto_discovers_and_persists_link(app, monkeypatch):
+ from app import db
+ from app.models.dns_zone import DNSZone
+ from app.services.dns_zone_service import DNSZoneService
+ from app.services.dns_provider_service import DNSProviderService
+
+ conn = _add_connection(token='discovered')
+ zone = DNSZone(domain='example.com', provider='cloudflare') # no link, no zone id
+ db.session.add(zone)
+ db.session.commit()
+
+ monkeypatch.setattr(DNSProviderService, 'find_zone_for_domain', classmethod(
+ lambda cls, d: (conn, {'id': 'zoneXYZ', 'name': 'example.com'})))
+
+ cred = DNSZoneService._resolve_credential(zone)
+ assert cred.token == 'discovered'
+ # the discovered link + provider zone id are persisted for next time
+ assert zone.dns_provider_config_id == conn.id
+ assert zone.provider_zone_id == 'zoneXYZ'
+
+
+def test_resolve_falls_back_to_legacy_inline_token(app, monkeypatch):
+ from app import db
+ from app.models.dns_zone import DNSZone
+ from app.services.dns_zone_service import DNSZoneService
+ from app.services.dns_provider_service import DNSProviderService
+
+ zone = DNSZone(domain='legacy.com', provider='cloudflare')
+ zone.provider_config = {'api_token': 'legacy-token'}
+ db.session.add(zone)
+ db.session.commit()
+
+ monkeypatch.setattr(DNSProviderService, 'find_zone_for_domain',
+ classmethod(lambda cls, d: (None, None)))
+
+ cred = DNSZoneService._resolve_credential(zone)
+ assert cred.token == 'legacy-token'
+ assert zone.dns_provider_config_id is None # nothing to link to yet
+
+
+# ── link_legacy_zones ────────────────────────────────────────────────────────
+
+def test_link_legacy_zones_mints_encrypted_connection(app):
+ from app import db
+ from app.models.dns_zone import DNSZone
+ from app.models.email import DNSProviderConfig
+ from app.services.dns_zone_service import DNSZoneService
+ from app.utils.crypto import is_encrypted, decrypt_secret_safe
+
+ zone = DNSZone(domain='example.com', provider='cloudflare', provider_zone_id='zoneABC')
+ zone.provider_config = {'api_token': 'mint-me'}
+ db.session.add(zone)
+ db.session.commit()
+
+ n = DNSZoneService.link_legacy_zones()
+ assert n == 1
+
+ conn = DNSProviderConfig.query.filter_by(provider='cloudflare').one()
+ assert is_encrypted(conn.api_key) and decrypt_secret_safe(conn.api_key) == 'mint-me'
+ assert zone.dns_provider_config_id == conn.id
+ assert 'api_token' not in zone.provider_config # plaintext token stripped
+
+ # idempotent — the zone is now linked, so a second pass is a no-op
+ assert DNSZoneService.link_legacy_zones() == 0
+
+
+def test_link_legacy_zones_reuses_matching_connection(app):
+ from app import db
+ from app.models.dns_zone import DNSZone
+ from app.models.email import DNSProviderConfig
+ from app.services.dns_zone_service import DNSZoneService
+
+ conn = _add_connection(name='existing', token='shared-token')
+ zone = DNSZone(domain='example.com', provider='cloudflare', provider_zone_id='zoneABC')
+ zone.provider_config = {'api_token': 'shared-token'}
+ db.session.add(zone)
+ db.session.commit()
+
+ n = DNSZoneService.link_legacy_zones()
+ assert n == 1
+ # linked to the existing connection — no duplicate minted
+ assert zone.dns_provider_config_id == conn.id
+ assert DNSProviderConfig.query.filter_by(provider='cloudflare').count() == 1
+
+
+# ── Dynamic DNS rides the unified credential path ────────────────────────────
+
+def test_ddns_update_syncs_via_linked_connection(app, monkeypatch):
+ """A DDNS IP update on a zone linked to a connection drives the shared
+ Cloudflare client and captures the provider record id — no inline token."""
+ from app import db
+ from app.models.dns_zone import DNSZone, DNSRecord
+ from app.services.ddns_service import DdnsService
+ from app.services.dns import cloudflare as cf
+
+ conn = _add_connection(token='tok')
+ zone = DNSZone(domain='example.com', provider='cloudflare',
+ provider_zone_id='zoneABC', dns_provider_config_id=conn.id)
+ db.session.add(zone)
+ db.session.commit()
+
+ host = DdnsService.create_host({'zone_id': zone.id, 'record_name': 'home'})
+
+ monkeypatch.setattr(cf.requests, 'get',
+ lambda url, headers=None, timeout=None: _Resp({'result': []}))
+ monkeypatch.setattr(cf.requests, 'post',
+ lambda url, headers=None, json=None, timeout=None:
+ _Resp({'success': True, 'result': {'id': 'CFREC'}}))
+
+ status, updated = DdnsService.update_ip(host.token, '203.0.113.9')
+ assert status == 'updated' and updated.last_ip == '203.0.113.9'
+
+ rec = DNSRecord.query.filter_by(zone_id=zone.id, name='home', record_type='A').one()
+ assert rec.content == '203.0.113.9'
+ assert rec.provider_record_id == 'CFREC' # synced through the linked connection
diff --git a/frontend/src/pages/DNSZones.jsx b/frontend/src/pages/DNSZones.jsx
index f2ed1710..078a347f 100644
--- a/frontend/src/pages/DNSZones.jsx
+++ b/frontend/src/pages/DNSZones.jsx
@@ -32,41 +32,14 @@ const DNSZones = () => {
const [propagationResults, setPropagationResults] = useState([]);
const [deleteConfirm, setDeleteConfirm] = useState(null);
- const [zoneForm, setZoneForm] = useState({ domain: '', provider: 'manual', provider_zone_id: '', api_token: '' });
+ const [zoneForm, setZoneForm] = useState({ domain: '', dns_provider_config_id: '' });
+ const [providers, setProviders] = useState([]);
const [recordForm, setRecordForm] = useState({
record_type: 'A', name: '@', content: '', ttl: 3600, priority: null
});
const RECORD_TYPES = ['A', 'AAAA', 'CNAME', 'MX', 'TXT', 'SRV', 'CAA', 'NS'];
- const PROVIDER_CONFIG = {
- cloudflare: {
- zoneLabel: 'Cloudflare Zone ID',
- zonePlaceholder: 'e.g. 023e105f4ecef8ad9ca31a8372d0c353',
- tokenLabel: 'API Token',
- tokenPlaceholder: 'Cloudflare API token (Edit zone permissions)',
- helpText: 'Find your Zone ID in the Cloudflare dashboard under Overview → API.',
- },
- route53: {
- zoneLabel: 'Hosted Zone ID',
- zonePlaceholder: 'e.g. Z3M3LMPEXAMPLE',
- tokenLabel: 'AWS Access Key',
- tokenPlaceholder: 'AKIA... (needs Route 53 permissions)',
- helpText: 'Use an IAM user with AmazonRoute53FullAccess policy.',
- extraFields: [
- { key: 'aws_secret_key', label: 'AWS Secret Key', placeholder: 'Secret access key', type: 'password' },
- { key: 'aws_region', label: 'AWS Region', placeholder: 'us-east-1', type: 'text' },
- ],
- },
- digitalocean: {
- zoneLabel: 'Domain Name',
- zonePlaceholder: 'e.g. example.com (must exist in your DO account)',
- tokenLabel: 'Personal Access Token',
- tokenPlaceholder: 'DigitalOcean personal access token',
- helpText: 'Generate a token at API → Tokens with read+write scope.',
- },
- };
-
const loadZones = useCallback(async () => {
try {
const data = await api.getDNSZones();
@@ -80,6 +53,16 @@ const DNSZones = () => {
useEffect(() => { loadZones(); }, [loadZones]);
+ // Lazily load connected DNS providers (Settings -> Connections) for the
+ // zone picker the first time the modal opens.
+ useEffect(() => {
+ if (showCreateZone && providers.length === 0) {
+ api.getEmailDNSProviders()
+ .then(d => setProviders(d.providers || []))
+ .catch(() => {});
+ }
+ }, [showCreateZone, providers.length]);
+
const loadRecords = async (zoneId) => {
try {
const data = await api.getDNSRecords(zoneId);
@@ -92,18 +75,16 @@ const DNSZones = () => {
const handleCreateZone = async () => {
try {
- const payload = {
- domain: zoneForm.domain,
- provider: zoneForm.provider,
- };
- if (zoneForm.provider !== 'manual') {
- payload.provider_zone_id = zoneForm.provider_zone_id;
- payload.provider_config = { api_token: zoneForm.api_token };
+ const payload = { domain: zoneForm.domain };
+ if (zoneForm.dns_provider_config_id) {
+ payload.dns_provider_config_id = Number(zoneForm.dns_provider_config_id);
+ } else {
+ payload.provider = 'manual';
}
await api.createDNSZone(payload);
toast.success('Zone created');
setShowCreateZone(false);
- setZoneForm({ domain: '', provider: 'manual', provider_zone_id: '', api_token: '' });
+ setZoneForm({ domain: '', dns_provider_config_id: '' });
loadZones();
} catch (err) {
toast.error(err.message);
@@ -259,40 +240,36 @@ const DNSZones = () => {
<FormField label="Domain" htmlFor="zone-domain">
<Input id="zone-domain" value={zoneForm.domain} onChange={e => setZoneForm({...zoneForm, domain: e.target.value})} placeholder="example.com" />
</FormField>
- <FormField label="Provider">
- <Select value={zoneForm.provider} onValueChange={v => setZoneForm({...zoneForm, provider: v})}>
+ <FormField label="DNS Provider">
+ <Select
+ value={zoneForm.dns_provider_config_id || 'manual'}
+ onValueChange={v => setZoneForm({ ...zoneForm, dns_provider_config_id: v === 'manual' ? '' : v })}
+ >
<SelectTrigger id="zone-provider">
<SelectValue />
</SelectTrigger>
<SelectContent>
- <SelectItem value="manual">Manual</SelectItem>
- <SelectItem value="cloudflare">Cloudflare</SelectItem>
- <SelectItem value="route53">Route 53 (AWS)</SelectItem>
- <SelectItem value="digitalocean">DigitalOcean</SelectItem>
+ <SelectItem value="manual">Manual (no automatic sync)</SelectItem>
+ {providers.map(p => (
+ <SelectItem key={p.id} value={String(p.id)}>
+ {p.name} — {p.provider}
+ </SelectItem>
+ ))}
</SelectContent>
</Select>
</FormField>
- {zoneForm.provider !== 'manual' && (() => {
- const cfg = PROVIDER_CONFIG[zoneForm.provider];
- return (
- <>
- {cfg.helpText && (
- <p className="text-muted text-sm">{cfg.helpText}</p>
- )}
- <FormField label={cfg.zoneLabel} htmlFor="zone-provider-zone-id">
- <Input id="zone-provider-zone-id" value={zoneForm.provider_zone_id} onChange={e => setZoneForm({...zoneForm, provider_zone_id: e.target.value})} placeholder={cfg.zonePlaceholder} />
- </FormField>
- <FormField label={cfg.tokenLabel} htmlFor="zone-api-token">
- <Input id="zone-api-token" type="password" value={zoneForm.api_token} onChange={e => setZoneForm({...zoneForm, api_token: e.target.value})} placeholder={cfg.tokenPlaceholder} />
- </FormField>
- {cfg.extraFields?.map(field => (
- <FormField key={field.key} label={field.label} htmlFor={`zone-${field.key}`}>
- <Input id={`zone-${field.key}`} type={field.type} value={zoneForm[field.key] || ''} onChange={e => setZoneForm({...zoneForm, [field.key]: e.target.value})} placeholder={field.placeholder} />
- </FormField>
- ))}
- </>
- );
- })()}
+ {zoneForm.dns_provider_config_id ? (
+ <p className="text-muted text-sm">
+ Records added here sync to this connection. We will match{' '}
+ <strong>{zoneForm.domain || 'your domain'}</strong> to a zone in that
+ account automatically — no zone ID or token to paste.
+ </p>
+ ) : (
+ <p className="text-muted text-sm">
+ Manual zones are not pushed to a provider. To sync automatically,{' '}
+ <a href="/settings?tab=connections">connect a DNS provider</a> first.
+ </p>
+ )}
</div>
<div className="modal-footer">
<Button variant="outline" onClick={() => setShowCreateZone(false)}>Cancel</Button>