atmn 1.1.25 → 2.0.0

package/src/surgery/ensureBuilderImport.ts

@@ -0,0 +1,65 @@
+import { Lang, parse } from "@ast-grep/napi";
+import { configPackageName } from "../config/configPackageName";
+
+const NAMED_IMPORT = /^import\s+\{([^}]*)\}\s*from\s*["']([^"']+)["']/;
+const GENERATED_MODULE = /\/generated\/[A-Za-z]+$/;
+
+/**
+ * A file that gains an inline `plan({...})` must import `plan`. The specifier
+ * follows the file's own builder imports: `<x>/generated/wire` → `<x>/generated/plans`,
+ * the package → the same package import; a file with neither gets the package.
+ */
+export const ensureBuilderImport = ({
+	source,
+	builder,
+	collection,
+}: {
+	source: string;
+	builder: string;
+	collection: string;
+}): string => {
+	const root = parse(Lang.TypeScript, source).root();
+	const statements = root.findAll({ rule: { kind: "import_statement" } });
+	const parsed = statements.flatMap((statement) => {
+		const match = NAMED_IMPORT.exec(statement.text());
+		return match
+			? [
+					{
+						statement,
+						names: match[1].split(",").map((n) => n.trim()),
+						specifier: match[2],
+					},
+				]
+			: [];
+	});
+	const imported = parsed.some((entry) =>
+		entry.names.some(
+			(name) => name === builder || name.startsWith(`${builder} as `),
+		),
+	);
+	if (imported) return source;
+
+	const packageName = configPackageName();
+	const packageImport = parsed.find((entry) => entry.specifier === packageName);
+	if (packageImport !== undefined) {
+		const text = packageImport.statement.text();
+		const widened = text.replace(/\{\s*/, `{ ${builder}, `);
+		return root.commitEdits([
+			{
+				startPos: packageImport.statement.range().start.index,
+				endPos: packageImport.statement.range().end.index,
+				insertedText: widened,
+			},
+		]);
+	}
+	const generated = parsed.find((entry) =>
+		GENERATED_MODULE.test(entry.specifier),
+	);
+	const line =
+		generated === undefined
+			? `import { ${builder} } from "${packageName}";\n`
+			: `import { ${builder} } from "${generated.specifier.replace(GENERATED_MODULE, `/generated/${collection}`)}";\n`;
+	const anchor = generated?.statement ?? statements[0];
+	const at = anchor === undefined ? 0 : anchor.range().end.index + 1;
+	return `${source.slice(0, at)}${line}${source.slice(at)}`;
+};

package/src/surgery/findFixture.ts

@@ -0,0 +1,238 @@
+import type { SgNode } from "@ast-grep/napi";
+import { Lang, parse } from "@ast-grep/napi";
+import { containsDynamicValue } from "./fixtureEdit";
+
+/** A property the matched literal must hold; an absent one may count as a default. */
+export type FixtureConstraint = {
+	field: string;
+	equals: string;
+	absentMeans?: string;
+};
+
+/** The one parent literal a nested shape may stand under: the base row that
+ * states this stable id, or, when it states none, this public id and constraints. */
+export type ParentFixture = {
+	internalId?: string;
+	idField: string;
+	id: string;
+	where?: FixtureConstraint[];
+};
+
+/**
+ * Where a fixture literal may stand: the first argument of a builder call
+ * (`plan({...})`), or an object element of one of a builder call's array
+ * properties (`plan({ variants: [{...}] })`), optionally under one `parent`.
+ */
+export type FixtureShape =
+	| string
+	| { parentBuilder: string; arrayProperty: string; parent?: ParentFixture };
+
+/** The object literal a found fixture node holds: the node itself, or a call's first argument. */
+export const fixtureObjectOf = (node: SgNode): SgNode | null => {
+	if (node.kind() === "object") return node;
+	const object = node.field("arguments")?.namedChildren()[0];
+	return object !== undefined && object.kind() === "object" ? object : null;
+};
+
+const builderCalls = ({
+	root,
+	builder,
+}: {
+	root: SgNode;
+	builder: string;
+}): SgNode[] =>
+	root
+		.findAll({ rule: { kind: "call_expression" } })
+		.filter((call) => call.field("function")?.text() === builder);
+
+/** Candidate nodes for the shape, each paired with the literal it holds. */
+const candidateFixtures = ({
+	root,
+	builder,
+}: {
+	root: SgNode;
+	builder: FixtureShape;
+}): { node: SgNode; object: SgNode }[] => {
+	if (typeof builder === "string") {
+		return builderCalls({ root, builder }).flatMap((call) => {
+			const object = fixtureObjectOf(call);
+			return object === null ? [] : [{ node: call, object }];
+		});
+	}
+	return builderCalls({ root, builder: builder.parentBuilder }).flatMap(
+		(call) => {
+			const parent = fixtureObjectOf(call);
+			if (parent === null) return [];
+			if (
+				builder.parent !== undefined &&
+				!isParentFixture({ object: parent, parent: builder.parent })
+			)
+				return [];
+			const array = topLevelPairValue({
+				object: parent,
+				key: builder.arrayProperty,
+			});
+			if (array === null || array.kind() !== "array") return [];
+			// An element is a bare literal or a builder call around one:
+			// `variants: [{...}]` and `variants: [variant({...})]` both count.
+			return array.namedChildren().flatMap((element) => {
+				const object = fixtureObjectOf(element);
+				return object === null ? [] : [{ node: element, object }];
+			});
+		},
+	);
+};
+
+export const findFixture = ({
+	source,
+	builder,
+	idField,
+	id,
+	where,
+	allowDynamic = false,
+}: {
+	source: string;
+	builder: FixtureShape;
+	idField: string;
+	id: string;
+	where?: FixtureConstraint[];
+	/** Match a literal built from spreads or calls too: to name it, not to edit it. */
+	allowDynamic?: boolean;
+}): SgNode | null => {
+	const root = parse(Lang.TypeScript, source).root();
+	// A rule walk rather than a pattern: a pattern misses an object whose id
+	// pair follows a spread, and the fixture must be found to be refused.
+	for (const { node, object } of candidateFixtures({ root, builder })) {
+		const idValue = topLevelPairValue({ object, key: idField });
+		if (idValue === null || stringLiteralValue(idValue) !== id) continue;
+		if (!allowDynamic && containsDynamicValue(object)) continue;
+		if (where !== undefined && !satisfiesFixtureConstraints({ object, where }))
+			continue;
+		return node;
+	}
+	return null;
+};
+
+const SIMPLE_ESCAPES: Record<string, string> = {
+	n: "\n",
+	t: "\t",
+	r: "\r",
+	b: "\b",
+	f: "\f",
+	v: "\v",
+	"0": "\0",
+};
+
+const CODE_POINT_ESCAPE = /^u\{([0-9a-fA-F]{1,6})\}/;
+const CODE_UNIT_ESCAPE = /^u([0-9a-fA-F]{4})/;
+const HEX_ESCAPE = /^x([0-9a-fA-F]{2})/;
+
+/** A quoted string's body as the runtime reads it, so `'a\\'b'` and `"a'b"`
+ * name one fixture. */
+const decodeStringBody = (body: string): string => {
+	let decoded = "";
+	let index = 0;
+	while (index < body.length) {
+		const char = body[index] ?? "";
+		if (char !== "\\") {
+			decoded += char;
+			index += 1;
+			continue;
+		}
+		const rest = body.slice(index + 1);
+		const numeric =
+			CODE_POINT_ESCAPE.exec(rest) ??
+			CODE_UNIT_ESCAPE.exec(rest) ??
+			HEX_ESCAPE.exec(rest);
+		if (numeric !== null) {
+			decoded += String.fromCodePoint(Number.parseInt(numeric[1] ?? "0", 16));
+			index += 1 + numeric[0].length;
+			continue;
+		}
+		const escaped = rest[0];
+		if (escaped === undefined) return decoded;
+		decoded += SIMPLE_ESCAPES[escaped] ?? escaped;
+		index += 2;
+	}
+	return decoded;
+};
+
+/**
+ * The text a string node stands for, so `'pro'` and `"pro"` name one fixture.
+ * Null for anything else — a template literal is a computed value, not an id.
+ */
+const stringLiteralValue = (node: SgNode): string | null => {
+	if (node.kind() !== "string") return null;
+	const text = node.text();
+	const quote = text[0];
+	if (quote !== '"' && quote !== "'") return null;
+	if (text.length < 2 || !text.endsWith(quote)) return null;
+	return decodeStringBody(text.slice(1, -1));
+};
+
+/** The value of the object's own `key: value` member, ignoring nested objects. */
+const topLevelPairValue = ({
+	object,
+	key,
+}: {
+	object: SgNode;
+	key: string;
+}): SgNode | null => {
+	for (const member of object.children()) {
+		if (member.kind() !== "pair") continue;
+		const [name, value] = member.namedChildren();
+		if (name?.text() === key && value !== undefined) return value;
+	}
+	return null;
+};
+
+/** A stated stable id decides on its own; only a literal without one is
+ * matched by its public id, so two versions sharing an id stay apart. */
+const isParentFixture = ({
+	object,
+	parent,
+}: {
+	object: SgNode;
+	parent: ParentFixture;
+}): boolean => {
+	const statedInternalId = topLevelPairValue({ object, key: "internalId" });
+	const literalInternalId =
+		statedInternalId === null ? null : stringLiteralValue(statedInternalId);
+	if (literalInternalId !== null)
+		return literalInternalId === parent.internalId;
+	const idValue = topLevelPairValue({ object, key: parent.idField });
+	if (idValue === null || stringLiteralValue(idValue) !== parent.id)
+		return false;
+	return (
+		parent.where === undefined ||
+		satisfiesFixtureConstraints({ object, where: parent.where })
+	);
+};
+
+const satisfiesFixtureConstraints = ({
+	object,
+	where,
+}: {
+	object: SgNode;
+	where: FixtureConstraint[];
+}): boolean =>
+	where.every((constraint) => satisfiesConstraint({ object, constraint }));
+
+const satisfiesConstraint = ({
+	object,
+	constraint,
+}: {
+	object: SgNode;
+	constraint: FixtureConstraint;
+}): boolean => {
+	const pair = object
+		.children()
+		.find(
+			(child) =>
+				child.kind() === "pair" &&
+				child.namedChildren()[0]?.text() === constraint.field,
+		);
+	if (pair === undefined) return constraint.absentMeans === constraint.equals;
+	const value = pair.namedChildren()[1];
+	return value !== undefined && stringLiteralValue(value) === constraint.equals;
+};

package/src/surgery/fixtureEdit.ts

@@ -0,0 +1,156 @@
+import type { Edit, SgNode } from "@ast-grep/napi";
+
+// Kinds that make an object literal's value dynamic, so a fixture built from it
+// cannot be rewritten as bytes. `property_identifier` (keys) is a different kind.
+export const dynamicValueKinds = [
+	"identifier",
+	"member_expression",
+	"call_expression",
+	"spread_element",
+	"computed_property_name",
+] as const;
+
+/** An array element naming another fixture (`variants: [proAnnual]`, or
+ * `[...annualVariants]`) is a reference, not a computed value. */
+const isFixtureReference = (element: SgNode): boolean =>
+	element.kind() === "identifier" ||
+	(element.kind() === "spread_element" &&
+		element.namedChildren()[0]?.kind() === "identifier");
+
+export const containsDynamicValue = (node: SgNode): boolean => {
+	if (dynamicValueKinds.some((dynamicKind) => node.kind() === dynamicKind))
+		return true;
+	for (const child of node.children()) {
+		if (node.kind() === "array" && isFixtureReference(child)) continue;
+		if (containsDynamicValue(child)) return true;
+	}
+	return false;
+};
+
+export const lineStartOf = (source: string, index: number): number =>
+	index <= 0 ? 0 : source.lastIndexOf("\n", index - 1) + 1;
+
+export const lineEndOf = (source: string, index: number): number => {
+	const newline = source.indexOf("\n", index);
+	return newline === -1 ? source.length : newline;
+};
+
+/** End of the line containing `index`, inclusive of the newline when present. */
+export const lineEndInclusive = (source: string, index: number): number => {
+	const lineEnd = lineEndOf(source, index);
+	return lineEnd < source.length ? lineEnd + 1 : lineEnd;
+};
+
+export const leadingIndentOfLine = (source: string, index: number): string => {
+	const lineStart = lineStartOf(source, index);
+	const match = /^\s*/.exec(source.slice(lineStart));
+	return match === null ? "" : match[0];
+};
+
+export const importStatementOf = (node: SgNode): SgNode | null => {
+	for (const ancestor of node.ancestors()) {
+		if (ancestor.kind() === "import_statement") return ancestor;
+	}
+	return null;
+};
+
+/** Remove a node together with its line: leading indentation through the newline. */
+export const removeLineEdit = ({
+	source,
+	node,
+}: {
+	source: string;
+	node: SgNode;
+}): Edit => ({
+	startPos: lineStartOf(source, node.range().start.index),
+	endPos: lineEndInclusive(source, node.range().end.index),
+	insertedText: "",
+});
+
+/**
+ * Remove an element from an array: its line when it stands alone (trailing comma
+ * included), a collapse to `[]` when it is the sole element, or just the element
+ * plus one adjacent comma when it shares a line with siblings.
+ */
+export const removeArrayElementEdits = ({
+	source,
+	element,
+}: {
+	source: string;
+	element: SgNode;
+}): Array<Edit> | null => {
+	const parent = element.parent();
+	if (parent === null || parent.kind() !== "array") return null;
+	if (parent.namedChildren().length === 1) {
+		return [
+			{
+				startPos: parent.range().start.index,
+				endPos: parent.range().end.index,
+				insertedText: "[]",
+			},
+		];
+	}
+	const start = element.range().start.index;
+	const end = element.range().end.index;
+	const lineStart = lineStartOf(source, start);
+	const lineEnd = lineEndOf(source, end);
+	const after = source.slice(end, lineEnd);
+	const commaIndex = after.indexOf(",");
+	const hasTrailingComma =
+		commaIndex !== -1 && after.slice(0, commaIndex).trim() === "";
+	const restAfterComma = hasTrailingComma ? after.slice(commaIndex + 1) : after;
+	const standsAlone =
+		source.slice(lineStart, start).trim() === "" &&
+		restAfterComma.trim() === "";
+	if (standsAlone) {
+		return [
+			{
+				startPos: lineStart,
+				endPos: lineEndInclusive(source, end),
+				insertedText: "",
+			},
+		];
+	}
+	if (hasTrailingComma) {
+		// Inline siblings: take the comma and the spacing before the next one.
+		const afterComma = end + commaIndex + 1;
+		const spacing = /^[ \t]*/.exec(source.slice(afterComma))?.[0].length ?? 0;
+		return [
+			{ startPos: start, endPos: afterComma + spacing, insertedText: "" },
+		];
+	}
+	const commaBefore = source.lastIndexOf(",", start);
+	return [
+		{
+			startPos: commaBefore === -1 ? start : commaBefore,
+			endPos: end,
+			insertedText: "",
+		},
+	];
+};
+
+/** Remove an import specifier plus one adjacent comma, keeping the statement. */
+export const removeSpecifierEdit = ({
+	source,
+	specifier,
+}: {
+	source: string;
+	specifier: SgNode;
+}): Edit => {
+	const start = specifier.range().start.index;
+	const end = specifier.range().end.index;
+	const after = source.slice(end);
+	const commaAfter = after.indexOf(",");
+	if (commaAfter !== -1 && after.slice(0, commaAfter).trim() === "") {
+		// Take the space after the comma too, or `{ a, b }` becomes `{  b }`.
+		const afterComma = end + commaAfter + 1;
+		const spaces = /^[ \t]*/.exec(source.slice(afterComma))?.[0].length ?? 0;
+		return { startPos: start, endPos: afterComma + spaces, insertedText: "" };
+	}
+	const commaBefore = source.lastIndexOf(",", start);
+	return {
+		startPos: commaBefore === -1 ? start : commaBefore,
+		endPos: end,
+		insertedText: "",
+	};
+};

package/src/surgery/fixtureLocation.ts

@@ -0,0 +1,32 @@
+import { readFileSync } from "node:fs";
+import { dirname, relative } from "node:path";
+import { listSourceFiles } from "../actions/pull/listSourceFiles";
+import { locateFixture } from "../actions/pull/locateFixture";
+
+/** The one place the CLI answers "where does this fixture live". */
+export const fixtureLocation = ({
+	configPath,
+	builder,
+	idField,
+	id,
+}: {
+	configPath: string;
+	builder: string;
+	idField: string;
+	id: string;
+}): { file: string; line: number } | null => {
+	const directory = dirname(configPath);
+	const files = new Map<string, string>();
+	files.set(configPath, readFileSync(configPath, "utf8"));
+	for (const file of listSourceFiles({ directory })) {
+		if (!files.has(file)) files.set(file, readFileSync(file, "utf8"));
+	}
+
+	const located = locateFixture({ configPath, files, builder, idField, id });
+	if (located === null) return null;
+
+	return {
+		file: relative(directory, located.file),
+		line: located.node.range().start.line + 1,
+	};
+};

package/src/surgery/insertCollection.ts

@@ -0,0 +1,86 @@
+import { Lang, parse } from "@ast-grep/napi";
+import { leadingIndentOfLine, lineStartOf } from "./fixtureEdit";
+
+/** Identifiers spread into the `atmn({...})` object: `atmn({ ...shared })` → ["shared"]. */
+export const rootSpreadNames = ({ source }: { source: string }): string[] => {
+	const root = parse(Lang.TypeScript, source).root();
+	const call = root.find("atmn($ARG)");
+	const object = call?.getMatch("ARG");
+	if (object === null || object === undefined || object.kind() !== "object")
+		return [];
+	return object
+		.children()
+		.filter((child) => child.kind() === "spread_element")
+		.map((child) => child.namedChildren()[0]?.text() ?? child.text());
+};
+
+export const insertCollection = ({
+	source,
+	collection,
+}: {
+	source: string;
+	collection: string;
+}): string | null => {
+	const root = parse(Lang.TypeScript, source).root();
+	const call = root.find("atmn($ARG)");
+	if (call === null) return null;
+	const object = call.getMatch("ARG");
+	if (object === null || object.kind() !== "object") return null;
+
+	const pairs = object.children().filter((child) => child.kind() === "pair");
+	const named = object
+		.children()
+		.some((child) =>
+			child.kind() === "pair"
+				? child.namedChildren()[0]?.text() === collection
+				: child.kind() === "shorthand_property_identifier" &&
+					child.text() === collection,
+		);
+	if (named) return source;
+
+	if (pairs.length === 0) {
+		const callLineIndent = leadingIndentOfLine(
+			source,
+			call.range().start.index,
+		);
+		const indent = `${callLineIndent}\t`;
+		return root.commitEdits([
+			{
+				startPos: object.range().start.index,
+				endPos: object.range().end.index,
+				insertedText: `{\n${indent}${collection}: [],\n${callLineIndent}}`,
+			},
+		]);
+	}
+
+	const last = pairs[pairs.length - 1];
+	const lastEnd = last.range().end.index;
+	const after = source.slice(lastEnd);
+	const commaAfter = after.indexOf(",");
+	const hasTrailingComma =
+		commaAfter !== -1 && after.slice(0, commaAfter).trim() === "";
+	const insertAt = hasTrailingComma ? lastEnd + commaAfter + 1 : lastEnd;
+	const missingComma = hasTrailingComma ? "" : ",";
+	// A one-line object keeps its shape: the key goes inline after the last pair.
+	const spansLines = object.text().includes("\n");
+	if (!spansLines) {
+		return root.commitEdits([
+			{
+				startPos: insertAt,
+				endPos: insertAt,
+				insertedText: `${missingComma} ${collection}: [],`,
+			},
+		]);
+	}
+	const indent = source.slice(
+		lineStartOf(source, last.range().start.index),
+		last.range().start.index,
+	);
+	return root.commitEdits([
+		{
+			startPos: insertAt,
+			endPos: insertAt,
+			insertedText: `${missingComma}\n${indent}${collection}: [],`,
+		},
+	]);
+};

package/src/surgery/insertFirstProperty.ts

@@ -0,0 +1,73 @@
+import { appendPropertyEdit, holdsSpread } from "./appendPropertyEdit";
+import {
+	type FixtureConstraint,
+	type FixtureShape,
+	findFixture,
+	fixtureObjectOf,
+} from "./findFixture";
+import { lineStartOf } from "./fixtureEdit";
+
+export const insertFirstProperty = ({
+	source,
+	builder,
+	idField,
+	id,
+	where,
+	property,
+}: {
+	source: string;
+	builder: FixtureShape;
+	idField: string;
+	id: string;
+	where?: FixtureConstraint[];
+	property: string;
+}): string | null => {
+	// A splice keeps every other byte, so a literal the pull rewriter refuses
+	// (it names another fixture) still takes one new property.
+	const call = findFixture({
+		source,
+		builder,
+		idField,
+		id,
+		where,
+		allowDynamic: true,
+	});
+	if (call === null) return null;
+	const object = fixtureObjectOf(call);
+	if (object === null) return null;
+	// A spread later in the literal overrides an earlier key, so a literal built
+	// from one takes the property at the end instead — where it still applies.
+	if (holdsSpread({ object })) {
+		return call
+			.getRoot()
+			.root()
+			.commitEdits([appendPropertyEdit({ source, object, pair: property })]);
+	}
+	const first = object.namedChildren()[0];
+	if (first === undefined) return null;
+	const insertAt = first.range().start.index;
+	// The object spans lines: the existing whitespace before the first property
+	// already indents it, so the new property takes that indent on its own line.
+	const spansLines = source
+		.slice(object.range().start.index, insertAt)
+		.includes("\n");
+	if (!spansLines) {
+		return call
+			.getRoot()
+			.root()
+			.commitEdits([
+				{ startPos: insertAt, endPos: insertAt, insertedText: `${property}, ` },
+			]);
+	}
+	const indent = source.slice(lineStartOf(source, insertAt), insertAt);
+	return call
+		.getRoot()
+		.root()
+		.commitEdits([
+			{
+				startPos: insertAt,
+				endPos: insertAt,
+				insertedText: `${property},\n${indent}`,
+			},
+		]);
+};