doomain 0.1.2 → 0.1.3

package/dist/commands/domains/list.js

@@ -4,6 +4,15 @@ import { domainFlag, jsonFlag, providerFlag } from '../../lib/flags.js';
 import { createOutput, outputError } from '../../lib/output.js';
 import { createProvider } from '../../lib/providers/registry.js';
 import { normalizeDomain } from '../../lib/validate.js';
+async function resolveZones(provider, domain) {
+    if (!domain)
+        return provider.listZones();
+    const normalized = normalizeDomain(domain);
+    const zone = await provider.getZone(normalized);
+    if (!zone)
+        throw new Error(`${provider.name} does not have a DNS zone for ${normalized}.`);
+    return [zone];
+}
 export default class DomainsList extends Command {
     static description = 'List DNS zones and records for a provider.';
     static flags = {
@@ -17,7 +26,7 @@ export default class DomainsList extends Command {
         try {
             const config = await loadConfig();
             const provider = await createProvider(flags.provider ?? process.env.DOOMAIN_PROVIDER ?? config.defaults?.provider ?? 'spaceship');
-            const zones = flags.domain ? [{ id: normalizeDomain(flags.domain), name: normalizeDomain(flags.domain) }] : await provider.listZones();
+            const zones = await resolveZones(provider, flags.domain);
             const results = [];
             for (const zone of zones) {
                 const records = await provider.listRecords(zone);

package/dist/lib/link-domain.js

@@ -187,6 +187,20 @@ function uniqueRecords(records) {
     }
     return unique;
 }
+function recordKey(record) {
+    return `${record.type}:${record.name}:${record.value}:${record.proxied ?? ''}`;
+}
+function mergeRecords(records, nextRecords) {
+    const existing = new Set(records.map(recordKey));
+    const added = nextRecords.filter((record) => !existing.has(recordKey(record)));
+    return { records: [...records, ...added], added };
+}
+function errorDetails(error) {
+    return error instanceof DoomainError ? error.details : undefined;
+}
+function isDomainConfigReady(config) {
+    return config?.misconfigured !== true;
+}
 export function verificationRecords(raw, zoneDomain) {
     const verification = collectVerificationRecords(raw);
     return verification.flatMap((record) => {
@@ -239,32 +253,58 @@ async function waitForVercelDomainReady(opts) {
     const startedAt = Date.now();
     const deadline = Date.now() + timeoutSeconds * 1000;
     let lastError;
+    let lastConfig;
     let propagated = false;
     let attempt = 1;
+    let records = opts.records;
+    async function applyVerificationRecords(raw) {
+        const nextRecords = planVerificationRecords(opts.providerId, raw, opts.zoneDomain);
+        const merged = mergeRecords(records, nextRecords);
+        if (merged.added.length === 0)
+            return;
+        reportProgress(opts.input, 'dns:plan', `Found ${merged.added.length} new Vercel ownership record${merged.added.length === 1 ? '' : 's'}`);
+        const dnsPlan = await opts.provider.planChanges(opts.zone, merged.added, { force: opts.force });
+        reportProgress(opts.input, 'dns:apply', `Updating ownership records in ${opts.provider.name}`);
+        await opts.provider.applyChanges(opts.zone, dnsPlan, { force: opts.force });
+        records = merged.records;
+    }
+    async function isVercelReady(raw) {
+        await applyVerificationRecords(raw);
+        if (raw.verified !== true)
+            return false;
+        lastConfig = await vercel.getDomainConfig(opts.domain);
+        return isDomainConfigReady(lastConfig);
+    }
     while (Date.now() <= deadline) {
         const elapsedSeconds = Math.round((Date.now() - startedAt) / 1000);
         reportProgress(opts.input, 'vercel:verify', `Verifying domain in Vercel (attempt ${attempt}, ${elapsedSeconds}s elapsed)`);
         try {
             const current = await vercel.getProjectDomain(opts.project, opts.domain);
-            if (current.verified === true)
+            if (await isVercelReady(current))
                 return { propagated: true, verified: true };
             const result = await vercel.verifyProjectDomain(opts.project, opts.domain);
-            if (result.verified !== false)
+            if (await isVercelReady(result))
                 return { propagated: true, verified: true };
         }
         catch (error) {
             // Vercel returns an error while DNS is still propagating.
             lastError = error;
+            await applyVerificationRecords(errorDetails(error));
         }
-        propagated = await areRecordsPropagated(opts.records, opts.zoneDomain);
+        propagated = await areRecordsPropagated(records, opts.zoneDomain);
         reportProgress(opts.input, 'dns:wait', propagated
             ? 'DNS is visible publicly; Vercel verification is still pending'
             : 'DNS records were saved; public DNS is still catching up');
         attempt += 1;
+        if (Date.now() > deadline)
+            break;
         await wait(5000);
     }
     if (lastError) {
-        throw new DoomainError('DOMAIN_VERIFY_FAILED', `Vercel did not verify ${opts.domain} within ${timeoutSeconds} seconds. Last Vercel response: ${errorMessage(lastError)}`);
+        throw new DoomainError('DOMAIN_VERIFY_FAILED', `Vercel did not verify ${opts.domain} within ${timeoutSeconds} seconds. Last Vercel response: ${errorMessage(lastError)}`, { domainConfig: lastConfig, error: errorDetails(lastError) });
+    }
+    if (lastConfig?.misconfigured === true) {
+        throw new DoomainError('DOMAIN_VERIFY_FAILED', `Vercel verified ${opts.domain}, but its DNS configuration is still invalid after ${timeoutSeconds} seconds.`, { domainConfig: lastConfig });
     }
     return { propagated, verified: false };
 }
@@ -324,7 +364,17 @@ export async function linkDomain(input) {
         reportProgress(input, 'dns:wait', verificationDnsRecords.length > 0 ? 'DNS records saved; asking Vercel to verify ownership' : 'DNS records saved; asking Vercel to verify');
     }
     const waitResult = shouldWait
-        ? await waitForVercelDomainReady({ domain: plan.domain, input, project: plan.project, records, zoneDomain: plan.zoneDomain })
+        ? await waitForVercelDomainReady({
+            domain: plan.domain,
+            force: input.force,
+            input,
+            project: plan.project,
+            provider,
+            providerId: plan.provider,
+            records,
+            zone,
+            zoneDomain: plan.zoneDomain,
+        })
         : { propagated: false, verified: false };
     return {
         ...plan,

package/oclif.manifest.json

@@ -629,5 +629,5 @@
       ]
     }
   },
-  "version": "0.1.2"
+  "version": "0.1.3"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "doomain",
   "description": "Link your vercel project and domain in seconds",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "author": "Crafter Station",
   "packageManager": "bun@1.3.13",
   "bin": {