doomain 0.1.10 → 0.1.12

package/dist/lib/config.d.ts

@@ -6,10 +6,13 @@ export interface VercelConfig {
     token?: string;
     teamId?: string;
 }
-export interface ProviderConfig {
+export interface ProviderAccountConfig {
     credentials?: Record<string, string>;
     settings?: Record<string, unknown>;
 }
+export interface ProviderConfig extends ProviderAccountConfig {
+    accounts?: Record<string, ProviderAccountConfig | undefined>;
+}
 export interface SpaceshipProviderConfig extends ProviderConfig {
     apiKey?: string;
     apiSecret?: string;

package/dist/lib/flags.d.ts

@@ -1,5 +1,6 @@
 export declare const jsonFlag: import("@oclif/core/interfaces").BooleanFlag<boolean>;
 export declare const providerFlag: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+export declare const accountFlag: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
 export declare const domainFlag: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
 export declare const subdomainFlag: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
 export declare const apexFlag: import("@oclif/core/interfaces").BooleanFlag<boolean>;

package/dist/lib/flags.js

@@ -1,6 +1,7 @@
 import { Flags } from '@oclif/core';
 export const jsonFlag = Flags.boolean({ description: 'Output a single JSON object and never prompt.' });
 export const providerFlag = Flags.string({ description: 'DNS provider id. Inferred from the target domain when omitted.' });
+export const accountFlag = Flags.string({ description: 'DNS provider profile/account alias. Defaults to the provider default account.' });
 export const domainFlag = Flags.string({ description: 'Target domain or base zone, for example app.example.com or example.com.' });
 export const subdomainFlag = Flags.string({ description: 'Subdomain to add, for example app for app.example.com.' });
 export const apexFlag = Flags.boolean({ description: 'Use the root/apex domain instead of a subdomain.' });

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

@@ -1,6 +1,7 @@
 import type { DnsRecordInput } from './providers/types.js';
 export interface LinkDomainInput {
     provider?: string;
+    account?: string;
     domain?: string;
     subdomain?: string;
     apex?: boolean;
@@ -21,6 +22,9 @@ export type LinkDomainProgressCallback = (progress: LinkDomainProgress) => void;
 export interface LinkDomainPlan {
     provider: string;
     providerInferred: boolean;
+    account: string;
+    accountInferred: boolean;
+    isDefaultAccount: boolean;
     project: string;
     projectSource: LinkDomainProjectSource;
     recordName: string;

package/dist/lib/link-domain.js

@@ -4,8 +4,9 @@ import { dirname, join, parse } from 'node:path';
 import { loadConfig } from './config.js';
 import { DoomainError } from './errors.js';
 import { detectLocalVercelProject } from './local-vercel.js';
+import { DEFAULT_PROVIDER_ACCOUNT, isDefaultProviderAccount, listConfiguredProviderAccounts, normalizeProviderAccount, } from './providers/core/config.js';
 import { createProvider, getProviderDefinition, listProviderDefinitions } from './providers/registry.js';
-import { isProviderConfigured, listProviderStatuses } from './providers/status.js';
+import { listProviderStatuses } from './providers/status.js';
 import { normalizeDomain, normalizeSubdomain } from './validate.js';
 import { createVercelClient, resolveVercelConfig, VERCEL_APEX_A_RECORD, VERCEL_CNAME_RECORD } from './vercel.js';
 function cleanDnsValue(value) {
@@ -118,10 +119,12 @@ async function resolveZone(provider, zoneDomain) {
 async function providerConnectionDetails() {
     return (await listProviderStatuses({ verify: false })).map((provider) => ({
         configured: provider.configured,
+        account: provider.account,
         default: provider.default,
         displayName: provider.displayName,
         docsUrl: provider.docsUrl,
         id: provider.id,
+        isDefaultAccount: provider.isDefaultAccount,
     }));
 }
 function resolveRequestedDomain(opts) {
@@ -155,51 +158,91 @@ function targetFromZone(fullDomain, zoneDomain) {
 }
 function candidateDetails(candidates) {
     return candidates.map((candidate) => ({
+        account: candidate.account,
+        isDefaultAccount: candidate.isDefaultAccount,
         provider: candidate.provider,
         providerName: candidate.providerName,
         zoneDomain: candidate.zone.name,
     }));
 }
-async function loadProviderZones(definition) {
-    const provider = await createProvider(definition.id);
+function defaultAccountRef(providerId) {
+    return { account: DEFAULT_PROVIDER_ACCOUNT, isDefaultAccount: true, providerId };
+}
+function explicitAccountRef(providerId, account) {
+    const normalized = normalizeProviderAccount(account);
+    return { account: normalized, isDefaultAccount: isDefaultProviderAccount(normalized), providerId };
+}
+async function loadProviderZones(definition, account) {
+    const provider = await createProvider(definition.id, { account: account.account });
     const zones = await provider.listZones();
     return {
-        candidates: zones.map((zone) => ({ provider: definition.id, providerName: definition.displayName, zone })),
-        search: { displayName: definition.displayName, id: definition.id, zones: zones.map((zone) => zone.name) },
+        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 loadConfiguredProviderZones(providerId) {
+async function loadConfiguredProviderZones(providerId, accountInput) {
+    const config = await loadConfig();
+    const account = accountInput ? normalizeProviderAccount(accountInput) : undefined;
     if (providerId) {
         const definition = getProviderDefinition(providerId);
-        const result = await loadProviderZones(definition);
-        return { candidates: result.candidates, providerInferred: false, searched: [result.search] };
+        const accounts = account ? [explicitAccountRef(definition.id, account)] : listConfiguredProviderAccounts(config, definition);
+        const selectedAccounts = accounts.length > 0 ? accounts : [defaultAccountRef(definition.id)];
+        const results = await Promise.all(selectedAccounts.map((ref) => loadProviderZones(definition, ref)));
+        return {
+            accountInferred: account === undefined,
+            candidates: results.flatMap((result) => result.candidates),
+            providerInferred: false,
+            searched: results.map((result) => result.search),
+        };
     }
-    const config = await loadConfig();
-    const definitions = listProviderDefinitions().filter((definition) => isProviderConfigured(definition, config));
-    if (definitions.length === 0) {
-        throw new DoomainError('CONFIG_NOT_FOUND', 'No DNS provider is configured. Run `doomain providers connect` first.', {
+    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: ['doomain providers connect', '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(definitions.map(async (definition) => {
+    const results = await Promise.all(providerAccounts.map(async ({ definition, ref }) => {
         try {
-            return await loadProviderZones(definition);
+            return await loadProviderZones(definition, ref);
         }
         catch (error) {
             return {
                 candidates: [],
                 search: {
+                    account: ref.account,
                     displayName: definition.displayName,
                     error: error instanceof Error ? error.message : String(error),
                     id: definition.id,
+                    isDefaultAccount: ref.isDefaultAccount,
                     zones: [],
                 },
             };
         }
     }));
     return {
+        accountInferred: account === undefined,
         candidates: results.flatMap((result) => result.candidates),
         providerInferred: true,
         searched: results.map((result) => result.search),
@@ -211,30 +254,35 @@ async function resolveProviderTarget(input) {
         domain: await resolveConfiguredDomain(input.domain),
         subdomain: input.subdomain,
     });
-    const zones = await loadConfiguredProviderZones(input.provider);
+    const zones = await loadConfiguredProviderZones(input.provider, input.account);
     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} does not have a matching DNS zone for ${requested.fullDomain}.`
+            ? `${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> only if another configured provider owns this zone. Otherwise connect the DNS provider that owns this domain.',
+            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> --json`, 'doomain providers connect'],
+            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.zone.name === candidate.zone.name) === index);
+    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 providers have a matching DNS zone for ${requested.fullDomain}. Pass --provider to choose one.`, { candidates: candidateDetails(uniqueBestMatches), domain: requested.fullDomain });
+        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),
@@ -414,9 +462,12 @@ function reportProgress(input, stage, message) {
 export async function createLinkPlan(input) {
     const project = await resolveProject(input.project);
     const resolved = await resolveProviderTarget(input);
-    const { provider, providerInferred, target } = resolved;
+    const { account, accountInferred, isDefaultAccount, provider, providerInferred, target } = resolved;
     const record = planBaseRecord({ isApex: target.isApex, provider, recordName: target.recordName });
     return {
+        account,
+        accountInferred,
+        isDefaultAccount,
         provider,
         providerInferred,
         project: project.project,
@@ -441,7 +492,7 @@ export async function linkDomain(input) {
         };
     }
     const vercel = createVercelClient(await resolveVercelConfig());
-    const provider = await createProvider(plan.provider);
+    const provider = await createProvider(plan.provider, { account: plan.account });
     reportProgress(input, 'dns:resolve-zone', `Finding ${provider.name} DNS zone`);
     const zone = await resolveZone(provider, plan.zoneDomain);
     reportProgress(input, 'vercel:add-domain', 'Adding domain to Vercel');

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

@@ -1,5 +1,20 @@
-import { type DoomainConfig } from '../../config.js';
+import { type DoomainConfig, type ProviderConfig } from '../../config.js';
 import type { CredentialDefinition, DnsProviderDefinition, ProviderContext } from './types.js';
-export declare function getProviderCredentials(config: DoomainConfig, providerId: string): Record<string, string>;
-export declare function getProviderCredential(config: DoomainConfig, providerId: string, credential: CredentialDefinition): string | undefined;
-export declare function createProviderContext(definition: DnsProviderDefinition): Promise<ProviderContext>;
+export declare const DEFAULT_PROVIDER_ACCOUNT = "default";
+export interface ProviderAccountRef {
+    account: string;
+    isDefaultAccount: boolean;
+    providerId: string;
+}
+export interface ProviderAccountOptions {
+    account?: string;
+}
+export declare function normalizeProviderAccount(account?: string): string;
+export declare function isDefaultProviderAccount(account?: string): boolean;
+export declare function getProviderCredentials(config: DoomainConfig, providerId: string, opts?: ProviderAccountOptions): Record<string, string>;
+export declare function getProviderCredential(config: DoomainConfig, providerId: string, credential: CredentialDefinition, opts?: ProviderAccountOptions): string | undefined;
+export declare function providerAccountHasCredentials(config: DoomainConfig, providerId: string, accountInput?: string): boolean;
+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>;

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

@@ -1,5 +1,19 @@
 import { loadConfig } from '../../config.js';
 import { DoomainError } from '../../errors.js';
+import { ensureProviderAccount } from '../../validate.js';
+export const DEFAULT_PROVIDER_ACCOUNT = 'default';
+export function normalizeProviderAccount(account) {
+    if (!account?.trim())
+        return DEFAULT_PROVIDER_ACCOUNT;
+    return ensureProviderAccount(account);
+}
+export function isDefaultProviderAccount(account) {
+    return normalizeProviderAccount(account) === DEFAULT_PROVIDER_ACCOUNT;
+}
+function providerConfig(config, providerId) {
+    const value = config.providers?.[providerId];
+    return value && typeof value === 'object' ? value : undefined;
+}
 function legacyCredential(config, providerId, key) {
     if (providerId !== 'spaceship')
         return undefined;
@@ -8,25 +22,77 @@ function legacyCredential(config, providerId, key) {
         return undefined;
     return legacy[key];
 }
-export function getProviderCredentials(config, providerId) {
-    const providerConfig = config.providers?.[providerId];
-    const credentials = providerConfig && typeof providerConfig === 'object' && 'credentials' in providerConfig
-        ? (providerConfig.credentials ?? {})
-        : {};
-    return { ...credentials };
+function credentialFromSavedConfig(config, providerId, account, key) {
+    const credentials = getProviderCredentials(config, providerId, { account });
+    if (credentials[key])
+        return credentials[key];
+    if (account === DEFAULT_PROVIDER_ACCOUNT)
+        return legacyCredential(config, providerId, key);
+    return undefined;
+}
+function hasCredentials(credentials) {
+    return credentials !== undefined && Object.keys(credentials).length > 0;
+}
+export function getProviderCredentials(config, providerId, opts = {}) {
+    const account = normalizeProviderAccount(opts.account);
+    const current = providerConfig(config, providerId);
+    const credentials = account === DEFAULT_PROVIDER_ACCOUNT ? current?.credentials : current?.accounts?.[account]?.credentials;
+    return { ...(credentials ?? {}) };
+}
+export function getProviderCredential(config, providerId, credential, opts = {}) {
+    const account = normalizeProviderAccount(opts.account);
+    return process.env[credential.env] || credentialFromSavedConfig(config, providerId, account, credential.key);
 }
-export function getProviderCredential(config, providerId, credential) {
-    return process.env[credential.env] || getProviderCredentials(config, providerId)[credential.key] || legacyCredential(config, providerId, credential.key);
+export function providerAccountHasCredentials(config, providerId, accountInput) {
+    const account = normalizeProviderAccount(accountInput);
+    const current = providerConfig(config, providerId);
+    if (!current)
+        return false;
+    if (account !== DEFAULT_PROVIDER_ACCOUNT)
+        return hasCredentials(current.accounts?.[account]?.credentials);
+    return hasCredentials(current.credentials) || Boolean(legacyCredential(config, providerId, 'apiKey') || legacyCredential(config, providerId, 'apiSecret'));
+}
+export function withProviderAccountCredentials(current, accountInput, credentials) {
+    const account = normalizeProviderAccount(accountInput);
+    if (account === DEFAULT_PROVIDER_ACCOUNT)
+        return { ...current, credentials };
+    return {
+        ...current,
+        accounts: {
+            ...current?.accounts,
+            [account]: { credentials },
+        },
+    };
+}
+export function isProviderAccountConfigured(definition, config, opts = {}) {
+    return definition.credentials.every((credential) => credential.required === false || Boolean(getProviderCredential(config, definition.id, credential, opts)));
+}
+export function listConfiguredProviderAccounts(config, definition) {
+    const accounts = [];
+    if (isProviderAccountConfigured(definition, config, { account: DEFAULT_PROVIDER_ACCOUNT })) {
+        accounts.push({ account: DEFAULT_PROVIDER_ACCOUNT, isDefaultAccount: true, providerId: definition.id });
+    }
+    for (const account of Object.keys(providerConfig(config, definition.id)?.accounts ?? {}).sort()) {
+        const normalized = normalizeProviderAccount(account);
+        if (normalized === DEFAULT_PROVIDER_ACCOUNT)
+            continue;
+        if (!isProviderAccountConfigured(definition, config, { account: normalized }))
+            continue;
+        accounts.push({ account: normalized, isDefaultAccount: false, providerId: definition.id });
+    }
+    return accounts;
 }
-export async function createProviderContext(definition) {
+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);
+        const value = getProviderCredential(config, definition.id, credential, { account });
         if (value)
             credentials[credential.key] = value;
         else if (credential.required !== false) {
-            throw new DoomainError('MISSING_CREDENTIALS', `Missing ${definition.displayName} ${credential.label}. Run \`doomain providers connect ${definition.id}\` or set ${credential.env}.`);
+            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 });
         }
     }
     return { credentials, debug: process.env.DOOMAIN_DEBUG === '1' };

package/dist/lib/providers/registry.d.ts

@@ -1,4 +1,6 @@
 import type { DnsProvider, DnsProviderDefinition } from './types.js';
 export declare function listProviderDefinitions(): DnsProviderDefinition[];
 export declare function getProviderDefinition(id: string): DnsProviderDefinition;
-export declare function createProvider(id: string): Promise<DnsProvider>;
+export declare function createProvider(id: string, opts?: {
+    account?: string;
+}): Promise<DnsProvider>;

package/dist/lib/providers/registry.js

@@ -16,7 +16,7 @@ export function getProviderDefinition(id) {
         throw new DoomainError('PROVIDER_NOT_FOUND', `Unsupported DNS provider: ${id}`);
     return definition;
 }
-export async function createProvider(id) {
+export async function createProvider(id, opts = {}) {
     const definition = getProviderDefinition(id);
-    return definition.create(await createProviderContext(definition));
+    return definition.create(await createProviderContext(definition, opts));
 }

package/dist/lib/providers/status.d.ts

@@ -1,6 +1,7 @@
 import { type DoomainConfig } from '../config.js';
 import type { DnsProviderDefinition } from './types.js';
 export interface ProviderStatus {
+    account: string;
     configured: boolean;
     default: boolean;
     displayName: string;
@@ -8,9 +9,12 @@ export interface ProviderStatus {
     domainCount?: number;
     error?: string;
     id: string;
+    isDefaultAccount: boolean;
     verified?: boolean;
 }
-export declare function isProviderConfigured(definition: DnsProviderDefinition, config: DoomainConfig): boolean;
+export declare function isProviderConfigured(definition: DnsProviderDefinition, config: DoomainConfig, opts?: {
+    account?: string;
+}): boolean;
 export declare function listProviderStatuses(opts?: {
     verify?: boolean;
 }): Promise<ProviderStatus[]>;

package/dist/lib/providers/status.js

@@ -1,33 +1,40 @@
 import { loadConfig } from '../config.js';
-import { getProviderCredential } from './core/config.js';
+import { DEFAULT_PROVIDER_ACCOUNT, isProviderAccountConfigured, listConfiguredProviderAccounts, normalizeProviderAccount, } from './core/config.js';
 import { createProvider, listProviderDefinitions } from './registry.js';
-export function isProviderConfigured(definition, config) {
-    return definition.credentials.every((credential) => credential.required === false || Boolean(getProviderCredential(config, definition.id, credential)));
+export function isProviderConfigured(definition, config, opts = {}) {
+    return isProviderAccountConfigured(definition, config, opts);
 }
 export async function listProviderStatuses(opts = {}) {
     const config = await loadConfig();
     const statuses = [];
     for (const definition of listProviderDefinitions()) {
-        const configured = isProviderConfigured(definition, config);
-        const status = {
-            configured,
-            default: config.defaults?.provider === definition.id,
-            displayName: definition.displayName,
-            docsUrl: definition.docsUrl,
-            id: definition.id,
-        };
-        if (configured && opts.verify) {
-            try {
-                const zones = await (await createProvider(definition.id)).listZones();
-                status.domainCount = zones.length;
-                status.verified = true;
-            }
-            catch (error) {
-                status.error = error instanceof Error ? error.message : String(error);
-                status.verified = false;
+        const accounts = listConfiguredProviderAccounts(config, definition);
+        const refs = accounts.length > 0 ? accounts : [{ account: DEFAULT_PROVIDER_ACCOUNT, isDefaultAccount: true, providerId: definition.id }];
+        for (const ref of refs) {
+            const account = normalizeProviderAccount(ref.account);
+            const configured = accounts.some((item) => item.account === account);
+            const status = {
+                account,
+                configured,
+                default: config.defaults?.provider === definition.id,
+                displayName: definition.displayName,
+                docsUrl: definition.docsUrl,
+                id: definition.id,
+                isDefaultAccount: ref.isDefaultAccount,
+            };
+            if (configured && opts.verify) {
+                try {
+                    const zones = await (await createProvider(definition.id, { account })).listZones();
+                    status.domainCount = zones.length;
+                    status.verified = true;
+                }
+                catch (error) {
+                    status.error = error instanceof Error ? error.message : String(error);
+                    status.verified = false;
+                }
             }
+            statuses.push(status);
         }
-        statuses.push(status);
     }
     return statuses;
 }

package/dist/lib/validate.d.ts

@@ -12,4 +12,5 @@ export declare function resolveDomainTarget(opts: {
     apex?: boolean;
 }): DomainTarget;
 export declare function ensureProviderId(value: string): string;
+export declare function ensureProviderAccount(value: string): string;
 export declare function ensureProject(value?: string): string;

package/dist/lib/validate.js

@@ -54,6 +54,13 @@ export function ensureProviderId(value) {
     }
     return provider;
 }
+export function ensureProviderAccount(value) {
+    const account = value.trim().toLowerCase();
+    if (!/^[a-z0-9][a-z0-9-]*$/.test(account)) {
+        throw new DoomainError('INVALID_INPUT', `Invalid provider account alias: ${value}`);
+    }
+    return account;
+}
 export function ensureProject(value) {
     const project = value?.trim();
     if (!project)