doomain 0.1.22 → 0.1.24

package/dist/lib/remove-domain.js

@@ -1,9 +1,14 @@
+import { Effect } from 'effect';
 import { reconcileRecordRemoval } from './dns-reconciliation.js';
 import { recordMatchesSelector } from './dns-records.js';
 import { resolveProviderTarget } from './domain-provider.js';
+import { tryPromise } from './effect.js';
 import { DoomainError } from './errors.js';
 import { createProvider } from './providers/registry.js';
-const defaultDependencies = { createProvider, resolveTarget: resolveProviderTarget };
+const defaultDependencies = {
+    createProvider,
+    resolveTarget: (input) => resolveProviderTarget(input, { transportErrorCode: 'DNS_REMOVE_FAILED' }),
+};
 function quoteCommandArgument(value) {
     return /^[a-zA-Z0-9_./:@+-]+$/.test(value) ? value : `'${value.replaceAll("'", `'"'"'`)}'`;
 }
@@ -41,85 +46,86 @@ function ambiguousDeletionError(input, records) {
         suggestedCommands: [removalCommand(input, { allMatching: true, dryRun: true })],
     });
 }
-export async function removeDomain(input, dependencies = defaultDependencies) {
-    if (!input.allMatching && input.value === undefined) {
-        throw new DoomainError('INVALID_INPUT', 'An exact --value is required unless --all-matching is passed.', {
-            recovery: 'Pass --value <expected-value>, or preview --all-matching with --dry-run.',
+export function removeDomain(input, dependencies = defaultDependencies) {
+    return Effect.gen(function* () {
+        if (!input.allMatching && input.value === undefined) {
+            return yield* Effect.fail(new DoomainError('INVALID_INPUT', 'An exact --value is required unless --all-matching is passed.', {
+                recovery: 'Pass --value <expected-value>, or preview --all-matching with --dry-run.',
+            }));
+        }
+        const resolved = yield* dependencies
+            .resolveTarget(input)
+            .pipe(Effect.mapError((error) => removalResolutionError(error, input)));
+        const provider = yield* dependencies.createProvider(resolved.provider, {
+            account: resolved.account,
+            transportErrorCode: 'DNS_REMOVE_FAILED',
+        });
+        if (!provider.capabilities.recordTypes.includes(input.recordType)) {
+            return yield* Effect.fail(new DoomainError('PROVIDER_UNSUPPORTED_RECORD', `${provider.name} does not support ${input.recordType} records.`));
+        }
+        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}.`));
+        }
+        const selector = {
+            name: resolved.target.recordName,
+            type: input.recordType,
+            ...(input.value === undefined ? {} : { value: input.value }),
+        };
+        const existing = yield* provider.listRecords(zone);
+        const matched = existing.filter((record) => recordMatchesSelector(record, selector));
+        if (matched.length > 1 && !input.allMatching) {
+            const confirmed = input.confirmMultiple
+                ? yield* tryPromise(() => input.confirmMultiple?.(matched) ?? Promise.resolve(false), 'DNS_REMOVE_FAILED')
+                : false;
+            if (!confirmed)
+                return yield* Effect.fail(ambiguousDeletionError(input, matched));
+        }
+        const base = {
+            account: resolved.account,
+            accountInferred: resolved.accountInferred,
+            domain: resolved.target.fullDomain,
+            isDefaultAccount: resolved.isDefaultAccount,
+            matched,
+            provider: resolved.provider,
+            providerInferred: resolved.providerInferred,
+            selector,
+            zoneDomain: resolved.target.zoneDomain,
+        };
+        if (input.dryRun) {
+            return {
+                ...base,
+                dryRun: true,
+                reconciled: false,
+                reconciliationAttempts: 0,
+                removed: 0,
+            };
+        }
+        if (matched.length === 0) {
+            return { ...base, dryRun: false, reconciled: true, reconciliationAttempts: 1, removed: 0 };
+        }
+        input.progress?.(`Deleting ${matched.length} DNS record${matched.length === 1 ? '' : 's'}`);
+        const plan = {
+            changes: matched.map((record) => ({ action: 'delete', existing: record })),
+            conflicts: [],
+            desired: [],
+            existing,
+            zone,
+        };
+        yield* provider.applyChanges(zone, plan, { force: true });
+        const reconciliation = yield* reconcileRecordRemoval({
+            progress: input.progress,
+            provider,
+            selector,
+            timeoutMs: (input.reconcileTimeoutSeconds ?? 30) * 1000,
+            zone,
         });
-    }
-    let resolved;
-    try {
-        resolved = await dependencies.resolveTarget(input);
-    }
-    catch (error) {
-        if (error instanceof DoomainError)
-            throw removalResolutionError(error, input);
-        throw error;
-    }
-    const provider = await dependencies.createProvider(resolved.provider, { account: resolved.account });
-    if (!provider.capabilities.recordTypes.includes(input.recordType)) {
-        throw new DoomainError('PROVIDER_UNSUPPORTED_RECORD', `${provider.name} does not support ${input.recordType} records.`);
-    }
-    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}.`);
-    }
-    const selector = {
-        name: resolved.target.recordName,
-        type: input.recordType,
-        ...(input.value === undefined ? {} : { value: input.value }),
-    };
-    const existing = await provider.listRecords(zone);
-    const matched = existing.filter((record) => recordMatchesSelector(record, selector));
-    if (matched.length > 1 && !input.allMatching) {
-        const confirmed = (await input.confirmMultiple?.(matched)) === true;
-        if (!confirmed)
-            throw ambiguousDeletionError(input, matched);
-    }
-    const base = {
-        account: resolved.account,
-        accountInferred: resolved.accountInferred,
-        domain: resolved.target.fullDomain,
-        isDefaultAccount: resolved.isDefaultAccount,
-        matched,
-        provider: resolved.provider,
-        providerInferred: resolved.providerInferred,
-        selector,
-        zoneDomain: resolved.target.zoneDomain,
-    };
-    if (input.dryRun) {
         return {
             ...base,
-            dryRun: true,
-            reconciled: false,
-            reconciliationAttempts: 0,
-            removed: 0,
+            dryRun: false,
+            reconciled: reconciliation.reconciled,
+            reconciliationAttempts: reconciliation.attempts,
+            removed: matched.length,
         };
-    }
-    if (matched.length === 0) {
-        return { ...base, dryRun: false, reconciled: true, reconciliationAttempts: 1, removed: 0 };
-    }
-    input.progress?.(`Deleting ${matched.length} DNS record${matched.length === 1 ? '' : 's'}`);
-    const plan = {
-        changes: matched.map((record) => ({ action: 'delete', existing: record })),
-        conflicts: [],
-        desired: [],
-        existing,
-        zone,
-    };
-    await provider.applyChanges(zone, plan, { force: true });
-    const reconciliation = await reconcileRecordRemoval({
-        progress: input.progress,
-        provider,
-        selector,
-        timeoutMs: (input.reconcileTimeoutSeconds ?? 30) * 1000,
-        zone,
     });
-    return {
-        ...base,
-        dryRun: false,
-        reconciled: reconciliation.reconciled,
-        reconciliationAttempts: reconciliation.attempts,
-        removed: matched.length,
-    };
 }

package/dist/lib/self-update.d.ts

@@ -1,3 +1,4 @@
+import type { DoomainEffect } from './effect.js';
 interface ProcessResult {
     exitCode: number | null;
     stderr: string;
@@ -7,7 +8,7 @@ interface ProcessOptions {
     env: NodeJS.ProcessEnv;
     shell: boolean;
 }
-type ProcessRunner = (command: string, args: string[], options: ProcessOptions) => Promise<ProcessResult>;
+type ProcessRunner = (command: string, args: string[], options: ProcessOptions) => DoomainEffect<ProcessResult>;
 export interface SelfUpdateResult {
     package: string;
     packageSpec: string;
@@ -23,5 +24,5 @@ export declare function npmInstallCommand(cacheDirectory: string, platform?: Nod
     command: string;
     options: ProcessOptions;
 };
-export declare function installLatestVersion(options?: SelfUpdateOptions): Promise<SelfUpdateResult>;
+export declare function installLatestVersion(options?: SelfUpdateOptions): DoomainEffect<SelfUpdateResult>;
 export {};

package/dist/lib/self-update.js

@@ -2,9 +2,10 @@ import { spawn } from 'node:child_process';
 import { mkdtemp, rm } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { Effect } from 'effect';
 import { DoomainError } from './errors.js';
 function runProcess(command, args, options) {
-    return new Promise((resolve, reject) => {
+    return Effect.async((resume) => {
         const child = spawn(command, args, {
             ...options,
             stdio: ['ignore', 'pipe', 'pipe'],
@@ -20,8 +21,9 @@ function runProcess(command, args, options) {
         child.stdout.on('data', (chunk) => {
             stdout += chunk;
         });
-        child.once('error', reject);
-        child.once('close', (exitCode) => resolve({ exitCode, stderr, stdout }));
+        child.once('error', (cause) => resume(Effect.fail(new DoomainError('SELF_UPDATE_FAILED', `Unable to start npm: ${cause.message}`, cause))));
+        child.once('close', (exitCode) => resume(Effect.succeed({ exitCode, stderr, stdout })));
+        return Effect.sync(() => child.kill());
     });
 }
 export function npmInstallCommand(cacheDirectory, platform = process.platform, environment = process.env) {
@@ -36,28 +38,18 @@ export function npmInstallCommand(cacheDirectory, platform = process.platform, e
         },
     };
 }
-export async function installLatestVersion(options = {}) {
-    const cacheDirectory = await mkdtemp(join(options.cacheRoot ?? tmpdir(), 'doomain-npm-cache-'));
-    try {
+export function installLatestVersion(options = {}) {
+    const acquire = Effect.tryPromise({
+        try: () => mkdtemp(join(options.cacheRoot ?? tmpdir(), 'doomain-npm-cache-')),
+        catch: (cause) => new DoomainError('SELF_UPDATE_FAILED', `Unable to create npm cache: ${String(cause)}`, cause),
+    });
+    return Effect.acquireUseRelease(acquire, (cacheDirectory) => Effect.gen(function* () {
         const invocation = npmInstallCommand(cacheDirectory, options.platform);
-        const result = await (options.runner ?? runProcess)(invocation.command, invocation.args, invocation.options);
+        const result = yield* (options.runner ?? runProcess)(invocation.command, invocation.args, invocation.options);
         if (result.exitCode !== 0) {
             const reason = result.stderr.trim() || result.stdout.trim() || `npm exited with code ${result.exitCode ?? 'unknown'}`;
-            throw new DoomainError('SELF_UPDATE_FAILED', `Unable to update doomain: ${reason}`);
+            return yield* Effect.fail(new DoomainError('SELF_UPDATE_FAILED', `Unable to update doomain: ${reason}`));
         }
-        return {
-            package: 'doomain',
-            packageSpec: 'doomain@latest',
-            packageManager: 'npm',
-        };
-    }
-    catch (error) {
-        if (error instanceof DoomainError)
-            throw error;
-        const message = error instanceof Error ? error.message : String(error);
-        throw new DoomainError('SELF_UPDATE_FAILED', `Unable to update doomain: ${message}`);
-    }
-    finally {
-        await rm(cacheDirectory, { force: true, recursive: true }).catch(() => undefined);
-    }
+        return { package: 'doomain', packageSpec: 'doomain@latest', packageManager: 'npm' };
+    }), (cacheDirectory) => Effect.tryPromise(() => rm(cacheDirectory, { force: true, recursive: true })).pipe(Effect.ignore));
 }

package/dist/lib/vercel-auth.d.ts

@@ -1,3 +1,4 @@
+import type { DoomainEffect } from './effect.js';
 export type GlobalVercelTokenSource = 'environment' | 'vercel-cli';
 export interface GlobalVercelToken {
     authFile?: string;
@@ -10,4 +11,4 @@ export declare function listGlobalVercelTokens(opts?: {
     authFile?: string;
     authFiles?: string[];
     env?: NodeJS.ProcessEnv;
-}): Promise<GlobalVercelToken[]>;
+}): DoomainEffect<GlobalVercelToken[], never>;

package/dist/lib/vercel-auth.js

@@ -2,6 +2,7 @@ import { existsSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { delimiter, join } from 'node:path';
+import { Effect } from 'effect';
 function xdgDataHome(env) {
     if (env.XDG_DATA_HOME)
         return env.XDG_DATA_HOME;
@@ -25,30 +26,26 @@ export function getVercelCliAuthFiles(env = process.env) {
         join(homedir(), '.vercel'),
     ].map((dir) => join(dir, 'auth.json'));
 }
-async function readVercelCliToken(authFile) {
-    try {
-        const data = JSON.parse(await readFile(authFile, 'utf8'));
-        return typeof data.token === 'string' && data.token.trim() ? data.token.trim() : undefined;
-    }
-    catch {
-        return undefined;
-    }
+function readVercelCliToken(authFile) {
+    return Effect.tryPromise(() => readFile(authFile, 'utf8')).pipe(Effect.flatMap((contents) => Effect.try(() => JSON.parse(contents))), Effect.map((data) => (typeof data.token === 'string' && data.token.trim() ? data.token.trim() : undefined)), Effect.catchAll(() => Effect.succeed(undefined)));
 }
-export async function listGlobalVercelTokens(opts = {}) {
-    const env = opts.env ?? process.env;
-    const tokens = [];
-    const envToken = env.VERCEL_TOKEN?.trim();
-    if (envToken) {
-        tokens.push({ label: 'VERCEL_TOKEN', source: 'environment', token: envToken });
-    }
-    const authFiles = opts.authFile ? [opts.authFile] : (opts.authFiles ?? getVercelCliAuthFiles(env));
-    for (const authFile of authFiles) {
-        if (!existsSync(authFile))
-            continue;
-        const cliToken = await readVercelCliToken(authFile);
-        if (cliToken && !tokens.some((item) => item.token === cliToken)) {
-            tokens.push({ authFile, label: 'Vercel CLI', source: 'vercel-cli', token: cliToken });
+export function listGlobalVercelTokens(opts = {}) {
+    return Effect.gen(function* () {
+        const env = opts.env ?? process.env;
+        const tokens = [];
+        const envToken = env.VERCEL_TOKEN?.trim();
+        if (envToken) {
+            tokens.push({ label: 'VERCEL_TOKEN', source: 'environment', token: envToken });
         }
-    }
-    return tokens;
+        const authFiles = opts.authFile ? [opts.authFile] : (opts.authFiles ?? getVercelCliAuthFiles(env));
+        for (const authFile of authFiles) {
+            if (!existsSync(authFile))
+                continue;
+            const cliToken = yield* readVercelCliToken(authFile);
+            if (cliToken && !tokens.some((item) => item.token === cliToken)) {
+                tokens.push({ authFile, label: 'Vercel CLI', source: 'vercel-cli', token: cliToken });
+            }
+        }
+        return tokens;
+    });
 }

package/dist/lib/vercel.d.ts

@@ -1,3 +1,5 @@
+import type { DoomainEffect } from './effect.js';
+import { type DoomainErrorCode } from './errors.js';
 export declare const VERCEL_APEX_A_RECORD = "76.76.21.21";
 export declare const VERCEL_CNAME_RECORD = "cname.vercel-dns.com";
 export interface VercelProject {
@@ -23,26 +25,28 @@ interface VercelProjectDomainOwner {
     };
     project: VercelProject;
 }
-export declare function resolveVercelConfig(): Promise<VercelConfig>;
-export declare function createVercelClient(config: VercelConfig): {
-    listTeams(): Promise<VercelTeam[]>;
-    listProjects(search?: string): Promise<VercelProject[]>;
+export declare function resolveVercelConfig(): DoomainEffect<VercelConfig>;
+export declare function createVercelClient(config: VercelConfig, clientOpts?: {
+    transportErrorCode?: DoomainErrorCode;
+}): {
+    listTeams(): DoomainEffect<VercelTeam[]>;
+    listProjects(search?: string): DoomainEffect<VercelProject[]>;
     addDomainToProject(project: string, domain: string, opts?: {
         force?: boolean;
-    }): Promise<{
+    }): DoomainEffect<{
         alreadyAdded: boolean;
         raw?: unknown;
     }>;
-    findProjectDomainOwner(domain: string): Promise<VercelProjectDomainOwner | undefined>;
-    getDomainConfig(domain: string): Promise<Record<string, unknown>>;
-    getRecommendedCname(domain: string): Promise<string>;
-    getProjectDomain(project: string, domain: string): Promise<Record<string, unknown>>;
-    listProjectDomains(project: string): Promise<Array<Record<string, unknown> & {
+    findProjectDomainOwner(domain: string): DoomainEffect<VercelProjectDomainOwner | undefined>;
+    getDomainConfig(domain: string): DoomainEffect<Record<string, unknown>>;
+    getRecommendedCname(domain: string): DoomainEffect<string>;
+    getProjectDomain(project: string, domain: string): DoomainEffect<Record<string, unknown>>;
+    listProjectDomains(project: string): DoomainEffect<Array<Record<string, unknown> & {
         name?: string;
         projectId?: string;
     }>>;
-    removeDomainFromProject(project: string, domain: string): Promise<void>;
-    verifyProjectDomain(project: string, domain: string): Promise<Record<string, unknown>>;
+    removeDomainFromProject(project: string, domain: string): DoomainEffect<void>;
+    verifyProjectDomain(project: string, domain: string): DoomainEffect<Record<string, unknown>>;
 };
 export type VercelClient = ReturnType<typeof createVercelClient>;
 export {};