atmn 2.0.32 → 2.0.34

package/src/render/renderWebhooks.ts

@@ -0,0 +1,92 @@
+import chalk from "chalk";
+import type { PreviewSyncWebhooksResponse } from "../generated/client";
+
+type WebhookChange = PreviewSyncWebhooksResponse["changes"][number];
+type WebhookState = Extract<WebhookChange, { action: "create" }>["webhook"];
+
+/** One push's webhook lane: the server's diff for the target env. */
+export type WebhooksPreview = {
+	changes: WebhookChange[];
+};
+
+export const webhooksHaveWork = ({
+	webhooks,
+}: {
+	webhooks: WebhooksPreview | undefined;
+}): boolean =>
+	(webhooks?.changes ?? []).some((change) => change.action !== "unmanaged");
+
+const DETAIL_INDENT = "      ";
+
+const list = (values: readonly string[]): string =>
+	values.length === 0 ? "(none)" : values.join(", ");
+
+/** Every field that moved, one line each; the URL first, since it is the one that bites. */
+const updateDetails = ({
+	id,
+	before,
+	after,
+}: {
+	id: string;
+	before: WebhookState;
+	after: WebhookState;
+}): string[] => {
+	const lines: string[] = [];
+	if (before.url !== after.url)
+		lines.push(`${id} url: ${before.url} → ${after.url}`);
+	const events = (state: WebhookState) => [...state.events].sort();
+	if (events(before).join() !== events(after).join())
+		lines.push(`events: ${list(events(before))} → ${list(events(after))}`);
+	if ((before.description ?? "") !== (after.description ?? ""))
+		lines.push(
+			`description: ${JSON.stringify(before.description ?? "")} → ${JSON.stringify(after.description ?? "")}`,
+		);
+	if (before.disabled !== after.disabled)
+		lines.push(`disabled: ${before.disabled} → ${after.disabled}`);
+	return lines.map((line) => `${DETAIL_INDENT}${chalk.yellow(line)}`);
+};
+
+const renderChange = ({ change }: { change: WebhookChange }): string[] => {
+	if (change.action === "create")
+		return [
+			`  ${chalk.green(`+ ${change.id}`)}${chalk.dim(`  ${change.webhook.url}`)}`,
+			`${DETAIL_INDENT}${chalk.dim(`events: ${list(change.webhook.events)}`)}`,
+		];
+	if (change.action === "adopt")
+		return [
+			`  ${chalk.yellow(`~ ${change.id}`)}  ${chalk.bold("adopt")}  ${chalk.dim("existing dashboard webhook · signing secret unchanged")}`,
+			...updateDetails({
+				id: change.id,
+				before: change.before,
+				after: change.after,
+			}),
+		];
+	if (change.action === "update")
+		return [
+			`  ${chalk.yellow(`~ ${change.id}`)}`,
+			...updateDetails({
+				id: change.id,
+				before: change.before,
+				after: change.after,
+			}),
+		];
+	return [
+		chalk.dim(
+			`  · ${change.id}  unmanaged (not in your config; atmn leaves it alone)`,
+		),
+	];
+};
+
+/** Null when the lane has nothing to say, so push prints no empty heading. */
+export const renderWebhooks = ({
+	webhooks,
+}: {
+	webhooks: WebhooksPreview;
+}): string | null => {
+	const rows = webhooks.changes.flatMap((change) => renderChange({ change }));
+	if (rows.length === 0) return null;
+	const count = webhooks.changes.filter(
+		(change) => change.action !== "unmanaged",
+	).length;
+	return [chalk.bold(`Webhooks (${count})`), ...rows].join("\n");
+};

package/src/surgery/appendPropertyEdit.ts

@@ -1,5 +1,5 @@
 import type { Edit, SgNode } from "@ast-grep/napi";
-import { leadingIndentOfLine, lineStartOf } from "./fixtureEdit";
+import { leadingIndentOfLine, lineEndOf, lineStartOf } from "./fixtureEdit";
 
 const isMember = (child: SgNode): boolean =>
 	child.kind() === "pair" ||
@@ -49,9 +49,15 @@ export const appendPropertyEdit = ({
 		// Anchored to the last member itself, so a value whose closing brace shares
 		// the object's closing line can never push the insert outside the literal.
 		const indent = leadingIndentOfLine(source, last.range().start.index);
+		// A trailing `// comment` belongs to the member it follows: insert after it.
+		const restOfLine = source.slice(afterComma, lineEndOf(source, afterComma));
+		const at =
+			trailingComma && /^\s*\/\/.*$/.test(restOfLine)
+				? afterComma + restOfLine.length
+				: afterComma;
 		return {
-			startPos: afterComma,
-			endPos: afterComma,
+			startPos: at,
+			endPos: at,
 			insertedText: trailingComma
 				? `\n${indent}${pair},`
 				: `,\n${indent}${pair},`,

package/src/surgery/patchFixturePaths.ts

@@ -7,6 +7,7 @@ import {
 	findFixtures,
 	fixtureObjectOf,
 } from "./findFixture";
+import { lineEndOf, lineStartOf } from "./fixtureEdit";
 import {
 	DYNAMIC_VALUE,
 	fixtureArrayElements,
@@ -47,7 +48,48 @@ const matchesLiteral = ({
 	return !isDynamic(proposed) && isDeepStrictEqual(value, proposed);
 };
 
-const removeMemberEdits = ({ member }: { member: SgNode }): Edit[] => {
+const PLAIN_IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+
+/** Inserted keys are quoted unless the caller asks for identifiers where they are valid. */
+const keyText = ({
+	key,
+	bareKeys,
+}: {
+	key: string;
+	bareKeys: boolean;
+}): string =>
+	bareKeys && PLAIN_IDENTIFIER.test(key) ? key : JSON.stringify(key);
+
+/** A member alone on its line goes with the whole line, its own trailing comment included. */
+const wholeLineEdit = ({
+	source,
+	member,
+	comma,
+}: {
+	source: string;
+	member: SgNode;
+	comma: SgNode | null;
+}): Edit | null => {
+	const start = member.range().start.index;
+	const lineStart = lineStartOf(source, start);
+	if (source.slice(lineStart, start).trim() !== "") return null;
+	const end = Math.max(member.range().end.index, comma?.range().end.index ?? 0);
+	const lineEnd = lineEndOf(source, end);
+	if (!/^\s*(\/\/.*)?$/.test(source.slice(end, lineEnd))) return null;
+	return {
+		startPos: lineStart,
+		endPos: Math.min(lineEnd + 1, source.length),
+		insertedText: "",
+	};
+};
+
+const removeMemberEdits = ({
+	source,
+	member,
+}: {
+	source: string;
+	member: SgNode;
+}): Edit[] => {
 	const siblings = member.parent()?.children() ?? [];
 	const index = siblings.findIndex(
 		(sibling) => sibling.range().start.index === member.range().start.index,
@@ -61,6 +103,11 @@ const removeMemberEdits = ({ member }: { member: SgNode }): Edit[] => {
 		.find((sibling) => sibling.kind() !== "comment");
 	const comma =
 		next?.kind() === "," ? next : previous?.kind() === "," ? previous : null;
+	const line =
+		comma === next || comma === null
+			? wholeLineEdit({ source, member, comma })
+			: null;
+	if (line !== null) return [line];
 	return [member, ...(comma === null ? [] : [comma])].map((node) => ({
 		startPos: node.range().start.index,
 		endPos: node.range().end.index,
@@ -74,10 +121,12 @@ const pathEdits = ({
 	path,
 	text,
 	builders,
+	bareKeys,
 }: {
 	source: string;
 	object: SgNode;
 	builders: readonly string[];
+	bareKeys: boolean;
 } & Assignment): Edit[] | string => {
 	let current = object;
 	for (let index = 0; index < path.length; index += 1) {
@@ -124,8 +173,8 @@ const pathEdits = ({
 					return "missing-array-element";
 				let inserted = text;
 				for (const key of remaining.reverse())
-					inserted = `{ ${JSON.stringify(key)}: ${inserted} }`;
-				const pair = `${JSON.stringify(segment)}: ${inserted}`;
+					inserted = `{ ${keyText({ key: String(key), bareKeys })}: ${inserted} }`;
+				const pair = `${keyText({ key: segment, bareKeys })}: ${inserted}`;
 				const members = current
 					.namedChildren()
 					.filter((child) => child.kind() !== "comment");
@@ -149,7 +198,7 @@ const pathEdits = ({
 		if (text === null)
 			return member === undefined
 				? "array-element-removal"
-				: removeMemberEdits({ member });
+				: removeMemberEdits({ source, member });
 		if (matchesLiteral({ value: currentValue, text })) return [];
 		return [
 			{
@@ -170,6 +219,7 @@ export const patchFixturePaths = ({
 	where,
 	assignments,
 	builders = [],
+	bareKeys = false,
 }: {
 	source: string;
 	builder: FixtureShape;
@@ -178,6 +228,8 @@ export const patchFixturePaths = ({
 	where?: FixtureConstraint[];
 	assignments: Assignment[];
 	builders?: readonly string[];
+	/** Write an inserted key bare when it is a valid identifier. */
+	bareKeys?: boolean;
 }): PatchResult | null => {
 	const selector = { builder, idField, id, where, allowDynamic: true };
 	const initial = findFixtures({ source, ...selector });
@@ -193,7 +245,7 @@ export const patchFixturePaths = ({
 		const edits =
 			object === null
 				? "ambiguous-fixture"
-				: pathEdits({ source, object, builders, ...assignment });
+				: pathEdits({ source, object, builders, bareKeys, ...assignment });
 		if (typeof edits === "string") {
 			skipped.push({ path: assignment.path, reason: edits });
 			continue;