doomain 0.1.23 → 0.1.24

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

@@ -1,15 +1,18 @@
-export async function paginateBySkip(input) {
-    const items = [];
-    const maxPages = input.maxPages ?? 100;
-    let skip = 0;
-    let total = Number.POSITIVE_INFINITY;
-    for (let page = 0; skip < total && page < maxPages; page += 1) {
-        const result = await input.fetchPage({ skip, take: input.take });
-        items.push(...result.items);
-        total = result.total;
-        if (result.items.length === 0)
-            break;
-        skip += result.items.length;
-    }
-    return items;
+import { Effect } from 'effect';
+export function paginateBySkip(input) {
+    return Effect.gen(function* () {
+        const items = [];
+        const maxPages = input.maxPages ?? 100;
+        let skip = 0;
+        let total = Number.POSITIVE_INFINITY;
+        for (let page = 0; skip < total && page < maxPages; page += 1) {
+            const result = yield* input.fetchPage({ skip, take: input.take });
+            items.push(...result.items);
+            total = result.total;
+            if (result.items.length === 0)
+                break;
+            skip += result.items.length;
+        }
+        return items;
+    });
 }

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

@@ -1,3 +1,4 @@
+import type { DoomainEffect } from '../../effect.js';
 import type { DnsChange, DnsChangePlan, DnsRecord, DnsRecordInput, DnsZone, PlanOptions } from './types.js';
 export declare function planDnsChanges(input: {
     desired: DnsRecordInput[];
@@ -6,14 +7,14 @@ export declare function planDnsChanges(input: {
     providerId: string;
     zone: DnsZone;
 }): DnsChangePlan;
-export declare function assertNoConflicts(providerId: string, plan: DnsChangePlan): void;
+export declare function assertNoConflicts(providerId: string, plan: DnsChangePlan): DoomainEffect<void>;
 export declare function applyDnsChanges(input: {
-    deleteRecord(record: DnsRecord): Promise<void>;
+    deleteRecord(record: DnsRecord): DoomainEffect<void>;
     plan: DnsChangePlan;
     providerId: string;
-    upsertRecord(record: DnsRecordInput): Promise<DnsRecord>;
+    upsertRecord(record: DnsRecordInput): DoomainEffect<DnsRecord>;
     opts?: PlanOptions;
-}): Promise<{
+}): DoomainEffect<{
     applied: DnsChange[];
     skipped: DnsRecordInput[];
 }>;

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

@@ -1,3 +1,4 @@
+import { Effect } from 'effect';
 import { ProviderError } from './errors.js';
 function cleanDnsValue(value) {
     return value.toLowerCase().replace(/\.$/, '');
@@ -60,22 +61,24 @@ export function planDnsChanges(input) {
 }
 export function assertNoConflicts(providerId, plan) {
     if (plan.conflicts.length === 0)
-        return;
-    throw new ProviderError(providerId, 'PROVIDER_RECORD_CONFLICT', 'DNS record conflicts must be resolved before applying changes.', {
+        return Effect.void;
+    return Effect.fail(new ProviderError(providerId, 'PROVIDER_RECORD_CONFLICT', 'DNS record conflicts must be resolved before applying changes.', {
         conflicts: plan.conflicts,
-    });
+    }));
 }
-export async function applyDnsChanges(input) {
-    assertNoConflicts(input.providerId, input.plan);
-    const applied = [];
-    const skipped = [];
-    for (const change of input.plan.changes) {
-        if (change.action === 'skip') {
-            skipped.push(change.record);
-            continue;
+export function applyDnsChanges(input) {
+    return Effect.gen(function* () {
+        yield* assertNoConflicts(input.providerId, input.plan);
+        const applied = [];
+        const skipped = [];
+        for (const change of input.plan.changes) {
+            if (change.action === 'skip') {
+                skipped.push(change.record);
+                continue;
+            }
+            yield* change.action === 'delete' ? input.deleteRecord(change.existing) : input.upsertRecord(change.record);
+            applied.push(change);
         }
-        await (change.action === 'delete' ? input.deleteRecord(change.existing) : input.upsertRecord(change.record));
-        applied.push(change);
-    }
-    return { applied, skipped };
+        return { applied, skipped };
+    });
 }

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

@@ -1,3 +1,5 @@
+import type { DoomainEffect } from '../../effect.js';
+import type { DoomainErrorCode } from '../../errors.js';
 export type DnsRecordType = 'A' | 'AAAA' | 'CNAME' | 'MX' | 'TXT';
 export interface CredentialDefinition {
     description?: string;
@@ -97,19 +99,20 @@ export interface ProviderContext {
     credentials: Record<string, string>;
     debug?: boolean;
     signal?: AbortSignal;
+    transportErrorCode?: DoomainErrorCode;
 }
 export interface DnsProvider {
     capabilities: ProviderCapabilities;
     id: string;
     name: string;
-    applyChanges(zone: DnsZone, plan: DnsChangePlan, opts?: ApplyOptions): Promise<DnsChangeResult>;
-    deleteRecord(zone: DnsZone, record: DnsRecord): Promise<void>;
-    getZone(domain: string): Promise<DnsZone | null>;
-    listRecords(zone: DnsZone): Promise<DnsRecord[]>;
-    listZones(input?: ListZonesInput): Promise<DnsZone[]>;
-    planChanges(zone: DnsZone, desired: DnsRecordInput[], opts?: PlanOptions): Promise<DnsChangePlan>;
-    upsertRecord(zone: DnsZone, record: DnsRecordInput): Promise<DnsRecord>;
-    verifyCredentials(): Promise<ProviderHealth>;
+    applyChanges(zone: DnsZone, plan: DnsChangePlan, opts?: ApplyOptions): DoomainEffect<DnsChangeResult>;
+    deleteRecord(zone: DnsZone, record: DnsRecord): DoomainEffect<void>;
+    getZone(domain: string): DoomainEffect<DnsZone | null>;
+    listRecords(zone: DnsZone): DoomainEffect<DnsRecord[]>;
+    listZones(input?: ListZonesInput): DoomainEffect<DnsZone[]>;
+    planChanges(zone: DnsZone, desired: DnsRecordInput[], opts?: PlanOptions): DoomainEffect<DnsChangePlan>;
+    upsertRecord(zone: DnsZone, record: DnsRecordInput): DoomainEffect<DnsRecord>;
+    verifyCredentials(): DoomainEffect<ProviderHealth>;
 }
 export interface DnsProviderDefinition {
     capabilities: ProviderCapabilities;

package/dist/lib/providers/hostinger/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 HostingerProvider implements DnsProvider {
     readonly capabilities: ProviderCapabilities;
@@ -5,19 +6,19 @@ export declare class HostingerProvider implements DnsProvider {
     readonly name = "Hostinger";
     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 putRecords;
     private putHostingerRecordSets;
 }

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

@@ -1,3 +1,5 @@
+import { Effect } from 'effect';
+import { trySync } from '../../effect.js';
 import { normalizeDomain } from '../../validate.js';
 import { createProviderHttpClient } from '../core/http.js';
 import { assertNoConflicts, planDnsChanges } from '../core/planner.js';
@@ -107,91 +109,89 @@ export class HostingerProvider {
             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 domains = await this.http.request('/api/domains/v1/portfolio');
-        return domains.flatMap((domain) => {
+    listZones() {
+        return this.http.request('/api/domains/v1/portfolio').pipe(Effect.map((domains) => domains.flatMap((domain) => {
             const zone = toZone(domain);
             return zone ? [zone] : [];
-        });
+        })));
     }
-    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 = await this.http.request(`/api/dns/v1/zones/${encodeURIComponent(zone.name)}`);
-        return records.flatMap((record) => toDnsRecords(record, zone));
+    listRecords(zone) {
+        return this.http
+            .request(`/api/dns/v1/zones/${encodeURIComponent(zone.name)}`)
+            .pipe(Effect.map((records) => records.flatMap((record) => toDnsRecords(record, zone))));
     }
-    async planChanges(zone, desired, opts = {}) {
-        const plan = planDnsChanges({
-            desired,
-            existing: await this.listRecords(zone),
-            force: opts.force,
-            providerId: this.id,
-            zone,
-        });
-        return collapseRecordSetWrites(plan);
+    planChanges(zone, desired, opts = {}) {
+        return this.listRecords(zone).pipe(Effect.map((existing) => collapseRecordSetWrites(planDnsChanges({ desired, existing, force: opts.force, providerId: this.id, zone }))));
     }
-    async applyChanges(zone, plan) {
-        assertNoConflicts(this.id, plan);
-        const applied = [];
-        const skipped = [];
-        const deletionSets = new Map();
-        for (const change of plan.changes) {
-            if (change.action !== 'delete')
-                continue;
-            const key = `${change.existing.type}\0${change.existing.name}`;
-            const records = deletionSets.get(key) ?? [];
-            records.push(change.existing);
-            deletionSets.set(key, records);
-        }
-        for (const deleted of deletionSets.values()) {
-            const sample = deleted[0];
-            const source = sample.metadata?.hostinger;
-            const deletedValues = new Set(deleted.map((record) => record.value));
-            const sourceRecords = source?.records?.filter((record) => record.is_disabled || !record.content || !deletedValues.has(record.content));
-            if (source && sourceRecords && sourceRecords.length > 0) {
-                await this.putHostingerRecordSets(zone, [{ ...source, records: sourceRecords }], true);
+    applyChanges(zone, plan) {
+        return Effect.gen(this, function* () {
+            yield* assertNoConflicts(this.id, plan);
+            const applied = [];
+            const skipped = [];
+            const deletionSets = new Map();
+            for (const change of plan.changes) {
+                if (change.action !== 'delete')
+                    continue;
+                const key = `${change.existing.type}\0${change.existing.name}`;
+                const records = deletionSets.get(key) ?? [];
+                records.push(change.existing);
+                deletionSets.set(key, records);
             }
-            else {
-                const remaining = plan.existing.filter((record) => sameRecordSet(record, sample) && !deleted.includes(record));
-                if (remaining.length > 0)
-                    await this.putRecords(zone, remaining, true);
-                else
-                    await this.deleteRecord(zone, sample);
+            for (const deleted of deletionSets.values()) {
+                const sample = deleted[0];
+                const source = sample.metadata?.hostinger;
+                const deletedValues = new Set(deleted.map((record) => record.value));
+                const sourceRecords = source?.records?.filter((record) => record.is_disabled || !record.content || !deletedValues.has(record.content));
+                if (source && sourceRecords && sourceRecords.length > 0) {
+                    yield* this.putHostingerRecordSets(zone, [{ ...source, records: sourceRecords }], true);
+                }
+                else {
+                    const remaining = plan.existing.filter((record) => sameRecordSet(record, sample) && !deleted.includes(record));
+                    if (remaining.length > 0)
+                        yield* this.putRecords(zone, remaining, true);
+                    else
+                        yield* this.deleteRecord(zone, sample);
+                }
+                applied.push(...plan.changes.filter((change) => change.action === 'delete' && deleted.includes(change.existing)));
             }
-            applied.push(...plan.changes.filter((change) => change.action === 'delete' && deleted.includes(change.existing)));
-        }
-        for (const change of plan.changes) {
-            if (change.action === 'skip') {
-                skipped.push(change.record);
-                continue;
+            for (const change of plan.changes) {
+                if (change.action === 'skip') {
+                    skipped.push(change.record);
+                    continue;
+                }
+                if (change.action === 'delete')
+                    continue;
+                yield* this.putRecords(zone, [change.record], change.action === 'update');
+                applied.push(change);
             }
-            if (change.action === 'delete')
-                continue;
-            await this.putRecords(zone, [change.record], change.action === 'update');
-            applied.push(change);
-        }
-        return { applied, skipped };
+            return { applied, skipped };
+        });
     }
-    async upsertRecord(zone, record) {
-        await this.putRecords(zone, [record], true);
-        return { ...record, ttl: record.ttl ?? capabilities.defaultTtl };
+    upsertRecord(zone, record) {
+        return this.putRecords(zone, [record], true).pipe(Effect.as({ ...record, ttl: record.ttl ?? capabilities.defaultTtl }));
     }
-    async deleteRecord(zone, record) {
-        await this.http.request(`/api/dns/v1/zones/${encodeURIComponent(zone.name)}`, {
+    deleteRecord(zone, record) {
+        return this.http
+            .request(`/api/dns/v1/zones/${encodeURIComponent(zone.name)}`, {
             body: { filters: [deleteFilter(record)] },
             method: 'DELETE',
-        });
+        })
+            .pipe(Effect.asVoid);
     }
-    async putRecords(zone, records, overwrite) {
+    putRecords(zone, records, overwrite) {
         const recordSets = new Map();
         for (const record of records) {
             const key = `${record.type}\0${record.name}`;
@@ -199,13 +199,15 @@ export class HostingerProvider {
             values.push(record);
             recordSets.set(key, values);
         }
-        await this.putHostingerRecordSets(zone, [...recordSets.values()].map(toHostingerRecordSet), overwrite);
+        return this.putHostingerRecordSets(zone, [...recordSets.values()].map(toHostingerRecordSet), overwrite);
     }
-    async putHostingerRecordSets(zone, recordSets, overwrite) {
-        await this.http.request(`/api/dns/v1/zones/${encodeURIComponent(zone.name)}`, {
+    putHostingerRecordSets(zone, recordSets, overwrite) {
+        return this.http
+            .request(`/api/dns/v1/zones/${encodeURIComponent(zone.name)}`, {
             body: { overwrite, zone: recordSets },
             method: 'PUT',
-        });
+        })
+            .pipe(Effect.asVoid);
     }
 }
 export const hostingerProviderDefinition = {

package/dist/lib/providers/namecheap/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 NamecheapProvider implements DnsProvider {
     readonly capabilities: ProviderCapabilities;
@@ -7,21 +8,22 @@ export declare class NamecheapProvider implements DnsProvider {
     private readonly apiUser;
     private readonly baseUrl;
     private readonly clientIp;
+    private readonly transportErrorCode;
     private readonly username;
     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 setHosts;
     private request;
 }