@tailor-platform/sdk-codemod 0.3.8 → 0.4.0-next.9

package/dist/codemods/v2/execute-script-arg/scripts/transform.js

@@ -0,0 +1,60 @@
+import { Lang, parse } from "@ast-grep/napi";
+//#region codemods/v2/execute-script-arg/scripts/transform.ts
+const NEEDLE = "executeScript";
+function quickFilter(source) {
+	return source.includes(NEEDLE) && source.includes("JSON.stringify");
+}
+function pairKeyText(pair) {
+	const key = pair.children()[0];
+	if (!key) return null;
+	return key.text().replace(/^['"]|['"]$/g, "");
+}
+/**
+* True when `stringifyCall` is the value of a top-level `arg:` property in the
+* object literal passed directly to `executeScript(...)`. The chain checked is
+* `JSON.stringify(...)` → pair (`arg:`) → object → arguments → `executeScript`
+* call, so a nested `arg:` (e.g. `executeScript({ opts: { arg: ... } })`) or an
+* unrelated `JSON.stringify` is left untouched.
+*/
+function isExecuteScriptArg(stringifyCall) {
+	const pair = stringifyCall.parent();
+	if (!pair || pair.kind() !== "pair") return false;
+	if (pairKeyText(pair) !== "arg") return false;
+	const obj = pair.parent();
+	if (!obj || obj.kind() !== "object") return false;
+	const args = obj.parent();
+	if (!args || args.kind() !== "arguments") return false;
+	const call = args.parent();
+	if (!call || call.kind() !== "call_expression") return false;
+	const callee = call.children()[0];
+	return !!callee && callee.text() === NEEDLE;
+}
+/**
+* Rewrite `executeScript({ ..., arg: JSON.stringify(X), ... })` to
+* `executeScript({ ..., arg: X, ... })`.
+*
+* In v2 the `executeScript` `arg` option takes a JSON-serializable value and
+* serializes it internally, so a pre-stringified argument double-encodes. Only
+* the literal `arg: JSON.stringify(<single expr>)` form is rewritten; indirect
+* forms (a stringified value held in a variable, `JSON.stringify(x, null, 2)`,
+* etc.) are left for manual migration.
+* @param source - File contents
+* @param _filePath - Absolute path to the file (kept for the runner signature)
+* @returns Transformed source or null when nothing matched.
+*/
+function transform(source, _filePath) {
+	if (!quickFilter(source)) return null;
+	const root = parse(source.includes("</") || source.includes("/>") ? Lang.Tsx : Lang.TypeScript, source).root();
+	const edits = [];
+	for (const match of root.findAll({ rule: { pattern: "JSON.stringify($X)" } })) {
+		if (!isExecuteScriptArg(match)) continue;
+		const inner = match.getMatch("X");
+		if (!inner) continue;
+		edits.push(match.replace(inner.text()));
+	}
+	if (edits.length === 0) return null;
+	const result = root.commitEdits(edits);
+	return result === source ? null : result;
+}
+//#endregion
+export { transform as default };

package/dist/codemods/v2/forward-relation-name/scripts/transform.js

@@ -0,0 +1,115 @@
+import { l as stringValue } from "../../../ast-grep-helpers-CXtWn3RB.js";
+import { Lang, parse } from "@ast-grep/napi";
+//#region codemods/v2/forward-relation-name/scripts/transform.ts
+function sourceLang(filePath, source) {
+	const lowerPath = filePath.toLowerCase();
+	if (/\.(?:ts|mts|cts)$/u.test(lowerPath)) return Lang.TypeScript;
+	if (/\.(?:tsx|jsx|js)$/u.test(lowerPath)) return Lang.Tsx;
+	return source.includes("</") ? Lang.Tsx : Lang.TypeScript;
+}
+function isRelationCall(call, aliases) {
+	const callee = call.children()[0];
+	if (!callee) return false;
+	if (callee.kind() === "identifier") return aliases.has(callee.text());
+	if (callee.kind() === "subscript_expression") {
+		const property = literalStringValue(callee.field("index"));
+		return property === null || property === "relation";
+	}
+	if (callee.kind() !== "member_expression") return false;
+	return callee.children().findLast((child) => child.kind() === "property_identifier" || child.kind() === "identifier")?.text() === "relation";
+}
+function relationBindingName(pattern) {
+	if (pattern.kind() !== "object_pattern") return null;
+	for (const child of pattern.children()) {
+		if (child.kind() === "shorthand_property_identifier_pattern" && child.text() === "relation") return child.text();
+		if (child.kind() === "pair_pattern" && stringValue(child.field("key")) === "relation") {
+			const value = child.field("value");
+			return value?.kind() === "identifier" ? value.text() : null;
+		}
+		if (child.kind() === "object_assignment_pattern") {
+			const binding = child.children().find((node) => node.kind() === "shorthand_property_identifier_pattern");
+			if (binding?.text() === "relation") return binding.text();
+		}
+	}
+	return null;
+}
+function relationAliases(root) {
+	const aliases = /* @__PURE__ */ new Set();
+	for (const pattern of root.findAll({ rule: { kind: "object_pattern" } })) {
+		const name = relationBindingName(pattern);
+		if (name) aliases.add(name);
+	}
+	return aliases;
+}
+function callArgument(call) {
+	const args = call.children().find((child) => child.kind() === "arguments");
+	if (!args) return null;
+	const values = args.children().filter((child) => {
+		const kind = child.kind();
+		return kind !== "(" && kind !== ")" && kind !== "," && kind !== "comment";
+	});
+	return values.length === 1 ? values[0] : null;
+}
+function pairKey(pair) {
+	const key = pair.children()[0];
+	return stringValue(key ?? null);
+}
+function pairValue(pair) {
+	const children = pair.children();
+	const colonIndex = children.findIndex((child) => child.kind() === ":");
+	if (colonIndex === -1) return null;
+	return children.slice(colonIndex + 1).find((child) => child.kind() !== "comment") ?? null;
+}
+function objectPair(object, key) {
+	return object.children().find((child) => child.kind() === "pair" && pairKey(child) === key) ?? null;
+}
+function literalStringValue(node) {
+	if (node?.kind() !== "string") return null;
+	return stringValue(node);
+}
+function hasDynamicProperties(object) {
+	return object.children().some((child) => {
+		const kind = child.kind();
+		if (kind === "{" || kind === "}" || kind === "," || kind === "comment") return false;
+		if (kind !== "pair") return true;
+		const keyKind = child.children()[0]?.kind();
+		return keyKind !== "property_identifier" && keyKind !== "string";
+	});
+}
+function needsReview(call) {
+	const config = callArgument(call);
+	if (config?.kind() !== "object") return config != null;
+	if (hasDynamicProperties(config)) return true;
+	const relationType = objectPair(config, "type");
+	const toward = objectPair(config, "toward");
+	if (!relationType || !toward) return false;
+	if (literalStringValue(pairValue(relationType)) === "keyOnly") return false;
+	const towardConfig = pairValue(toward);
+	if (towardConfig?.kind() !== "object") return towardConfig != null;
+	if (hasDynamicProperties(towardConfig)) return true;
+	const targetType = objectPair(towardConfig, "type");
+	if (targetType && literalStringValue(pairValue(targetType)) === "self") return false;
+	const as = objectPair(towardConfig, "as");
+	if (as) {
+		const explicitName = literalStringValue(pairValue(as));
+		return explicitName === null || explicitName.length === 0;
+	}
+	if (!targetType) return false;
+	return true;
+}
+function transform(_source, _filePath) {
+	return null;
+}
+function reviewFindings(source, filePath, relativePath) {
+	if (!source.includes("relation")) return [];
+	const root = parse(sourceLang(filePath, source), source).root();
+	const aliases = relationAliases(root);
+	return root.findAll({ rule: { kind: "call_expression" } }).filter((call) => isRelationCall(call, aliases) && needsReview(call)).map((call) => ({
+		file: relativePath,
+		line: call.range().start.line + 1,
+		message: "Review the v2 forward GraphQL field name or add an explicit toward.as.",
+		excerpt: call.text().split("\n", 1)[0].trim()
+	}));
+}
+//#endregion
+export { transform as default, reviewFindings };