doomain 0.1.23 → 0.1.24

package/dist/lib/dns-reconciliation.js

@@ -1,53 +1,58 @@
+import { Effect } from 'effect';
 import { desiredSlotPostcondition, recordMatchesSelector } from './dns-records.js';
 import { DoomainError } from './errors.js';
-const sleep = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
-export async function reconcileDesiredRecord(input) {
-    const now = input.dependencies?.now ?? Date.now;
-    const wait = input.dependencies?.sleep ?? sleep;
-    const deadline = now() + (input.timeoutMs ?? 30_000);
-    let attempts = 0;
-    const appliedChanges = 0;
-    while (true) {
-        attempts += 1;
-        const records = await input.provider.listRecords(input.zone);
-        const state = desiredSlotPostcondition(records, input.desired);
-        if (state.reconciled)
-            return { appliedChanges, attempts, observed: state.observed, reconciled: true };
-        if (now() >= deadline) {
-            throw new DoomainError('DNS_RECONCILIATION_INCOMPLETE', `The DNS provider accepted the change, but the ${input.desired.type} ${input.desired.name} slot is not reconciled yet.`, {
-                attempts,
-                expected: input.desired,
-                observed: state.observed,
-                recovery: 'Retry the command. Do not treat the DNS change as complete until reconciled is true.',
-            });
+const sleep = (milliseconds) => Effect.sleep(milliseconds);
+export function reconcileDesiredRecord(input) {
+    return Effect.gen(function* () {
+        const now = input.dependencies?.now ?? Date.now;
+        const wait = input.dependencies?.sleep ?? sleep;
+        const deadline = now() + (input.timeoutMs ?? 30_000);
+        let attempts = 0;
+        const appliedChanges = 0;
+        while (true) {
+            attempts += 1;
+            const records = yield* input.provider.listRecords(input.zone);
+            const state = desiredSlotPostcondition(records, input.desired);
+            if (state.reconciled)
+                return { appliedChanges, attempts, observed: state.observed, reconciled: true };
+            if (now() >= deadline) {
+                return yield* Effect.fail(new DoomainError('DNS_RECONCILIATION_INCOMPLETE', `The DNS provider accepted the change, but the ${input.desired.type} ${input.desired.name} slot is not reconciled yet.`, {
+                    attempts,
+                    expected: input.desired,
+                    observed: state.observed,
+                    recovery: 'Retry the command. Do not treat the DNS change as complete until reconciled is true.',
+                }));
+            }
+            input.progress?.('Waiting for the DNS provider to publish the accepted change');
+            const remaining = deadline - now();
+            yield* wait(Math.min(input.intervalMs ?? 1000, Math.max(0, remaining)));
         }
-        input.progress?.('Waiting for the DNS provider to publish the accepted change');
-        const remaining = deadline - now();
-        await wait(Math.min(input.intervalMs ?? 1000, Math.max(0, remaining)));
-    }
+    });
 }
-export async function reconcileRecordRemoval(input) {
-    const now = input.dependencies?.now ?? Date.now;
-    const wait = input.dependencies?.sleep ?? sleep;
-    const deadline = now() + (input.timeoutMs ?? 30_000);
-    let attempts = 0;
-    const appliedChanges = 0;
-    while (true) {
-        attempts += 1;
-        const records = await input.provider.listRecords(input.zone);
-        const observed = records.filter((record) => recordMatchesSelector(record, input.selector));
-        if (observed.length === 0)
-            return { appliedChanges, attempts, observed, reconciled: true };
-        if (now() >= deadline) {
-            throw new DoomainError('DNS_RECONCILIATION_INCOMPLETE', `The DNS provider accepted the deletion, but ${observed.length} matching record${observed.length === 1 ? '' : 's'} remain.`, {
-                attempts,
-                observed,
-                selector: input.selector,
-                recovery: 'Retry the command. Do not treat the DNS deletion as complete until reconciled is true.',
-            });
+export function reconcileRecordRemoval(input) {
+    return Effect.gen(function* () {
+        const now = input.dependencies?.now ?? Date.now;
+        const wait = input.dependencies?.sleep ?? sleep;
+        const deadline = now() + (input.timeoutMs ?? 30_000);
+        let attempts = 0;
+        const appliedChanges = 0;
+        while (true) {
+            attempts += 1;
+            const records = yield* input.provider.listRecords(input.zone);
+            const observed = records.filter((record) => recordMatchesSelector(record, input.selector));
+            if (observed.length === 0)
+                return { appliedChanges, attempts, observed, reconciled: true };
+            if (now() >= deadline) {
+                return yield* Effect.fail(new DoomainError('DNS_RECONCILIATION_INCOMPLETE', `The DNS provider accepted the deletion, but ${observed.length} matching record${observed.length === 1 ? '' : 's'} remain.`, {
+                    attempts,
+                    observed,
+                    selector: input.selector,
+                    recovery: 'Retry the command. Do not treat the DNS deletion as complete until reconciled is true.',
+                }));
+            }
+            input.progress?.('Waiting for the DNS provider to publish the accepted deletion');
+            const remaining = deadline - now();
+            yield* wait(Math.min(input.intervalMs ?? 1000, Math.max(0, remaining)));
         }
-        input.progress?.('Waiting for the DNS provider to publish the accepted deletion');
-        const remaining = deadline - now();
-        await wait(Math.min(input.intervalMs ?? 1000, Math.max(0, remaining)));
-    }
+    });
 }

package/dist/lib/domain-provider.d.ts

@@ -1,3 +1,4 @@
+import { type DoomainEffect } from './effect.js';
 import { type DoomainErrorCode } from './errors.js';
 export interface FindDomainProviderInput {
     account?: string;
@@ -33,6 +34,7 @@ export interface ResolveProviderTargetInput extends FindDomainProviderInput {
 }
 export interface ResolveProviderTargetOptions {
     tolerateProviderAccountErrors?: boolean;
+    transportErrorCode?: DoomainErrorCode;
 }
 export interface ResolvedDnsTarget {
     account: string;
@@ -48,6 +50,8 @@ export interface ResolvedDnsTarget {
     };
     warnings: ProviderSearchWarning[];
 }
-export declare function resolveProviderTarget(input: ResolveProviderTargetInput, options?: ResolveProviderTargetOptions): Promise<ResolvedDnsTarget>;
+export declare function resolveProviderTarget(input: ResolveProviderTargetInput, options?: ResolveProviderTargetOptions): DoomainEffect<ResolvedDnsTarget>;
 /** Find the configured DNS provider account with the longest zone match for a domain. */
+export declare function findDomainProviderEffect(input: FindDomainProviderInput): DoomainEffect<DomainProviderResult>;
+/** Promise facade retained for the package's public programmatic API. */
 export declare function findDomainProvider(input: FindDomainProviderInput): Promise<DomainProviderResult>;

package/dist/lib/domain-provider.js

@@ -1,4 +1,6 @@
+import { Effect } from 'effect';
 import { loadConfig } from './config.js';
+import { runDoomainEffect, trySync } from './effect.js';
 import { DoomainError } from './errors.js';
 import { DEFAULT_PROVIDER_ACCOUNT, isDefaultProviderAccount, listConfiguredProviderAccounts, normalizeProviderAccount, } from './providers/core/config.js';
 import { createProvider, getProviderDefinition, listProviderDefinitions } from './providers/registry.js';
@@ -55,46 +57,43 @@ function searchError(error) {
         message: error instanceof Error ? error.message : String(error),
     };
 }
-async function loadProviderZones(definition, account) {
-    const provider = await createProvider(definition.id, { account: account.account });
-    const zones = await provider.listZones();
-    return {
-        candidates: zones.map((zone) => ({
-            account: account.account,
-            isDefaultAccount: account.isDefaultAccount,
-            provider: definition.id,
-            providerName: definition.displayName,
-            zone,
-        })),
-        search: {
-            account: account.account,
-            displayName: definition.displayName,
-            id: definition.id,
-            isDefaultAccount: account.isDefaultAccount,
-            zones: zones.map((zone) => zone.name),
-        },
-    };
-}
-async function loadProviderZonesSafely(definition, account) {
-    try {
-        return await loadProviderZones(definition, account);
-    }
-    catch (error) {
+function loadProviderZones(definition, account, transportErrorCode) {
+    return Effect.gen(function* () {
+        const provider = yield* createProvider(definition.id, { account: account.account, transportErrorCode });
+        const zones = yield* provider.listZones();
         return {
-            candidates: [],
+            candidates: zones.map((zone) => ({
+                account: account.account,
+                isDefaultAccount: account.isDefaultAccount,
+                provider: definition.id,
+                providerName: definition.displayName,
+                zone,
+            })),
             search: {
                 account: account.account,
                 displayName: definition.displayName,
-                error: searchError(error),
                 id: definition.id,
                 isDefaultAccount: account.isDefaultAccount,
-                zones: [],
+                zones: zones.map((zone) => zone.name),
             },
         };
-    }
+    });
 }
-async function providerConnectionDetails() {
-    return (await listProviderStatuses({ verify: false })).map((provider) => ({
+function loadProviderZonesSafely(definition, account, transportErrorCode) {
+    return loadProviderZones(definition, account, transportErrorCode).pipe(Effect.catchAll((error) => Effect.succeed({
+        candidates: [],
+        search: {
+            account: account.account,
+            displayName: definition.displayName,
+            error: searchError(error),
+            id: definition.id,
+            isDefaultAccount: account.isDefaultAccount,
+            zones: [],
+        },
+    })));
+}
+function providerConnectionDetails() {
+    return listProviderStatuses({ verify: false }).pipe(Effect.map((providers) => providers.map((provider) => ({
         configured: provider.configured,
         account: provider.account,
         default: provider.default,
@@ -102,7 +101,7 @@ async function providerConnectionDetails() {
         docsUrl: provider.docsUrl,
         id: provider.id,
         isDefaultAccount: provider.isDefaultAccount,
-    }));
+    }))));
 }
 function searchWarnings(searches) {
     return searches.flatMap((search) => search.error
@@ -117,89 +116,99 @@ function searchWarnings(searches) {
         ]
         : []);
 }
-async function loadConfiguredProviderZones(providerId, accountInput, tolerateProviderAccountErrors = false) {
-    const config = await loadConfig();
-    const account = accountInput ? normalizeProviderAccount(accountInput) : undefined;
-    if (providerId) {
-        const definition = getProviderDefinition(providerId);
-        const accounts = account
-            ? [explicitAccountRef(definition.id, account)]
-            : listConfiguredProviderAccounts(config, definition);
-        const selectedAccounts = accounts.length > 0 ? accounts : [defaultAccountRef(definition.id)];
-        const tolerateAccountErrors = tolerateProviderAccountErrors && !account && selectedAccounts.length > 1;
-        const results = await Promise.all(selectedAccounts.map((ref) => tolerateAccountErrors ? loadProviderZonesSafely(definition, ref) : loadProviderZones(definition, ref)));
+function loadConfiguredProviderZones(providerId, accountInput, tolerateProviderAccountErrors = false, transportErrorCode = 'DOMAIN_PROVIDER_DISCOVERY_FAILED') {
+    return Effect.gen(function* () {
+        const config = yield* loadConfig();
+        const account = accountInput
+            ? yield* trySync(() => normalizeProviderAccount(accountInput), 'INVALID_INPUT')
+            : undefined;
+        if (providerId) {
+            const definition = yield* trySync(() => getProviderDefinition(providerId), 'PROVIDER_NOT_FOUND');
+            const accounts = account
+                ? [explicitAccountRef(definition.id, account)]
+                : yield* trySync(() => listConfiguredProviderAccounts(config, definition), 'INVALID_INPUT');
+            const selectedAccounts = accounts.length > 0 ? accounts : [defaultAccountRef(definition.id)];
+            const tolerateAccountErrors = tolerateProviderAccountErrors && !account && selectedAccounts.length > 1;
+            const results = yield* Effect.all(selectedAccounts.map((ref) => tolerateAccountErrors
+                ? loadProviderZonesSafely(definition, ref, transportErrorCode)
+                : loadProviderZones(definition, ref, transportErrorCode)), { concurrency: 'unbounded' });
+            return {
+                accountInferred: account === undefined,
+                candidates: results.flatMap((result) => result.candidates),
+                providerInferred: false,
+                searched: results.map((result) => result.search),
+            };
+        }
+        const providerAccounts = yield* trySync(() => listProviderDefinitions().flatMap((definition) => listConfiguredProviderAccounts(config, definition)
+            .filter((ref) => !account || ref.account === account)
+            .map((ref) => ({ definition, ref }))), 'INVALID_INPUT');
+        if (providerAccounts.length === 0) {
+            const message = account
+                ? `No DNS provider account named ${account} is configured. Run \`doomain providers connect <provider> --account ${account}\` first.`
+                : 'No DNS provider is configured. Run `doomain providers connect` first.';
+            return yield* Effect.fail(new DoomainError('CONFIG_NOT_FOUND', message, {
+                account,
+                configuredProviders: yield* providerConnectionDetails(),
+                recovery: 'Connect the DNS provider that owns this domain, then retry `doomain link <domain> --json`.',
+                suggestedCommands: account
+                    ? [`doomain providers connect <provider> --account ${account}`, 'doomain link <domain> --json']
+                    : ['doomain providers connect', 'doomain link <domain> --json'],
+            }));
+        }
+        const results = yield* Effect.all(providerAccounts.map(({ definition, ref }) => tolerateProviderAccountErrors
+            ? loadProviderZonesSafely(definition, ref, transportErrorCode)
+            : loadProviderZones(definition, ref, transportErrorCode)), { concurrency: 'unbounded' });
         return {
             accountInferred: account === undefined,
             candidates: results.flatMap((result) => result.candidates),
-            providerInferred: false,
+            providerInferred: true,
             searched: results.map((result) => result.search),
         };
-    }
-    const providerAccounts = listProviderDefinitions().flatMap((definition) => listConfiguredProviderAccounts(config, definition)
-        .filter((ref) => !account || ref.account === account)
-        .map((ref) => ({ definition, ref })));
-    if (providerAccounts.length === 0) {
-        const message = account
-            ? `No DNS provider account named ${account} is configured. Run \`doomain providers connect <provider> --account ${account}\` first.`
-            : 'No DNS provider is configured. Run `doomain providers connect` first.';
-        throw new DoomainError('CONFIG_NOT_FOUND', message, {
-            account,
-            configuredProviders: await providerConnectionDetails(),
-            recovery: 'Connect the DNS provider that owns this domain, then retry `doomain link <domain> --json`.',
-            suggestedCommands: account
-                ? [`doomain providers connect <provider> --account ${account}`, 'doomain link <domain> --json']
-                : ['doomain providers connect', 'doomain link <domain> --json'],
-        });
-    }
-    const results = await Promise.all(providerAccounts.map(({ definition, ref }) => tolerateProviderAccountErrors ? loadProviderZonesSafely(definition, ref) : loadProviderZones(definition, ref)));
-    return {
-        accountInferred: account === undefined,
-        candidates: results.flatMap((result) => result.candidates),
-        providerInferred: true,
-        searched: results.map((result) => result.search),
-    };
+    });
 }
-export async function resolveProviderTarget(input, options = {}) {
-    const requested = resolveRequestedDomain(input);
-    const zones = await loadConfiguredProviderZones(input.provider, input.account, options.tolerateProviderAccountErrors);
-    const matches = zones.candidates
-        .filter((candidate) => zoneMatchesDomain(requested.fullDomain, candidate.zone.name, requested.forceExactZone))
-        .sort((a, b) => b.zone.name.length - a.zone.name.length);
-    if (matches.length === 0) {
-        const account = input.account ? normalizeProviderAccount(input.account) : undefined;
-        const providerMessage = input.provider
-            ? `${getProviderDefinition(input.provider).displayName}${account ? ` account ${account}` : ''} does not have a matching DNS zone for ${requested.fullDomain}.`
-            : `No configured DNS provider has a matching DNS zone for ${requested.fullDomain}.`;
-        throw new DoomainError('PROVIDER_ZONE_NOT_FOUND', providerMessage, {
-            account,
-            configuredProviders: await providerConnectionDetails(),
-            domain: requested.fullDomain,
-            recovery: 'Retry with --provider <id> --account <alias> only if another configured provider account owns this zone. Otherwise connect the DNS provider account that owns this domain.',
-            searchedZones: zones.searched,
-            suggestedCommands: [
-                `doomain link ${requested.fullDomain} --provider <id> --account <alias> --json`,
-                'doomain providers connect',
-            ],
-        });
-    }
-    const bestLength = matches[0].zone.name.length;
-    const bestMatches = matches.filter((candidate) => candidate.zone.name.length === bestLength);
-    const uniqueBestMatches = bestMatches.filter((candidate, index, candidates) => candidates.findIndex((item) => item.provider === candidate.provider &&
-        item.account === candidate.account &&
-        item.zone.name === candidate.zone.name) === index);
-    if (uniqueBestMatches.length > 1) {
-        throw new DoomainError('PROVIDER_ZONE_AMBIGUOUS', `Multiple DNS provider accounts have a matching DNS zone for ${requested.fullDomain}. Pass --provider and --account to choose one.`, { candidates: candidateDetails(uniqueBestMatches), domain: requested.fullDomain });
-    }
-    const selected = uniqueBestMatches[0];
-    return {
-        account: selected.account,
-        accountInferred: zones.accountInferred,
-        isDefaultAccount: selected.isDefaultAccount,
-        provider: selected.provider,
-        providerInferred: zones.providerInferred,
-        target: targetFromZone(requested.fullDomain, selected.zone.name),
-        warnings: searchWarnings(zones.searched),
-    };
+export function resolveProviderTarget(input, options = {}) {
+    return Effect.gen(function* () {
+        const requested = yield* trySync(() => resolveRequestedDomain(input), 'INVALID_INPUT');
+        const zones = yield* loadConfiguredProviderZones(input.provider, input.account, options.tolerateProviderAccountErrors, options.transportErrorCode);
+        const matches = zones.candidates
+            .filter((candidate) => zoneMatchesDomain(requested.fullDomain, candidate.zone.name, requested.forceExactZone))
+            .sort((a, b) => b.zone.name.length - a.zone.name.length);
+        if (matches.length === 0) {
+            const account = input.account ? normalizeProviderAccount(input.account) : undefined;
+            const providerMessage = input.provider
+                ? `${getProviderDefinition(input.provider).displayName}${account ? ` account ${account}` : ''} does not have a matching DNS zone for ${requested.fullDomain}.`
+                : `No configured DNS provider has a matching DNS zone for ${requested.fullDomain}.`;
+            return yield* Effect.fail(new DoomainError('PROVIDER_ZONE_NOT_FOUND', providerMessage, {
+                account,
+                configuredProviders: yield* providerConnectionDetails(),
+                domain: requested.fullDomain,
+                recovery: 'Retry with --provider <id> --account <alias> only if another configured provider account owns this zone. Otherwise connect the DNS provider account that owns this domain.',
+                searchedZones: zones.searched,
+                suggestedCommands: [
+                    `doomain link ${requested.fullDomain} --provider <id> --account <alias> --json`,
+                    'doomain providers connect',
+                ],
+            }));
+        }
+        const bestLength = matches[0].zone.name.length;
+        const bestMatches = matches.filter((candidate) => candidate.zone.name.length === bestLength);
+        const uniqueBestMatches = bestMatches.filter((candidate, index, candidates) => candidates.findIndex((item) => item.provider === candidate.provider &&
+            item.account === candidate.account &&
+            item.zone.name === candidate.zone.name) === index);
+        if (uniqueBestMatches.length > 1) {
+            return yield* Effect.fail(new DoomainError('PROVIDER_ZONE_AMBIGUOUS', `Multiple DNS provider accounts have a matching DNS zone for ${requested.fullDomain}. Pass --provider and --account to choose one.`, { candidates: candidateDetails(uniqueBestMatches), domain: requested.fullDomain }));
+        }
+        const selected = uniqueBestMatches[0];
+        return {
+            account: selected.account,
+            accountInferred: zones.accountInferred,
+            isDefaultAccount: selected.isDefaultAccount,
+            provider: selected.provider,
+            providerInferred: zones.providerInferred,
+            target: targetFromZone(requested.fullDomain, selected.zone.name),
+            warnings: searchWarnings(zones.searched),
+        };
+    });
 }
 function discoveryError(error, domain) {
     if (error.code !== 'CONFIG_NOT_FOUND' && error.code !== 'PROVIDER_ZONE_NOT_FOUND')
@@ -212,26 +221,22 @@ function discoveryError(error, domain) {
     });
 }
 /** Find the configured DNS provider account with the longest zone match for a domain. */
-export async function findDomainProvider(input) {
-    try {
-        const resolved = await resolveProviderTarget(input, { tolerateProviderAccountErrors: true });
-        return {
-            account: resolved.account,
-            accountInferred: resolved.accountInferred,
-            complete: resolved.warnings.length === 0,
-            domain: resolved.target.fullDomain,
-            isApex: resolved.target.isApex,
-            isDefaultAccount: resolved.isDefaultAccount,
-            provider: resolved.provider,
-            providerInferred: resolved.providerInferred,
-            recordName: resolved.target.recordName,
-            warnings: resolved.warnings,
-            zoneDomain: resolved.target.zoneDomain,
-        };
-    }
-    catch (error) {
-        if (error instanceof DoomainError)
-            throw discoveryError(error, input.domain);
-        throw error;
-    }
+export function findDomainProviderEffect(input) {
+    return resolveProviderTarget(input, { tolerateProviderAccountErrors: true }).pipe(Effect.map((resolved) => ({
+        account: resolved.account,
+        accountInferred: resolved.accountInferred,
+        complete: resolved.warnings.length === 0,
+        domain: resolved.target.fullDomain,
+        isApex: resolved.target.isApex,
+        isDefaultAccount: resolved.isDefaultAccount,
+        provider: resolved.provider,
+        providerInferred: resolved.providerInferred,
+        recordName: resolved.target.recordName,
+        warnings: resolved.warnings,
+        zoneDomain: resolved.target.zoneDomain,
+    })), Effect.mapError((error) => discoveryError(error, input.domain)));
+}
+/** Promise facade retained for the package's public programmatic API. */
+export function findDomainProvider(input) {
+    return runDoomainEffect(findDomainProviderEffect(input));
 }

package/dist/lib/effect.d.ts

@@ -0,0 +1,6 @@
+import { Effect } from 'effect';
+import { type DoomainError, type DoomainErrorCode } from './errors.js';
+export type DoomainEffect<A, E = DoomainError> = Effect.Effect<A, E>;
+export declare function trySync<A>(evaluate: () => A, fallbackCode: DoomainErrorCode): DoomainEffect<A>;
+export declare function tryPromise<A>(evaluate: () => PromiseLike<A>, fallbackCode: DoomainErrorCode): DoomainEffect<A>;
+export declare function runDoomainEffect<A>(effect: DoomainEffect<A>): Promise<A>;

package/dist/lib/effect.js

@@ -0,0 +1,20 @@
+import { Effect } from 'effect';
+import { toDoomainError } from './errors.js';
+export function trySync(evaluate, fallbackCode) {
+    return Effect.try({
+        try: evaluate,
+        catch: (error) => toDoomainError(error, fallbackCode),
+    });
+}
+export function tryPromise(evaluate, fallbackCode) {
+    return Effect.tryPromise({
+        try: evaluate,
+        catch: (error) => toDoomainError(error, fallbackCode),
+    });
+}
+export async function runDoomainEffect(effect) {
+    const result = await Effect.runPromise(Effect.either(effect));
+    if (result._tag === 'Left')
+        throw result.left;
+    return result.right;
+}

package/dist/lib/link-domain.d.ts

@@ -1,3 +1,4 @@
+import { type DoomainEffect } from './effect.js';
 import type { DnsConflict, DnsRecordInput } from './providers/types.js';
 export interface LinkDomainInput {
     provider?: string;
@@ -61,5 +62,5 @@ export interface LinkDomainResult extends LinkDomainPlan {
 }
 export declare function withProviderRecordOptions(provider: string, record: DnsRecordInput): DnsRecordInput;
 export declare function verificationRecords(raw: unknown, zoneDomain: string): DnsRecordInput[];
-export declare function createLinkPlan(input: LinkDomainInput): Promise<LinkDomainPlan>;
-export declare function linkDomain(input: LinkDomainInput): Promise<LinkDomainResult>;
+export declare function createLinkPlan(input: LinkDomainInput): DoomainEffect<LinkDomainPlan>;
+export declare function linkDomain(input: LinkDomainInput): DoomainEffect<LinkDomainResult>;