atmn 2.0.33 → 2.0.35

package/src/actions/pull/webhooks/removeWebhookEnv.ts

@@ -0,0 +1,141 @@
+import { SYNCED_LISTS } from "../../../generated/emit";
+import { deleteFixtureLiteral } from "../../../surgery/deleteFixtureLiteral";
+import { deleteReference } from "../../../surgery/deleteReference";
+import { fixtureObjectOf } from "../../../surgery/findFixture";
+import { patchFixturePaths } from "../../../surgery/patchFixturePaths";
+import {
+	fixtureKeyOf,
+	readFixtureValue,
+} from "../../../surgery/readFixtureValue";
+import { resolveCollectionTarget } from "../resolveCollectionTarget";
+import { locateWebhook } from "./locateWebhook";
+import type { PullFiles, StatedWebhook, WebhookEditResult } from "./types";
+import { nonLiteralUrlWarning } from "./updateWebhook";
+
+const SPEC = SYNCED_LISTS.webhooks;
+
+/** Read from source, not the evaluated config: a key whose code evaluates to
+ * undefined is still a key the user wrote. */
+const urlMapIsEmpty = ({
+	pull,
+	id,
+}: {
+	pull: PullFiles;
+	id: string;
+}): boolean => {
+	const located = locateWebhook({ pull, id });
+	const object = located === null ? null : fixtureObjectOf(located.node);
+	const member = object
+		?.namedChildren()
+		.find(
+			(child) =>
+				child.kind() === "pair" &&
+				child.field("key") !== null &&
+				fixtureKeyOf({ node: child.field("key") as never }) === "url",
+		);
+	const value = member?.field("value");
+	if (value === null || value === undefined) return false;
+	const read = readFixtureValue({ node: value });
+	return (
+		typeof read === "object" && read !== null && Object.keys(read).length === 0
+	);
+};
+
+/** The whole `webhook({...})`, and any export reference left pointing at it. */
+const deleteWebhook = ({
+	pull,
+	id,
+}: {
+	pull: PullFiles;
+	id: string;
+}): boolean => {
+	const located = locateWebhook({ pull, id });
+	if (located === null) return false;
+	const removed = deleteFixtureLiteral({
+		source: located.source,
+		builder: SPEC.builder,
+		idField: SPEC.idField,
+		id,
+	});
+	if (removed === null) return false;
+	pull.files.set(located.file, removed.source);
+	if (removed.exportedName !== undefined) {
+		const referenceFiles = new Set([pull.configPath]);
+		const target = resolveCollectionTarget({
+			configPath: pull.configPath,
+			files: pull.files,
+			collection: "webhooks",
+		});
+		if (target !== null) referenceFiles.add(target.file);
+		for (const file of referenceFiles)
+			pull.files.set(
+				file,
+				deleteReference({
+					source: pull.files.get(file) ?? "",
+					name: removed.exportedName,
+				}),
+			);
+	}
+	return true;
+};
+
+/**
+ * Rule 4: the server has no such webhook in this env, so the env's key goes;
+ * a map left empty registers the webhook nowhere, so the webhook goes too.
+ */
+export const removeWebhookEnv = ({
+	pull,
+	stated,
+	envKey,
+}: {
+	pull: PullFiles;
+	stated: StatedWebhook;
+	envKey: string;
+}): WebhookEditResult => {
+	const result: WebhookEditResult = { lines: [], warnings: [], unlocated: [] };
+	const located = locateWebhook({ pull, id: stated.id });
+	const patched =
+		located === null
+			? null
+			: patchFixturePaths({
+					source: located.source,
+					builder: SPEC.builder,
+					idField: SPEC.idField,
+					id: stated.id,
+					assignments: [{ path: ["url", envKey], text: null }],
+				});
+	if (located === null || patched === null) {
+		result.unlocated.push({
+			id: stated.id,
+			action: `remove url.${envKey} by hand`,
+		});
+		return result;
+	}
+	if (patched.skipped.length > 0) {
+		result.warnings.push(
+			nonLiteralUrlWarning({
+				id: stated.id,
+				envKey,
+				server: undefined,
+				config: stated.url?.[envKey],
+			}),
+		);
+		return result;
+	}
+	if (patched.source === located.source) return result;
+	pull.files.set(located.file, patched.source);
+	if (urlMapIsEmpty({ pull, id: stated.id })) {
+		if (deleteWebhook({ pull, id: stated.id })) {
+			result.lines.push(`- webhook ${stated.id}`);
+			return result;
+		}
+		// Only a literal can be deleted; saying so beats leaving `url: {}` behind.
+		result.unlocated.push({
+			id: stated.id,
+			action: "delete the webhook by hand: its url map is now empty",
+		});
+		return result;
+	}
+	result.lines.push(`- webhook ${stated.id} url.${envKey}`);
+	return result;
+};

package/src/actions/pull/webhooks/types.ts

@@ -0,0 +1,20 @@
+import type { ListWebhooksResponse } from "../../../generated/client";
+
+export type RemoteWebhook = ListWebhooksResponse["list"][number];
+
+/** A config webhook as evaluated: `url` still holds every env's value. */
+export type StatedWebhook = Record<string, unknown> & {
+	id: string;
+	url?: Record<string, unknown>;
+};
+
+/** The in-memory sources a pull edits, plus where the config lives. */
+export type PullFiles = { configPath: string; files: Map<string, string> };
+
+export type WebhookEditResult = {
+	/** Printed as they land, in the `+ / ~ / -` style of the other lanes. */
+	lines: string[];
+	/** Values the config states in code pull must not rewrite. */
+	warnings: string[];
+	unlocated: { id: string; action: string }[];
+};

package/src/actions/pull/webhooks/updateWebhook.ts

@@ -0,0 +1,138 @@
+import { isDeepStrictEqual } from "node:util";
+import { SYNCED_LISTS } from "../../../generated/emit";
+import { patchFixturePaths } from "../../../surgery/patchFixturePaths";
+import { locateWebhook } from "./locateWebhook";
+import type {
+	PullFiles,
+	RemoteWebhook,
+	StatedWebhook,
+	WebhookEditResult,
+} from "./types";
+
+const SPEC = SYNCED_LISTS.webhooks;
+
+type Assignment = { path: string[]; text: string | null };
+
+const sameEvents = (left: unknown, right: readonly string[]): boolean =>
+	Array.isArray(left) && isDeepStrictEqual([...left].sort(), [...right].sort());
+
+/** Settings-style: a field moves only when the server holds something else. */
+const fieldAssignments = ({
+	webhook,
+	stated,
+}: {
+	webhook: RemoteWebhook;
+	stated: StatedWebhook;
+}): Assignment[] => {
+	const assignments: Assignment[] = [];
+	// `[]` is a dashboard webhook receiving every event: not a list a config can state.
+	if (webhook.events.length > 0 && !sameEvents(stated.events, webhook.events))
+		assignments.push({
+			path: ["events"],
+			text: `[${webhook.events.map((event) => JSON.stringify(event)).join(", ")}]`,
+		});
+	if ((stated.description ?? "") !== (webhook.description ?? ""))
+		assignments.push({
+			path: ["description"],
+			text: webhook.description ? JSON.stringify(webhook.description) : null,
+		});
+	if ((stated.disabled === true) !== webhook.disabled)
+		assignments.push({
+			path: ["disabled"],
+			text: webhook.disabled ? "true" : null,
+		});
+	return assignments;
+};
+
+/** Rule 3's wording: what the server holds against what the code evaluates to. */
+export const nonLiteralUrlWarning = ({
+	id,
+	envKey,
+	server,
+	config,
+}: {
+	id: string;
+	envKey: string;
+	server: string | undefined;
+	config: unknown;
+}): string => {
+	const pad = " ".repeat(id.length + 4);
+	return [
+		`⚠ ${id}  url.${envKey} isn't a plain string, so pull left it untouched`,
+		`${pad}server:      ${server ?? "(not registered)"}`,
+		`${pad}your config: ${typeof config === "string" ? config : "(no value)"}`,
+		`${pad}Update it by hand, or make it a string and pull will manage it.`,
+	].join("\n");
+};
+
+/**
+ * Rules 2 and 3: set or replace `url[envKey]` when it is a string literal (or
+ * absent), and bring the other fields in line. Code is never rewritten; a
+ * value that evaluates differently from the server earns a warning instead.
+ */
+export const updateWebhook = ({
+	pull,
+	webhook,
+	stated,
+	envKey,
+}: {
+	pull: PullFiles;
+	webhook: RemoteWebhook;
+	stated: StatedWebhook;
+	envKey: string;
+}): WebhookEditResult => {
+	const result: WebhookEditResult = { lines: [], warnings: [], unlocated: [] };
+	if (webhook.events.length === 0 && Array.isArray(stated.events))
+		result.warnings.push(
+			`⚠ ${webhook.id}  the dashboard webhook at this url receives every event; your next push narrows it to ${stated.events.join(", ")}`,
+		);
+	const located = locateWebhook({ pull, id: webhook.id });
+	if (located === null) {
+		result.unlocated.push({
+			id: webhook.id,
+			action: "update from the server by hand",
+		});
+		return result;
+	}
+	const patched = patchFixturePaths({
+		source: located.source,
+		builder: SPEC.builder,
+		idField: SPEC.idField,
+		id: webhook.id,
+		assignments: [
+			{ path: ["url", envKey], text: JSON.stringify(webhook.url) },
+			...fieldAssignments({ webhook, stated }),
+		],
+		bareKeys: true,
+	});
+	if (patched === null) {
+		result.unlocated.push({
+			id: webhook.id,
+			action: "update from the server by hand",
+		});
+		return result;
+	}
+	for (const { path } of patched.skipped) {
+		const field = path.join(".");
+		if (field !== `url.${envKey}`) {
+			result.warnings.push(
+				`⚠ ${webhook.id}  ${field} isn't a plain literal, so pull left it untouched`,
+			);
+			continue;
+		}
+		const config = stated.url?.[envKey];
+		if (config === webhook.url) continue;
+		result.warnings.push(
+			nonLiteralUrlWarning({
+				id: webhook.id,
+				envKey,
+				server: webhook.url,
+				config,
+			}),
+		);
+	}
+	if (patched.source === located.source) return result;
+	pull.files.set(located.file, patched.source);
+	result.lines.push(`~ webhook ${webhook.id}`);
+	return result;
+};

package/src/actions/pull.ts

@@ -30,11 +30,14 @@ import {
 	packageImports,
 	scaffoldConfig,
 } from "./pull/scaffoldConfig";
+import { applyWebhooksPull } from "./pull/webhooks/applyWebhooksPull";
+import type { StatedWebhook } from "./pull/webhooks/types";
 import { configSearchDirs } from "./push";
 import {
 	backfillInternalIds,
 	identityRowsFromCatalog,
 } from "./push/backfillInternalIds";
+import type { WebhookEnv } from "./webhooks/types/webhookEnv";
 
 export type PullResult = {
 	configPath: string;
@@ -64,6 +67,8 @@ export type PullOptions = {
 	yes?: boolean;
 	/** Asks where a first pull should put the config; headless by default. */
 	prompter?: Prompter;
+	/** The target env for the webhook lane; without it webhooks are not pulled. */
+	webhookEnv?: () => Promise<WebhookEnv>;
 };
 
 const OVERWRITE_HINT =
@@ -224,6 +229,7 @@ export const runPull = async ({
 	overwrite = false,
 	yes = false,
 	prompter = createPrompter({ interactive: false, write }),
+	webhookEnv,
 }: PullOptions): Promise<PullResult> => {
 	const project = resolveProject({ cwd, configFlag });
 	if (overwrite && !yes) {
@@ -268,9 +274,9 @@ export const runPull = async ({
 		overwrite,
 		write,
 	});
-	const { catalog: wire, singletons } = splitWire(document);
+	const { catalog: wire, singletons, lists } = splitWire(document);
 
-	const [preview, catalog, settingsPreview] = await Promise.all([
+	const [preview, catalog, settingsPreview, webhooks] = await Promise.all([
 		diffOrExplain({ client, wire }),
 		// Every version: each is a row in plans, with `active` on it.
 		client.get({ include_versions: true }),
@@ -279,6 +285,10 @@ export const runPull = async ({
 		client.previewUpdateOrganization(
 			singletons.settings ?? { config: {} },
 		) as Promise<SettingsPreview>,
+		// Always listed, like settings: a webhook the config never named is pulled in.
+		webhookEnv === undefined
+			? undefined
+			: Promise.all([webhookEnv(), client.listWebhooks({})]),
 	]);
 
 	const files = new Map<string, string>();
@@ -364,6 +374,25 @@ export const runPull = async ({
 		);
 	}
 
+	const webhookWarnings: string[] = [];
+	if (webhooks !== undefined) {
+		const [env, { list }] = webhooks;
+		const applied = applyWebhooksPull({
+			pull: { configPath, files },
+			remote: list,
+			stated: lists.webhooks as StatedWebhook[] | undefined,
+			envKey: env.key,
+		});
+		lines.push(...applied.lines);
+		webhookWarnings.push(...applied.warnings);
+		unlocated.push(
+			...applied.unlocated.map((entry) => ({
+				collection: "webhooks",
+				...entry,
+			})),
+		);
+	}
+
 	if (includeMappings) {
 		const managedCatalog = Object.fromEntries(
 			Object.entries(COLLECTIONS)
@@ -416,6 +445,7 @@ export const runPull = async ({
 			`↳ wrote versionSlug into ${slugged.length} fixture${slugged.length === 1 ? "" : "s"}`,
 		);
 
+	if (webhookWarnings.length > 0) write(`${webhookWarnings.join("\n\n")}\n\n`);
 	write(
 		lines.length === 0
 			? "Nothing to pull.\n"

package/src/actions/push/pushLanesError.ts

@@ -0,0 +1,47 @@
+/** One lane of a push that failed: settings, catalog or webhooks. */
+export type LaneFailure = { lane: string; error: unknown };
+
+const messageOf = (error: unknown): string =>
+	error instanceof Error ? error.message : String(error);
+
+/** Every failing lane at once: fixing one and re-running to meet the next is the cost this avoids. */
+export class PushLanesError extends Error {
+	readonly failures: LaneFailure[];
+
+	constructor({
+		stage,
+		failures,
+	}: {
+		stage: "preview" | "apply";
+		failures: LaneFailure[];
+	}) {
+		super(
+			[
+				`push ${stage} failed in ${failures.length} of its lanes:`,
+				...failures.map(
+					({ lane, error }) =>
+						`\n  ${lane}\n    ${messageOf(error).replace(/\n/g, "\n    ")}`,
+				),
+			].join("\n"),
+		);
+		this.name = "PushLanesError";
+		this.failures = failures;
+	}
+}
+
+/** The settled lanes' values; a rejected lane becomes a failure instead. */
+export const settleLanes = async <T extends Record<string, unknown>>(
+	lanes: { [K in keyof T]: Promise<T[K]> },
+): Promise<{ values: Partial<T>; failures: LaneFailure[] }> => {
+	const names = Object.keys(lanes) as (keyof T & string)[];
+	const settled = await Promise.allSettled(names.map((name) => lanes[name]));
+	const values: Partial<T> = {};
+	const failures: LaneFailure[] = [];
+	settled.forEach((result, index) => {
+		const lane = names[index] as keyof T & string;
+		if (result.status === "fulfilled")
+			values[lane] = result.value as T[typeof lane];
+		else failures.push({ lane, error: result.reason });
+	});
+	return { values, failures };
+};