@mtndev/cli 1.1.0 → 2.0.1

package/cjs/commands/aws/route53/add-record/schema.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Common Route53 record types offered in the interactive picker.
+ * Alias records are not supported by this command.
+ */
+export const RECORD_TYPES: string[];
+/**
+ * Default TTL (seconds) when creating or replacing a record set.
+ */
+export const DEFAULT_TTL: 300;
+/**
+ * Zod schema for `aws route53 add-record` options.
+ */
+export const addRecordOptionsSchema: z.ZodObject<{
+    profile: z.ZodOptional<z.ZodString>;
+    zone: z.ZodOptional<z.ZodString>;
+    type: z.ZodEffects<z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, string | undefined>, string | undefined, string | undefined>;
+    name: z.ZodOptional<z.ZodString>;
+    value: z.ZodOptional<z.ZodString>;
+    ttl: z.ZodOptional<z.ZodNumber>;
+    yes: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    dryRun: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    verbose: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    verbose: boolean;
+    yes: boolean;
+    dryRun: boolean;
+    profile?: string | undefined;
+    value?: string | undefined;
+    type?: string | undefined;
+    name?: string | undefined;
+    zone?: string | undefined;
+    ttl?: number | undefined;
+}, {
+    profile?: string | undefined;
+    verbose?: boolean | undefined;
+    yes?: boolean | undefined;
+    value?: string | undefined;
+    type?: string | undefined;
+    dryRun?: boolean | undefined;
+    name?: string | undefined;
+    zone?: string | undefined;
+    ttl?: number | undefined;
+}>;
+export type AddRecordOptions = z.infer<typeof addRecordOptionsSchema>;
+import { z } from "zod";

package/cjs/commands/aws/route53/add-record/utils.cjs

@@ -0,0 +1,404 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_commands_aws_utils_exec_aws = require("../../utils/exec-aws.cjs");
+require("./schema.cjs");
+//#region src/commands/aws/route53/add-record/utils.js
+/**
+* @typedef {Object} HostedZone
+* @property {string} id - Bare hosted zone ID (without /hostedzone/ prefix)
+* @property {string} name - Zone name with trailing dot (e.g. mountaindev.com.)
+* @property {boolean} privateZone
+* @property {number} recordCount
+*/
+/**
+* @typedef {Object} ResourceRecordSet
+* @property {string} name
+* @property {string} type
+* @property {number | undefined} ttl
+* @property {string[]} values
+* @property {boolean} isAlias
+* @property {any} [aliasTarget] - Raw AliasTarget block (present when isAlias)
+*/
+/**
+* Strip the `/hostedzone/` prefix from a Route53 hosted zone Id.
+* @param {string} rawId
+* @returns {string}
+*/
+function bareHostedZoneId(rawId) {
+	return rawId.replace(/^\/hostedzone\//, "");
+}
+/**
+* Ensure a DNS name ends with a trailing dot (Route53 FQDN form).
+* @param {string} name
+* @returns {string}
+*/
+function withTrailingDot(name) {
+	const trimmed = name.trim();
+	if (trimmed === "") return trimmed;
+	return trimmed.endsWith(".") ? trimmed : `${trimmed}.`;
+}
+/**
+* Strip a trailing dot for display.
+* @param {string} name
+* @returns {string}
+*/
+function withoutTrailingDot(name) {
+	return name.endsWith(".") ? name.slice(0, -1) : name;
+}
+/**
+* List hosted zones for the profile.
+* @param {{ profile?: string; verbose?: boolean }} params
+* @returns {HostedZone[]}
+*/
+function listHostedZones(params) {
+	const { profile, verbose } = params;
+	const data = require_commands_aws_utils_exec_aws.runAws({
+		profile,
+		args: ["route53", "list-hosted-zones"],
+		verbose
+	});
+	/** @type {HostedZone[]} */
+	const zones = [];
+	for (const zone of data.HostedZones ?? []) {
+		const id = bareHostedZoneId(String(zone.Id ?? ""));
+		const name = withTrailingDot(String(zone.Name ?? ""));
+		if (!id || !name) continue;
+		zones.push({
+			id,
+			name,
+			privateZone: Boolean(zone.Config?.PrivateZone),
+			recordCount: Number(zone.ResourceRecordSetCount ?? 0)
+		});
+	}
+	return zones.sort((a, b) => a.name.localeCompare(b.name));
+}
+/**
+* Resolve a hosted zone from a name (mountaindev.com) or bare/prefixed ID.
+* @param {{ zones: HostedZone[]; zoneInput: string }} params
+* @returns {HostedZone | null}
+*/
+function findHostedZone(params) {
+	const { zones, zoneInput } = params;
+	const input = zoneInput.trim();
+	if (!input) return null;
+	const bareId = bareHostedZoneId(input);
+	const byId = zones.find((zone) => zone.id === bareId);
+	if (byId) return byId;
+	const normalized = withTrailingDot(input).toLowerCase();
+	const matches = zones.filter((zone) => zone.name.toLowerCase() === normalized);
+	if (matches.length === 1) return matches[0] ?? null;
+	if (matches.length > 1) return matches.find((zone) => !zone.privateZone) ?? matches[0] ?? null;
+	return null;
+}
+/**
+* Build a display label for a hosted zone in the picker.
+* @param {HostedZone} zone
+* @returns {string}
+*/
+function hostedZoneLabel(zone) {
+	const visibility = zone.privateZone ? "private" : "public";
+	return `${withoutTrailingDot(zone.name)}  (${zone.id}, ${visibility}, ${zone.recordCount} records)`;
+}
+/**
+* Turn a relative or absolute name into a Route53 FQDN under the zone.
+* Apex / "@" / empty → the zone apex.
+* @param {{ nameInput: string; zoneName: string }} params
+* @returns {string} FQDN with trailing dot
+*/
+function resolveRecordName(params) {
+	const { nameInput, zoneName } = params;
+	const zoneFqdn = withTrailingDot(zoneName);
+	const raw = nameInput.trim();
+	if (raw === "" || raw === "@") return zoneFqdn;
+	const asFqdn = withTrailingDot(raw);
+	const zoneLower = zoneFqdn.toLowerCase();
+	if (asFqdn.toLowerCase() === zoneLower) return zoneFqdn;
+	if (asFqdn.toLowerCase().endsWith(`.${zoneLower}`)) return asFqdn;
+	return withTrailingDot(`${raw.replace(/\.$/, "")}.${withoutTrailingDot(zoneFqdn)}`);
+}
+/**
+* Fetch every resource record set at an exact name, across all types.
+* Paginates when needed; Route53 list is ordered by name then type.
+* @param {{
+*   profile?: string;
+*   hostedZoneId: string;
+*   name: string;
+*   verbose?: boolean;
+* }} params
+* @returns {ResourceRecordSet[]}
+*/
+function getRecordSetsAtName(params) {
+	const { profile, hostedZoneId, name, verbose } = params;
+	const targetName = withTrailingDot(name).toLowerCase();
+	let startRecordName = withTrailingDot(name);
+	/** @type {string | undefined} */
+	let startRecordType;
+	/** @type {string | undefined} */
+	let nextRecordIdentifier;
+	/** @type {ResourceRecordSet[]} */
+	const collected = [];
+	for (let page = 0; page < 20; page += 1) {
+		/** @type {string[]} */
+		const args = [
+			"route53",
+			"list-resource-record-sets",
+			"--hosted-zone-id",
+			hostedZoneId,
+			"--max-items",
+			"100"
+		];
+		if (startRecordName) args.push("--start-record-name", startRecordName);
+		if (startRecordType) args.push("--start-record-type", startRecordType);
+		if (nextRecordIdentifier) args.push("--start-record-identifier", nextRecordIdentifier);
+		const data = require_commands_aws_utils_exec_aws.runAws({
+			profile,
+			args,
+			verbose
+		});
+		const sets = data.ResourceRecordSets ?? [];
+		for (const set of sets) {
+			const setName = withTrailingDot(String(set.Name ?? "")).toLowerCase();
+			if (setName === targetName) {
+				collected.push(normalizeRecordSet(set));
+				continue;
+			}
+			if (setName > targetName) return collected;
+		}
+		if (!(data.IsTruncated === true)) return collected;
+		startRecordName = data.NextRecordName ? String(data.NextRecordName) : startRecordName;
+		startRecordType = data.NextRecordType ? String(data.NextRecordType) : void 0;
+		nextRecordIdentifier = data.NextRecordIdentifier ? String(data.NextRecordIdentifier) : void 0;
+	}
+	return collected;
+}
+/**
+* Fetch a single resource record set by exact name + type, if it exists.
+* @param {{
+*   profile?: string;
+*   hostedZoneId: string;
+*   name: string;
+*   type: string;
+*   verbose?: boolean;
+* }} params
+* @returns {ResourceRecordSet | null}
+*/
+function getResourceRecordSet(params) {
+	const { type, ...rest } = params;
+	const targetType = type.toUpperCase();
+	return getRecordSetsAtName(rest).find((set) => set.type === targetType) ?? null;
+}
+/**
+* Route53 forbids a CNAME from coexisting with any other record type at the
+* same name. Given the type about to be written and the record sets already at
+* that name, return the sets that would conflict (empty when there is none).
+* A same-type set is an overwrite, not a conflict.
+* @param {{ existingSets: ResourceRecordSet[]; type: string }} params
+* @returns {ResourceRecordSet[]}
+*/
+function findCnameConflicts(params) {
+	const { existingSets, type } = params;
+	const upperType = type.toUpperCase();
+	return existingSets.filter((set) => {
+		if (set.type === upperType) return false;
+		return upperType === "CNAME" || set.type === "CNAME";
+	});
+}
+/**
+* @param {any} set
+* @returns {ResourceRecordSet}
+*/
+function normalizeRecordSet(set) {
+	const values = (set.ResourceRecords ?? []).map((record) => String(record.Value ?? ""));
+	return {
+		name: withTrailingDot(String(set.Name ?? "")),
+		type: String(set.Type ?? "").toUpperCase(),
+		ttl: typeof set.TTL === "number" ? set.TTL : void 0,
+		values,
+		isAlias: Boolean(set.AliasTarget),
+		aliasTarget: set.AliasTarget ?? void 0
+	};
+}
+/**
+* Format existing values for console display.
+* @param {string[]} values
+* @returns {string}
+*/
+function formatValues(values) {
+	if (values.length === 0) return "(none)";
+	if (values.length === 1) return values[0] ?? "(none)";
+	return values.map((value) => `\n    - ${value}`).join("");
+}
+/**
+* Normalize a single record value for a given type (trailing dots, TXT quotes).
+* @param {{ type: string; value: string }} params
+* @returns {string}
+*/
+function normalizeRecordValue(params) {
+	const { type, value } = params;
+	const trimmed = value.trim();
+	if (type === "CNAME" || type === "NS" || type === "MX" || type === "SRV") {
+		if (type === "MX") {
+			const parts = trimmed.split(/\s+/);
+			if (parts.length >= 2) return `${parts[0]} ${withTrailingDot(parts.slice(1).join(" "))}`;
+		}
+		if (type === "SRV") {
+			const parts = trimmed.split(/\s+/);
+			if (parts.length >= 4) return `${parts.slice(0, 3).join(" ")} ${withTrailingDot(parts.slice(3).join(" "))}`;
+		}
+		return withTrailingDot(trimmed);
+	}
+	if (type === "TXT") {
+		if (trimmed.startsWith("\"") && trimmed.endsWith("\"") || trimmed.startsWith("'") && trimmed.endsWith("'")) return trimmed;
+		return `"${trimmed}"`;
+	}
+	return trimmed;
+}
+/**
+* Decide how the new value relates to an existing RRSet.
+* @param {{
+*   existing: ResourceRecordSet | null;
+*   newValue: string;
+*   mode?: "replace" | "append";
+* }} params
+* @returns {{
+*   action: "create" | "overwrite" | "append" | "noop";
+*   finalValues: string[];
+*   summary: string;
+* }}
+*/
+function planRecordChange(params) {
+	const { existing, newValue, mode = "replace" } = params;
+	if (!existing) return {
+		action: "create",
+		finalValues: [newValue],
+		summary: "Adding a new record (nothing exists at this name + type)."
+	};
+	if (existing.isAlias) return {
+		action: "overwrite",
+		finalValues: [newValue],
+		summary: "Overwriting an existing ALIAS record with a standard record set."
+	};
+	const alreadyPresent = existing.values.some((value) => value === newValue || value === `"${newValue}"`);
+	if (alreadyPresent && mode !== "replace") return {
+		action: "noop",
+		finalValues: existing.values,
+		summary: "Record already has this value. Nothing to do."
+	};
+	if (alreadyPresent && mode === "replace" && existing.values.length === 1 && existing.values[0] === newValue) return {
+		action: "noop",
+		finalValues: existing.values,
+		summary: "Record already has exactly this value. Nothing to do."
+	};
+	if (mode === "append") return {
+		action: "append",
+		finalValues: [...existing.values, newValue],
+		summary: `Adding to the existing ${existing.type} record (${existing.values.length} value(s) → ${existing.values.length + 1}).`
+	};
+	return {
+		action: "overwrite",
+		finalValues: [newValue],
+		summary: existing.values.length === 1 ? `Overwriting existing value:\n    ${existing.values[0]}\n  → ${newValue}` : `Replacing ${existing.values.length} existing values with a single new value.`
+	};
+}
+/**
+* Submit a Route53 UPSERT for a simple (non-alias) resource record set.
+* @param {{
+*   profile?: string;
+*   hostedZoneId: string;
+*   name: string;
+*   type: string;
+*   ttl: number;
+*   values: string[];
+*   verbose?: boolean;
+* }} params
+* @returns {any} ChangeInfo from Route53
+*/
+function upsertResourceRecordSet(params) {
+	const { profile, hostedZoneId, name, type, ttl, values, verbose } = params;
+	const changeBatch = {
+		Comment: `mtn aws route53 add-record: ${type} ${name}`,
+		Changes: [{
+			Action: "UPSERT",
+			ResourceRecordSet: {
+				Name: withTrailingDot(name),
+				Type: type,
+				TTL: ttl ?? 300,
+				ResourceRecords: values.map((value) => ({ Value: value }))
+			}
+		}]
+	};
+	const data = require_commands_aws_utils_exec_aws.runAws({
+		profile,
+		args: [
+			"route53",
+			"change-resource-record-sets",
+			"--hosted-zone-id",
+			hostedZoneId,
+			"--change-batch",
+			JSON.stringify(changeBatch)
+		],
+		verbose
+	});
+	return data.ChangeInfo ?? data;
+}
+/**
+* Submit a Route53 DELETE for an existing resource record set. Route53 requires
+* the record's exact current definition, so this is driven by the record set
+* returned from {@link getResourceRecordSet} — alias records reuse their
+* AliasTarget; standard records reuse their TTL + values.
+* @param {{
+*   profile?: string;
+*   hostedZoneId: string;
+*   record: ResourceRecordSet;
+*   verbose?: boolean;
+* }} params
+* @returns {any} ChangeInfo from Route53
+*/
+function deleteResourceRecordSet(params) {
+	const { profile, hostedZoneId, record, verbose } = params;
+	/** @type {Record<string, any>} */
+	const resourceRecordSet = {
+		Name: withTrailingDot(record.name),
+		Type: record.type
+	};
+	if (record.isAlias && record.aliasTarget) resourceRecordSet.AliasTarget = record.aliasTarget;
+	else {
+		resourceRecordSet.TTL = record.ttl ?? 300;
+		resourceRecordSet.ResourceRecords = record.values.map((value) => ({ Value: value }));
+	}
+	const changeBatch = {
+		Comment: `mtn aws route53 remove-record: ${record.type} ${record.name}`,
+		Changes: [{
+			Action: "DELETE",
+			ResourceRecordSet: resourceRecordSet
+		}]
+	};
+	const data = require_commands_aws_utils_exec_aws.runAws({
+		profile,
+		args: [
+			"route53",
+			"change-resource-record-sets",
+			"--hosted-zone-id",
+			hostedZoneId,
+			"--change-batch",
+			JSON.stringify(changeBatch)
+		],
+		verbose
+	});
+	return data.ChangeInfo ?? data;
+}
+//#endregion
+exports.bareHostedZoneId = bareHostedZoneId;
+exports.deleteResourceRecordSet = deleteResourceRecordSet;
+exports.findCnameConflicts = findCnameConflicts;
+exports.findHostedZone = findHostedZone;
+exports.formatValues = formatValues;
+exports.getRecordSetsAtName = getRecordSetsAtName;
+exports.getResourceRecordSet = getResourceRecordSet;
+exports.hostedZoneLabel = hostedZoneLabel;
+exports.listHostedZones = listHostedZones;
+exports.normalizeRecordValue = normalizeRecordValue;
+exports.planRecordChange = planRecordChange;
+exports.resolveRecordName = resolveRecordName;
+exports.upsertResourceRecordSet = upsertResourceRecordSet;
+exports.withTrailingDot = withTrailingDot;
+exports.withoutTrailingDot = withoutTrailingDot;

package/cjs/commands/aws/route53/add-record/utils.d.ts

@@ -0,0 +1,216 @@
+/**
+ * @typedef {Object} HostedZone
+ * @property {string} id - Bare hosted zone ID (without /hostedzone/ prefix)
+ * @property {string} name - Zone name with trailing dot (e.g. mountaindev.com.)
+ * @property {boolean} privateZone
+ * @property {number} recordCount
+ */
+/**
+ * @typedef {Object} ResourceRecordSet
+ * @property {string} name
+ * @property {string} type
+ * @property {number | undefined} ttl
+ * @property {string[]} values
+ * @property {boolean} isAlias
+ * @property {any} [aliasTarget] - Raw AliasTarget block (present when isAlias)
+ */
+/**
+ * Strip the `/hostedzone/` prefix from a Route53 hosted zone Id.
+ * @param {string} rawId
+ * @returns {string}
+ */
+export function bareHostedZoneId(rawId: string): string;
+/**
+ * Ensure a DNS name ends with a trailing dot (Route53 FQDN form).
+ * @param {string} name
+ * @returns {string}
+ */
+export function withTrailingDot(name: string): string;
+/**
+ * Strip a trailing dot for display.
+ * @param {string} name
+ * @returns {string}
+ */
+export function withoutTrailingDot(name: string): string;
+/**
+ * List hosted zones for the profile.
+ * @param {{ profile?: string; verbose?: boolean }} params
+ * @returns {HostedZone[]}
+ */
+export function listHostedZones(params: {
+    profile?: string;
+    verbose?: boolean;
+}): HostedZone[];
+/**
+ * Resolve a hosted zone from a name (mountaindev.com) or bare/prefixed ID.
+ * @param {{ zones: HostedZone[]; zoneInput: string }} params
+ * @returns {HostedZone | null}
+ */
+export function findHostedZone(params: {
+    zones: HostedZone[];
+    zoneInput: string;
+}): HostedZone | null;
+/**
+ * Build a display label for a hosted zone in the picker.
+ * @param {HostedZone} zone
+ * @returns {string}
+ */
+export function hostedZoneLabel(zone: HostedZone): string;
+/**
+ * Turn a relative or absolute name into a Route53 FQDN under the zone.
+ * Apex / "@" / empty → the zone apex.
+ * @param {{ nameInput: string; zoneName: string }} params
+ * @returns {string} FQDN with trailing dot
+ */
+export function resolveRecordName(params: {
+    nameInput: string;
+    zoneName: string;
+}): string;
+/**
+ * Fetch every resource record set at an exact name, across all types.
+ * Paginates when needed; Route53 list is ordered by name then type.
+ * @param {{
+ *   profile?: string;
+ *   hostedZoneId: string;
+ *   name: string;
+ *   verbose?: boolean;
+ * }} params
+ * @returns {ResourceRecordSet[]}
+ */
+export function getRecordSetsAtName(params: {
+    profile?: string;
+    hostedZoneId: string;
+    name: string;
+    verbose?: boolean;
+}): ResourceRecordSet[];
+/**
+ * Fetch a single resource record set by exact name + type, if it exists.
+ * @param {{
+ *   profile?: string;
+ *   hostedZoneId: string;
+ *   name: string;
+ *   type: string;
+ *   verbose?: boolean;
+ * }} params
+ * @returns {ResourceRecordSet | null}
+ */
+export function getResourceRecordSet(params: {
+    profile?: string;
+    hostedZoneId: string;
+    name: string;
+    type: string;
+    verbose?: boolean;
+}): ResourceRecordSet | null;
+/**
+ * Route53 forbids a CNAME from coexisting with any other record type at the
+ * same name. Given the type about to be written and the record sets already at
+ * that name, return the sets that would conflict (empty when there is none).
+ * A same-type set is an overwrite, not a conflict.
+ * @param {{ existingSets: ResourceRecordSet[]; type: string }} params
+ * @returns {ResourceRecordSet[]}
+ */
+export function findCnameConflicts(params: {
+    existingSets: ResourceRecordSet[];
+    type: string;
+}): ResourceRecordSet[];
+/**
+ * Format existing values for console display.
+ * @param {string[]} values
+ * @returns {string}
+ */
+export function formatValues(values: string[]): string;
+/**
+ * Normalize a single record value for a given type (trailing dots, TXT quotes).
+ * @param {{ type: string; value: string }} params
+ * @returns {string}
+ */
+export function normalizeRecordValue(params: {
+    type: string;
+    value: string;
+}): string;
+/**
+ * Decide how the new value relates to an existing RRSet.
+ * @param {{
+ *   existing: ResourceRecordSet | null;
+ *   newValue: string;
+ *   mode?: "replace" | "append";
+ * }} params
+ * @returns {{
+ *   action: "create" | "overwrite" | "append" | "noop";
+ *   finalValues: string[];
+ *   summary: string;
+ * }}
+ */
+export function planRecordChange(params: {
+    existing: ResourceRecordSet | null;
+    newValue: string;
+    mode?: "replace" | "append";
+}): {
+    action: "create" | "overwrite" | "append" | "noop";
+    finalValues: string[];
+    summary: string;
+};
+/**
+ * Submit a Route53 UPSERT for a simple (non-alias) resource record set.
+ * @param {{
+ *   profile?: string;
+ *   hostedZoneId: string;
+ *   name: string;
+ *   type: string;
+ *   ttl: number;
+ *   values: string[];
+ *   verbose?: boolean;
+ * }} params
+ * @returns {any} ChangeInfo from Route53
+ */
+export function upsertResourceRecordSet(params: {
+    profile?: string;
+    hostedZoneId: string;
+    name: string;
+    type: string;
+    ttl: number;
+    values: string[];
+    verbose?: boolean;
+}): any;
+/**
+ * Submit a Route53 DELETE for an existing resource record set. Route53 requires
+ * the record's exact current definition, so this is driven by the record set
+ * returned from {@link getResourceRecordSet} — alias records reuse their
+ * AliasTarget; standard records reuse their TTL + values.
+ * @param {{
+ *   profile?: string;
+ *   hostedZoneId: string;
+ *   record: ResourceRecordSet;
+ *   verbose?: boolean;
+ * }} params
+ * @returns {any} ChangeInfo from Route53
+ */
+export function deleteResourceRecordSet(params: {
+    profile?: string;
+    hostedZoneId: string;
+    record: ResourceRecordSet;
+    verbose?: boolean;
+}): any;
+export type HostedZone = {
+    /**
+     * - Bare hosted zone ID (without /hostedzone/ prefix)
+     */
+    id: string;
+    /**
+     * - Zone name with trailing dot (e.g. mountaindev.com.)
+     */
+    name: string;
+    privateZone: boolean;
+    recordCount: number;
+};
+export type ResourceRecordSet = {
+    name: string;
+    type: string;
+    ttl: number | undefined;
+    values: string[];
+    isAlias: boolean;
+    /**
+     * - Raw AliasTarget block (present when isAlias)
+     */
+    aliasTarget?: any;
+};