doomain 0.1.22 → 0.1.24

package/dist/lib/point-domain.js

@@ -1,13 +1,15 @@
+import { Effect } from 'effect';
 import { waitForDnsPropagation } from './dns-propagation.js';
 import { reconcileDesiredRecord } from './dns-reconciliation.js';
 import { inferAddressRecordType, normalizeAddressRecordTarget } from './dns-records.js';
 import { resolveProviderTarget } from './domain-provider.js';
+import { tryPromise, trySync } from './effect.js';
 import { DoomainError } from './errors.js';
 import { withProviderRecordOptions } from './link-domain.js';
 import { createProvider } from './providers/registry.js';
 const defaultDependencies = {
     createProvider,
-    resolveTarget: resolveProviderTarget,
+    resolveTarget: (input) => resolveProviderTarget(input, { transportErrorCode: 'DNS_POINT_FAILED' }),
 };
 export function createPointRecord(input) {
     const recordType = input.recordType ?? inferAddressRecordType(input.target.trim());
@@ -46,6 +48,9 @@ function dnsTargetConflictError(warning) {
     });
 }
 function providerResolutionError(error, input) {
+    if (error.code === 'PROVIDER_API_ERROR' && error.details instanceof Error) {
+        return new DoomainError('DNS_POINT_FAILED', error.details.message);
+    }
     if (error.code !== 'CONFIG_NOT_FOUND' && error.code !== 'PROVIDER_ZONE_NOT_FOUND')
         return error;
     const details = error.details && typeof error.details === 'object' ? error.details : {};
@@ -75,104 +80,101 @@ function validateTtl(provider, ttl) {
         throw new DoomainError('INVALID_INPUT', `${provider.name} requires a TTL no greater than ${maxTtl} seconds.`);
     }
 }
-export async function pointDomain(input, dependencies = defaultDependencies) {
-    let resolved;
-    try {
-        resolved = await dependencies.resolveTarget(input);
-    }
-    catch (error) {
-        if (error instanceof DoomainError)
-            throw providerResolutionError(error, input);
-        throw error;
-    }
-    const record = createPointRecord({
-        provider: resolved.provider,
-        recordName: resolved.target.recordName,
-        recordType: input.recordType,
-        target: input.target,
-        ttl: input.ttl,
-    });
-    const provider = await dependencies.createProvider(resolved.provider, { account: resolved.account });
-    validateTtl(provider, record.ttl);
-    if (!provider.capabilities.recordTypes.includes(record.type)) {
-        throw new DoomainError('PROVIDER_UNSUPPORTED_RECORD', `${provider.name} does not support ${record.type} records.`);
-    }
-    if (resolved.target.isApex && record.type === 'CNAME' && !provider.capabilities.supportsApexCname) {
-        throw new DoomainError('PROVIDER_UNSUPPORTED_RECORD', `${provider.name} does not support CNAME records at the zone apex. Use an A or AAAA target instead.`);
-    }
-    if (input.dryRun) {
+export function pointDomain(input, dependencies = defaultDependencies) {
+    return Effect.gen(function* () {
+        const resolved = yield* dependencies
+            .resolveTarget(input)
+            .pipe(Effect.mapError((error) => providerResolutionError(error, input)));
+        const record = yield* trySync(() => createPointRecord({
+            provider: resolved.provider,
+            recordName: resolved.target.recordName,
+            recordType: input.recordType,
+            target: input.target,
+            ttl: input.ttl,
+        }), 'INVALID_INPUT');
+        const provider = yield* dependencies.createProvider(resolved.provider, {
+            account: resolved.account,
+            transportErrorCode: 'DNS_POINT_FAILED',
+        });
+        yield* trySync(() => validateTtl(provider, record.ttl), 'INVALID_INPUT');
+        if (!provider.capabilities.recordTypes.includes(record.type)) {
+            return yield* Effect.fail(new DoomainError('PROVIDER_UNSUPPORTED_RECORD', `${provider.name} does not support ${record.type} records.`));
+        }
+        if (resolved.target.isApex && record.type === 'CNAME' && !provider.capabilities.supportsApexCname) {
+            return yield* Effect.fail(new DoomainError('PROVIDER_UNSUPPORTED_RECORD', `${provider.name} does not support CNAME records at the zone apex. Use an A or AAAA target instead.`));
+        }
+        if (input.dryRun) {
+            return {
+                account: resolved.account,
+                accountInferred: resolved.accountInferred,
+                domain: resolved.target.fullDomain,
+                dryRun: true,
+                isDefaultAccount: resolved.isDefaultAccount,
+                provider: resolved.provider,
+                providerInferred: resolved.providerInferred,
+                propagated: false,
+                propagation: { elapsedMs: 0, expected: record.value, observations: [], status: 'not_checked' },
+                reconciled: false,
+                reconciliationAttempts: 0,
+                record,
+                skipped: [],
+                updated: false,
+                zoneDomain: resolved.target.zoneDomain,
+            };
+        }
+        const zone = yield* provider.getZone(resolved.target.zoneDomain);
+        if (!zone) {
+            return yield* Effect.fail(new DoomainError('PROVIDER_ZONE_NOT_FOUND', `${provider.name} does not have a DNS zone for ${resolved.target.zoneDomain}.`));
+        }
+        input.progress?.(`Planning DNS change in ${provider.name}`);
+        let force = Boolean(input.force);
+        let plan = yield* provider.planChanges(zone, [record], { force });
+        if (!force && plan.conflicts.length > 0) {
+            const warning = conflictWarning(resolved, provider, record, plan.conflicts);
+            force = input.confirmDnsOverride
+                ? yield* tryPromise(() => input.confirmDnsOverride?.(warning) ?? Promise.resolve(false), 'DNS_POINT_FAILED')
+                : false;
+            if (!force)
+                return yield* Effect.fail(dnsTargetConflictError(warning));
+            plan = yield* provider.planChanges(zone, [record], { force: true });
+        }
+        input.progress?.(`Pointing ${resolved.target.fullDomain} to ${record.value}`);
+        const result = yield* provider.applyChanges(zone, plan, { force });
+        const reconciliation = yield* reconcileDesiredRecord({
+            desired: record,
+            progress: input.progress,
+            provider,
+            timeoutMs: (input.reconcileTimeoutSeconds ?? 30) * 1000,
+            zone,
+        });
+        const shouldWait = input.wait ?? true;
+        const propagation = shouldWait
+            ? yield* waitForDnsPropagation({
+                fqdn: recordFqdn(record, resolved.target.zoneDomain),
+                observe: dependencies.observeDns,
+                record,
+                timeoutSeconds: input.timeoutSeconds ?? 300,
+            })
+            : { elapsedMs: 0, expected: record.value, observations: [], status: 'not_checked' };
+        const propagated = propagation.status === 'propagated' ||
+            propagation.status === 'local_or_vpn_cache_stale' ||
+            propagation.status === 'system_resolver_unavailable';
         return {
             account: resolved.account,
             accountInferred: resolved.accountInferred,
             domain: resolved.target.fullDomain,
-            dryRun: true,
+            dryRun: false,
             isDefaultAccount: resolved.isDefaultAccount,
             provider: resolved.provider,
             providerInferred: resolved.providerInferred,
-            propagated: false,
-            propagation: {
-                elapsedMs: 0,
-                expected: record.value,
-                observations: [],
-                status: 'not_checked',
-            },
-            reconciled: false,
-            reconciliationAttempts: 0,
+            propagated,
+            propagation,
+            reconciled: reconciliation.reconciled,
+            reconciliationAttempts: reconciliation.attempts,
             record,
-            skipped: [],
-            updated: false,
+            skipped: result.skipped,
+            updated: result.applied.length > 0 || reconciliation.appliedChanges > 0,
             zoneDomain: resolved.target.zoneDomain,
         };
-    }
-    const zone = await provider.getZone(resolved.target.zoneDomain);
-    if (!zone)
-        throw new DoomainError('PROVIDER_ZONE_NOT_FOUND', `${provider.name} does not have a DNS zone for ${resolved.target.zoneDomain}.`);
-    input.progress?.(`Planning DNS change in ${provider.name}`);
-    let force = Boolean(input.force);
-    let plan = await provider.planChanges(zone, [record], { force });
-    if (!force && plan.conflicts.length > 0) {
-        const warning = conflictWarning(resolved, provider, record, plan.conflicts);
-        force = (await input.confirmDnsOverride?.(warning)) === true;
-        if (!force)
-            throw dnsTargetConflictError(warning);
-        plan = await provider.planChanges(zone, [record], { force: true });
-    }
-    input.progress?.(`Pointing ${resolved.target.fullDomain} to ${record.value}`);
-    const result = await provider.applyChanges(zone, plan, { force });
-    const reconciliation = await reconcileDesiredRecord({
-        desired: record,
-        progress: input.progress,
-        provider,
-        timeoutMs: (input.reconcileTimeoutSeconds ?? 30) * 1000,
-        zone,
     });
-    const shouldWait = input.wait ?? true;
-    const propagation = shouldWait
-        ? await waitForDnsPropagation({
-            fqdn: recordFqdn(record, resolved.target.zoneDomain),
-            observe: dependencies.observeDns,
-            record,
-            timeoutSeconds: input.timeoutSeconds ?? 300,
-        })
-        : { elapsedMs: 0, expected: record.value, observations: [], status: 'not_checked' };
-    const propagated = propagation.status === 'propagated' ||
-        propagation.status === 'local_or_vpn_cache_stale' ||
-        propagation.status === 'system_resolver_unavailable';
-    return {
-        account: resolved.account,
-        accountInferred: resolved.accountInferred,
-        domain: resolved.target.fullDomain,
-        dryRun: false,
-        isDefaultAccount: resolved.isDefaultAccount,
-        provider: resolved.provider,
-        providerInferred: resolved.providerInferred,
-        propagated,
-        propagation,
-        reconciled: reconciliation.reconciled,
-        reconciliationAttempts: reconciliation.attempts,
-        record,
-        skipped: result.skipped,
-        updated: result.applied.length > 0 || reconciliation.appliedChanges > 0,
-        zoneDomain: resolved.target.zoneDomain,
-    };
 }

package/dist/lib/providers/cloudflare/index.d.ts

@@ -1,3 +1,4 @@
+import { type DoomainEffect } from '../../effect.js';
 import type { DnsChange, DnsChangePlan, DnsProvider, DnsProviderDefinition, DnsRecord, DnsRecordInput, DnsZone, ProviderCapabilities, ProviderContext, ProviderHealth } from '../types.js';
 export declare class CloudflareProvider implements DnsProvider {
     readonly capabilities: ProviderCapabilities;
@@ -6,19 +7,19 @@ export declare class CloudflareProvider implements DnsProvider {
     private readonly accountId;
     private readonly http;
     constructor(context: ProviderContext);
-    verifyCredentials(): Promise<ProviderHealth>;
-    listZones(): Promise<DnsZone[]>;
-    getZone(domain: string): Promise<DnsZone | null>;
-    listRecords(zone: DnsZone): Promise<DnsRecord[]>;
+    verifyCredentials(): DoomainEffect<ProviderHealth>;
+    listZones(): DoomainEffect<DnsZone[]>;
+    getZone(domain: string): DoomainEffect<DnsZone | null>;
+    listRecords(zone: DnsZone): DoomainEffect<DnsRecord[]>;
     planChanges(zone: DnsZone, desired: DnsRecordInput[], opts?: {
         force?: boolean;
-    }): Promise<DnsChangePlan>;
-    applyChanges(zone: DnsZone, plan: DnsChangePlan): Promise<{
+    }): DoomainEffect<DnsChangePlan>;
+    applyChanges(zone: DnsZone, plan: DnsChangePlan): DoomainEffect<{
         applied: DnsChange[];
         skipped: DnsRecordInput[];
     }>;
-    upsertRecord(zone: DnsZone, record: DnsRecordInput): Promise<DnsRecord>;
-    deleteRecord(zone: DnsZone, record: DnsRecord): Promise<void>;
+    upsertRecord(zone: DnsZone, record: DnsRecordInput): DoomainEffect<DnsRecord>;
+    deleteRecord(zone: DnsZone, record: DnsRecord): DoomainEffect<void>;
     private createRecord;
     private updateRecord;
     private request;

package/dist/lib/providers/cloudflare/index.js

@@ -1,3 +1,5 @@
+import { Effect } from 'effect';
+import { trySync } from '../../effect.js';
 import { normalizeDomain } from '../../validate.js';
 import { ProviderError } from '../core/errors.js';
 import { createProviderHttpClient } from '../core/http.js';
@@ -94,114 +96,118 @@ export class CloudflareProvider {
             headers: { Authorization: `Bearer ${context.credentials.apiToken}` },
             providerId: this.id,
             signal: context.signal,
+            transportErrorCode: context.transportErrorCode,
         });
     }
-    async verifyCredentials() {
-        await this.listZones();
-        return { ok: true };
+    verifyCredentials() {
+        return this.listZones().pipe(Effect.as({ ok: true }));
     }
-    async listZones() {
-        const zones = [];
-        for (let page = 1; page <= 100; page += 1) {
-            const response = await this.request('/zones', {
-                query: { 'account.id': this.accountId, direction: 'asc', order: 'name', page, per_page: 50 },
-            });
-            for (const zone of response.result ?? []) {
-                const dnsZone = toZone(zone);
-                if (dnsZone)
-                    zones.push(dnsZone);
+    listZones() {
+        return Effect.gen(this, function* () {
+            const zones = [];
+            for (let page = 1; page <= 100; page += 1) {
+                const response = yield* this.request('/zones', {
+                    query: { 'account.id': this.accountId, direction: 'asc', order: 'name', page, per_page: 50 },
+                });
+                for (const zone of response.result ?? []) {
+                    const dnsZone = toZone(zone);
+                    if (dnsZone)
+                        zones.push(dnsZone);
+                }
+                const totalPages = response.result_info?.total_pages ?? page;
+                if (page >= totalPages || (response.result ?? []).length === 0)
+                    break;
             }
-            const totalPages = response.result_info?.total_pages ?? page;
-            if (page >= totalPages || (response.result ?? []).length === 0)
-                break;
-        }
-        return zones;
+            return zones;
+        });
     }
-    async getZone(domain) {
-        const normalized = normalizeDomain(domain);
-        const zones = await this.listZones();
-        return zones.find((zone) => zone.name === normalized) ?? null;
+    getZone(domain) {
+        return Effect.gen(this, function* () {
+            const normalized = yield* trySync(() => normalizeDomain(domain), 'INVALID_INPUT');
+            const zones = yield* this.listZones();
+            return zones.find((zone) => zone.name === normalized) ?? null;
+        });
     }
-    async listRecords(zone) {
-        const records = [];
-        for (let page = 1; page <= 100; page += 1) {
-            const response = await this.request(`/zones/${zone.id}/dns_records`, {
-                query: { page, per_page: 100 },
-            });
-            for (const record of response.result ?? []) {
-                const dnsRecord = toDnsRecord(record, zone);
-                if (dnsRecord)
-                    records.push(dnsRecord);
+    listRecords(zone) {
+        return Effect.gen(this, function* () {
+            const records = [];
+            for (let page = 1; page <= 100; page += 1) {
+                const response = yield* this.request(`/zones/${zone.id}/dns_records`, {
+                    query: { page, per_page: 100 },
+                });
+                for (const record of response.result ?? []) {
+                    const dnsRecord = toDnsRecord(record, zone);
+                    if (dnsRecord)
+                        records.push(dnsRecord);
+                }
+                const totalPages = response.result_info?.total_pages ?? page;
+                if (page >= totalPages || (response.result ?? []).length === 0)
+                    break;
             }
-            const totalPages = response.result_info?.total_pages ?? page;
-            if (page >= totalPages || (response.result ?? []).length === 0)
-                break;
-        }
-        return records;
-    }
-    async planChanges(zone, desired, opts = {}) {
-        return planDnsChanges({
-            desired,
-            existing: await this.listRecords(zone),
-            force: opts.force,
-            providerId: this.id,
-            zone,
+            return records;
         });
     }
-    async applyChanges(zone, plan) {
-        assertNoConflicts(this.id, plan);
-        const applied = [];
-        const skipped = [];
-        for (const change of plan.changes) {
-            if (change.action === 'skip') {
-                skipped.push(change.record);
-                continue;
+    planChanges(zone, desired, opts = {}) {
+        return this.listRecords(zone).pipe(Effect.map((existing) => planDnsChanges({ desired, existing, force: opts.force, providerId: this.id, zone })));
+    }
+    applyChanges(zone, plan) {
+        return Effect.gen(this, function* () {
+            yield* assertNoConflicts(this.id, plan);
+            const applied = [];
+            const skipped = [];
+            for (const change of plan.changes) {
+                if (change.action === 'skip') {
+                    skipped.push(change.record);
+                    continue;
+                }
+                if (change.action === 'delete')
+                    yield* this.deleteRecord(zone, change.existing);
+                else if (change.action === 'update')
+                    yield* this.updateRecord(zone, change.existing, change.record);
+                else
+                    yield* this.createRecord(zone, change.record);
+                applied.push(change);
             }
-            if (change.action === 'delete')
-                await this.deleteRecord(zone, change.existing);
-            else if (change.action === 'update')
-                await this.updateRecord(zone, change.existing, change.record);
-            else
-                await this.createRecord(zone, change.record);
-            applied.push(change);
-        }
-        return { applied, skipped };
+            return { applied, skipped };
+        });
     }
-    async upsertRecord(zone, record) {
-        const existing = (await this.listRecords(zone)).find((item) => item.name === record.name && item.type === record.type);
-        if (existing)
-            return this.updateRecord(zone, existing, record);
-        return this.createRecord(zone, record);
+    upsertRecord(zone, record) {
+        return Effect.gen(this, function* () {
+            const existing = (yield* this.listRecords(zone)).find((item) => item.name === record.name && item.type === record.type);
+            return yield* existing ? this.updateRecord(zone, existing, record) : this.createRecord(zone, record);
+        });
     }
-    async deleteRecord(zone, record) {
+    deleteRecord(zone, record) {
         if (!record.id)
-            throw new ProviderError(this.id, 'PROVIDER_API_ERROR', 'Cloudflare DNS record id is required to delete a record.');
-        await this.request(`/zones/${zone.id}/dns_records/${record.id}`, { method: 'DELETE' });
+            return Effect.fail(new ProviderError(this.id, 'PROVIDER_API_ERROR', 'Cloudflare DNS record id is required to delete a record.'));
+        return this.request(`/zones/${zone.id}/dns_records/${record.id}`, { method: 'DELETE' }).pipe(Effect.asVoid);
     }
-    async createRecord(zone, record) {
-        const response = await this.request(`/zones/${zone.id}/dns_records`, {
+    createRecord(zone, record) {
+        return this.request(`/zones/${zone.id}/dns_records`, {
             body: toCloudflareRecord(record, zone),
             method: 'POST',
-        });
-        const created = response.result ? toDnsRecord(response.result, zone) : null;
-        return created ?? { ...record, ttl: record.ttl ?? capabilities.defaultTtl };
+        }).pipe(Effect.map((response) => {
+            const created = response.result ? toDnsRecord(response.result, zone) : null;
+            return created ?? { ...record, ttl: record.ttl ?? capabilities.defaultTtl };
+        }));
     }
-    async updateRecord(zone, existing, record) {
+    updateRecord(zone, existing, record) {
         if (!existing.id)
-            throw new ProviderError(this.id, 'PROVIDER_API_ERROR', 'Cloudflare DNS record id is required to update a record.');
-        const response = await this.request(`/zones/${zone.id}/dns_records/${existing.id}`, {
+            return Effect.fail(new ProviderError(this.id, 'PROVIDER_API_ERROR', 'Cloudflare DNS record id is required to update a record.'));
+        return this.request(`/zones/${zone.id}/dns_records/${existing.id}`, {
             body: toCloudflareRecord(record, zone),
             method: 'PUT',
-        });
-        const updated = response.result ? toDnsRecord(response.result, zone) : null;
-        return updated ?? { ...record, id: existing.id, ttl: record.ttl ?? capabilities.defaultTtl };
+        }).pipe(Effect.map((response) => {
+            const updated = response.result ? toDnsRecord(response.result, zone) : null;
+            return updated ?? { ...record, id: existing.id, ttl: record.ttl ?? capabilities.defaultTtl };
+        }));
     }
-    async request(path, init = {}) {
-        const response = await this.http.request(path, init);
-        if (response.success === false) {
-            throw new ProviderError(this.id, 'PROVIDER_API_ERROR', cloudflareErrorMessage(response), response.errors);
-        }
-        return response;
+    request(path, init = {}) {
+        return this.http
+            .request(path, init)
+            .pipe(Effect.flatMap((response) => response.success === false
+            ? Effect.fail(new ProviderError(this.id, 'PROVIDER_API_ERROR', cloudflareErrorMessage(response), response.errors))
+            : Effect.succeed(response)));
     }
 }
 export const cloudflareProviderDefinition = {

package/dist/lib/providers/core/config.d.ts

@@ -1,4 +1,6 @@
 import { type DoomainConfig, type ProviderConfig } from '../../config.js';
+import { type DoomainEffect } from '../../effect.js';
+import { type DoomainErrorCode } from '../../errors.js';
 import type { CredentialDefinition, DnsProviderDefinition, ProviderContext } from './types.js';
 export declare const DEFAULT_PROVIDER_ACCOUNT = "default";
 export interface ProviderAccountRef {
@@ -8,6 +10,7 @@ export interface ProviderAccountRef {
 }
 export interface ProviderAccountOptions {
     account?: string;
+    transportErrorCode?: DoomainErrorCode;
 }
 export declare function normalizeProviderAccount(account?: string): string;
 export declare function isDefaultProviderAccount(account?: string): boolean;
@@ -17,4 +20,4 @@ export declare function providerAccountHasCredentials(config: DoomainConfig, pro
 export declare function withProviderAccountCredentials(current: ProviderConfig | undefined, accountInput: string, credentials: Record<string, string>): ProviderConfig;
 export declare function isProviderAccountConfigured(definition: DnsProviderDefinition, config: DoomainConfig, opts?: ProviderAccountOptions): boolean;
 export declare function listConfiguredProviderAccounts(config: DoomainConfig, definition: DnsProviderDefinition): ProviderAccountRef[];
-export declare function createProviderContext(definition: DnsProviderDefinition, opts?: ProviderAccountOptions): Promise<ProviderContext>;
+export declare function createProviderContext(definition: DnsProviderDefinition, opts?: ProviderAccountOptions): DoomainEffect<ProviderContext>;

package/dist/lib/providers/core/config.js

@@ -1,4 +1,6 @@
+import { Effect } from 'effect';
 import { loadConfig } from '../../config.js';
+import { trySync } from '../../effect.js';
 import { DoomainError } from '../../errors.js';
 import { ensureProviderAccount } from '../../validate.js';
 export const DEFAULT_PROVIDER_ACCOUNT = 'default';
@@ -83,18 +85,20 @@ export function listConfiguredProviderAccounts(config, definition) {
     }
     return accounts;
 }
-export async function createProviderContext(definition, opts = {}) {
-    const config = await loadConfig();
-    const credentials = {};
-    const account = normalizeProviderAccount(opts.account);
-    for (const credential of definition.credentials) {
-        const value = getProviderCredential(config, definition.id, credential, { account });
-        if (value)
-            credentials[credential.key] = value;
-        else if (credential.required !== false) {
-            const accountHint = account === DEFAULT_PROVIDER_ACCOUNT ? '' : ` for account ${account}`;
-            throw new DoomainError('MISSING_CREDENTIALS', `Missing ${definition.displayName} ${credential.label}${accountHint}. Run \`doomain providers connect ${definition.id}${account === DEFAULT_PROVIDER_ACCOUNT ? '' : ` --account ${account}`}\` or set ${credential.env}.`, { account, provider: definition.id });
+export function createProviderContext(definition, opts = {}) {
+    return Effect.gen(function* () {
+        const config = yield* loadConfig();
+        const credentials = {};
+        const account = yield* trySync(() => normalizeProviderAccount(opts.account), 'INVALID_INPUT');
+        for (const credential of definition.credentials) {
+            const value = getProviderCredential(config, definition.id, credential, { account });
+            if (value)
+                credentials[credential.key] = value;
+            else if (credential.required !== false) {
+                const accountHint = account === DEFAULT_PROVIDER_ACCOUNT ? '' : ` for account ${account}`;
+                return yield* Effect.fail(new DoomainError('MISSING_CREDENTIALS', `Missing ${definition.displayName} ${credential.label}${accountHint}. Run \`doomain providers connect ${definition.id}${account === DEFAULT_PROVIDER_ACCOUNT ? '' : ` --account ${account}`}\` or set ${credential.env}.`, { account, provider: definition.id }));
+            }
         }
-    }
-    return { credentials, debug: process.env.DOOMAIN_DEBUG === '1' };
+        return { credentials, debug: process.env.DOOMAIN_DEBUG === '1', transportErrorCode: opts.transportErrorCode };
+    });
 }

package/dist/lib/providers/core/http.d.ts

@@ -1,9 +1,12 @@
+import type { DoomainEffect } from '../../effect.js';
+import { type DoomainErrorCode } from '../../errors.js';
 export interface ProviderHttpClientOptions {
     baseUrl: string;
     errorMessages?: Partial<Record<number, string>>;
     headers?: Record<string, string>;
     providerId: string;
     signal?: AbortSignal;
+    transportErrorCode?: DoomainErrorCode;
 }
 export interface ProviderRequestOptions extends Omit<RequestInit, 'body'> {
     body?: unknown;
@@ -12,6 +15,6 @@ export interface ProviderRequestOptions extends Omit<RequestInit, 'body'> {
 export declare class ProviderHttpClient {
     private readonly opts;
     constructor(opts: ProviderHttpClientOptions);
-    request<T>(path: string, init?: ProviderRequestOptions): Promise<T>;
+    request<T>(path: string, init?: ProviderRequestOptions): DoomainEffect<T>;
 }
 export declare function createProviderHttpClient(opts: ProviderHttpClientOptions): ProviderHttpClient;

package/dist/lib/providers/core/http.js

@@ -1,3 +1,5 @@
+import { Effect } from 'effect';
+import { toDoomainError } from '../../errors.js';
 import { ProviderError, providerCodeFromStatus } from './errors.js';
 function appendQuery(path, query) {
     if (!query)
@@ -17,25 +19,33 @@ export class ProviderHttpClient {
     constructor(opts) {
         this.opts = opts;
     }
-    async request(path, init = {}) {
-        const { body, headers, query, ...rest } = init;
-        const response = await fetch(`${this.opts.baseUrl}${appendQuery(path, query)}`, {
-            ...rest,
-            body: body === undefined ? undefined : JSON.stringify(body),
-            headers: {
-                'Content-Type': 'application/json',
-                ...this.opts.headers,
-                ...headers,
-            },
-            signal: init.signal ?? this.opts.signal,
+    request(path, init = {}) {
+        return Effect.gen(this, function* () {
+            const { body, headers, query, ...rest } = init;
+            const response = yield* Effect.tryPromise({
+                try: (signal) => fetch(`${this.opts.baseUrl}${appendQuery(path, query)}`, {
+                    ...rest,
+                    body: body === undefined ? undefined : JSON.stringify(body),
+                    headers: {
+                        'Content-Type': 'application/json',
+                        ...this.opts.headers,
+                        ...headers,
+                    },
+                    signal: init.signal ?? this.opts.signal ?? signal,
+                }),
+                catch: (cause) => toDoomainError(cause, this.opts.transportErrorCode ?? 'PROVIDER_API_ERROR'),
+            });
+            if (!response.ok) {
+                const details = yield* Effect.tryPromise(() => response.json()).pipe(Effect.catchAll(() => Effect.succeed(undefined)));
+                return yield* Effect.fail(new ProviderError(this.opts.providerId, providerCodeFromStatus(response.status), this.opts.errorMessages?.[response.status] ?? `${this.opts.providerId} API error (${response.status}).`, details));
+            }
+            if (response.status === 204)
+                return undefined;
+            return (yield* Effect.tryPromise({
+                try: () => response.json(),
+                catch: (cause) => toDoomainError(cause, this.opts.transportErrorCode ?? 'PROVIDER_API_ERROR'),
+            }));
         });
-        if (!response.ok) {
-            const details = await response.json().catch(() => undefined);
-            throw new ProviderError(this.opts.providerId, providerCodeFromStatus(response.status), this.opts.errorMessages?.[response.status] ?? `${this.opts.providerId} API error (${response.status}).`, details);
-        }
-        if (response.status === 204)
-            return undefined;
-        return (await response.json().catch(() => undefined));
     }
 }
 export function createProviderHttpClient(opts) {

package/dist/lib/providers/core/pagination.d.ts

@@ -1,12 +1,13 @@
+import type { DoomainEffect } from '../../effect.js';
 export interface SkipPaginationInput<T> {
     fetchPage(input: {
         skip: number;
         take: number;
-    }): Promise<{
+    }): DoomainEffect<{
         items: T[];
         total: number;
     }>;
     maxPages?: number;
     take: number;
 }
-export declare function paginateBySkip<T>(input: SkipPaginationInput<T>): Promise<T[]>;
+export declare function paginateBySkip<T>(input: SkipPaginationInput<T>): DoomainEffect<T[]>;