@tailor-platform/sdk-codemod 0.3.9 → 0.4.0-next.10

package/dist/codemods/v2/exec-job-function-rename/scripts/transform.js

@@ -0,0 +1,95 @@
+import { a as importSource, c as localDeclarationNames, i as importBindings, o as importSpecNames, r as findImportStatements } from "../../../ast-grep-helpers-CXtWn3RB.js";
+import { Lang, parse } from "@ast-grep/napi";
+//#region codemods/v2/exec-job-function-rename/scripts/transform.ts
+const DEPRECATED_METHOD = "startJobFunction";
+const CANONICAL_METHOD = "execJobFunction";
+const DEPRECATED_OPTIONS = "StartJobFunctionOptions";
+const CANONICAL_OPTIONS = "ExecJobFunctionOptions";
+const WORKFLOW_MODULE_SOURCES = /* @__PURE__ */ new Set(["@tailor-platform/sdk/runtime", "@tailor-platform/sdk/runtime/workflow"]);
+function quickFilter(source) {
+	return source.includes(DEPRECATED_METHOD) || source.includes(DEPRECATED_OPTIONS);
+}
+function sourceLang(filePath, source) {
+	const lower = filePath.toLowerCase();
+	if (lower.endsWith(".tsx") || lower.endsWith(".jsx")) return Lang.Tsx;
+	return source.includes("</") || source.includes("/>") ? Lang.Tsx : Lang.TypeScript;
+}
+function collectWorkflowLocals(root, imports) {
+	const locals = /* @__PURE__ */ new Set();
+	for (const importStmt of imports) for (const binding of importBindings(importStmt)) if (binding.importedName === "workflow" && WORKFLOW_MODULE_SOURCES.has(binding.source)) locals.add(binding.localName);
+	const declaredNames = localDeclarationNames(root);
+	for (const name of locals) if (declaredNames.has(name)) locals.delete(name);
+	return locals;
+}
+function tailorIsAmbientGlobal(root, imports) {
+	if (localDeclarationNames(root).has("tailor")) return false;
+	return !imports.some((stmt) => importBindings(stmt).some((b) => b.localName === "tailor"));
+}
+function isAmbientTailorWorkflow(object) {
+	if (!object || object.kind() !== "member_expression") return false;
+	const base = object.field("object");
+	const property = object.field("property");
+	return base?.kind() === "identifier" && base.text() === "tailor" && property?.text() === "workflow";
+}
+/**
+* Rename `StartJobFunctionOptions` import specifiers from the runtime module,
+* plus the type references that resolve to them when the import is not aliased.
+* @param root - Parsed file root
+* @param imports - Top-level import statements
+* @returns Edits renaming the deprecated options type
+*/
+function optionsTypeEdits(root, imports) {
+	const edits = [];
+	for (const importStmt of imports) {
+		const source = importSource(importStmt);
+		if (source === null || !WORKFLOW_MODULE_SOURCES.has(source)) continue;
+		const specs = importStmt.findAll({ rule: { kind: "import_specifier" } });
+		if (specs.some((spec) => importSpecNames(spec)?.importedName === CANONICAL_OPTIONS)) continue;
+		for (const spec of specs) {
+			const names = importSpecNames(spec);
+			if (names?.importedName !== DEPRECATED_OPTIONS) continue;
+			const importedNode = spec.children().find((child) => child.kind() === "identifier");
+			if (!importedNode) continue;
+			edits.push(importedNode.replace(CANONICAL_OPTIONS));
+			if (names.localName !== DEPRECATED_OPTIONS) continue;
+			for (const reference of root.findAll({ rule: {
+				kind: "type_identifier",
+				regex: `^${DEPRECATED_OPTIONS}$`
+			} })) edits.push(reference.replace(CANONICAL_OPTIONS));
+		}
+	}
+	return edits;
+}
+/**
+* Rewrite `.startJobFunction(` member accesses — on the ambient
+* `tailor.workflow` global or on a `workflow` value imported from
+* `@tailor-platform/sdk/runtime(/workflow)` — to the canonical
+* `execJobFunction`, and rename the `StartJobFunctionOptions` type alias.
+* @param source - File contents
+* @param filePath - Absolute path to the file
+* @returns Transformed source or null when nothing matched.
+*/
+function transform(source, filePath) {
+	if (!quickFilter(source)) return null;
+	const root = parse(sourceLang(filePath ?? "", source), source).root();
+	const imports = findImportStatements(root);
+	const workflowLocals = collectWorkflowLocals(root, imports);
+	const tailorIsAmbient = tailorIsAmbientGlobal(root, imports);
+	const edits = optionsTypeEdits(root, imports);
+	for (const member of root.findAll({ rule: { kind: "member_expression" } })) {
+		const property = member.field("property");
+		if (!property || property.kind() !== "property_identifier") continue;
+		if (property.text() !== DEPRECATED_METHOD) continue;
+		const object = member.field("object");
+		if (!object) continue;
+		const isWorkflowImportReceiver = object.kind() === "identifier" && workflowLocals.has(object.text());
+		const isAmbientReceiver = tailorIsAmbient && isAmbientTailorWorkflow(object);
+		if (!isWorkflowImportReceiver && !isAmbientReceiver) continue;
+		edits.push(property.replace(CANONICAL_METHOD));
+	}
+	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/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 };

package/dist/codemods/v2/idp-publish-events-rename/scripts/transform.js

@@ -0,0 +1,186 @@
+import { a as importSource, c as localDeclarationNames, i as importBindings, l as stringValue, r as findImportStatements, s as isTypeOnlyImport } from "../../../ast-grep-helpers-CXtWn3RB.js";
+import { Lang, parse } from "@ast-grep/napi";
+//#region codemods/v2/idp-publish-events-rename/scripts/transform.ts
+const SDK_MODULE = "@tailor-platform/sdk";
+const DEFINE_IDP = "defineIdp";
+const LEGACY_KEY = "publishUserEvents";
+const NEW_KEY = "publishEvents";
+function sourceLang(filePath, source) {
+	return filePath.endsWith(".tsx") || filePath.endsWith(".jsx") || source.includes("</") ? Lang.Tsx : Lang.TypeScript;
+}
+function collectDefineIdpNames(root) {
+	const direct = /* @__PURE__ */ new Set();
+	const namespaces = /* @__PURE__ */ new Set();
+	for (const importStmt of findImportStatements(root)) {
+		if (importSource(importStmt) !== SDK_MODULE || isTypeOnlyImport(importStmt)) continue;
+		for (const binding of importBindings(importStmt)) if (binding.importedName === DEFINE_IDP) direct.add(binding.localName);
+		for (const namespaceImport of importStmt.findAll({ rule: { kind: "namespace_import" } })) for (const identifier of namespaceImport.children()) if (identifier.kind() === "identifier") namespaces.add(identifier.text());
+	}
+	return {
+		direct,
+		namespaces
+	};
+}
+function memberProperty(member) {
+	return member.children().findLast((child) => child.kind() === "property_identifier" || child.kind() === "identifier") ?? null;
+}
+function isDefineIdpCall(call, names) {
+	const callee = call.children()[0];
+	if (!callee) return false;
+	if (callee.kind() === "identifier") return names.direct.has(callee.text());
+	if (callee.kind() !== "member_expression") return false;
+	const object = callee.field("object");
+	return object?.kind() === "identifier" && names.namespaces.has(object.text()) && memberProperty(callee)?.text() === DEFINE_IDP;
+}
+function objectArguments(call) {
+	const args = call.children().find((child) => child.kind() === "arguments");
+	if (!args) return [];
+	return args.children().filter((child) => child.kind() === "object");
+}
+function findLegacyEntries(object) {
+	const entries = [];
+	for (const child of object.children()) {
+		if (child.kind() === "shorthand_property_identifier" && child.text() === LEGACY_KEY) {
+			entries.push({
+				node: child,
+				shorthand: true
+			});
+			continue;
+		}
+		if (child.kind() !== "pair") continue;
+		const key = child.children()[0];
+		if (!key) continue;
+		if (key.kind() !== "property_identifier" && key.kind() !== "string") continue;
+		if (stringValue(key) !== LEGACY_KEY) continue;
+		entries.push({
+			node: key,
+			shorthand: false
+		});
+	}
+	return entries;
+}
+function renameEdit(entry) {
+	if (entry.shorthand) return entry.node.replace(`${NEW_KEY}: ${LEGACY_KEY}`);
+	const text = entry.node.text();
+	if (entry.node.kind() !== "string") return entry.node.replace(NEW_KEY);
+	const quote = text.startsWith("'") ? "'" : text.startsWith("`") ? "`" : "\"";
+	return entry.node.replace(`${quote}${NEW_KEY}${quote}`);
+}
+function parseRoot(source, filePath) {
+	try {
+		return parse(sourceLang(filePath, source), source).root();
+	} catch {
+		return null;
+	}
+}
+function shadowsDefineIdp(root, names) {
+	const declared = localDeclarationNames(root);
+	return [...names.direct, ...names.namespaces].some((name) => declared.has(name));
+}
+/**
+* Rename the `publishUserEvents` option to `publishEvents` on `defineIdp` calls.
+* @param source - File contents
+* @param filePath - Path to the file being transformed
+* @returns Transformed source, or null when nothing matched
+*/
+function transform(source, filePath = "") {
+	if (!source.includes(LEGACY_KEY) || !source.includes(SDK_MODULE)) return null;
+	const root = parseRoot(source, filePath);
+	if (!root) return null;
+	const names = collectDefineIdpNames(root);
+	if (names.direct.size === 0 && names.namespaces.size === 0) return null;
+	if (shadowsDefineIdp(root, names)) return null;
+	const edits = [];
+	for (const call of root.findAll({ rule: { kind: "call_expression" } })) {
+		if (!isDefineIdpCall(call, names)) continue;
+		for (const object of objectArguments(call)) for (const entry of findLegacyEntries(object)) edits.push(renameEdit(entry));
+	}
+	return edits.length > 0 ? root.commitEdits(edits) : null;
+}
+function lineOf(node) {
+	return node.range().start.line + 1;
+}
+function excerptOf(node) {
+	return node.text().split("\n", 1)[0].trim();
+}
+function coversIndex(ranges, index) {
+	return ranges.some((range) => index >= range.start && index < range.end);
+}
+/** Quoted keys, e.g. `{ "publishUserEvents": true }`, whose node kind is a string. */
+function quotedLegacyKeys(root) {
+	return root.findAll({ rule: { kind: "pair" } }).flatMap((pair) => {
+		const key = pair.children()[0];
+		return key?.kind() === "string" && stringValue(key) === LEGACY_KEY ? [key] : [];
+	});
+}
+/** Computed keys whose value cannot be read statically, e.g. `[key]: value`. */
+function computedKeyEntries(object) {
+	return object.children().filter((child) => child.kind() === "pair").flatMap((pair) => {
+		const key = pair.children()[0];
+		return key?.kind() === "computed_property_name" ? [key] : [];
+	});
+}
+/**
+* Report `publishUserEvents` occurrences the transform cannot rewrite.
+*
+* Occurrences nested deeper inside a `defineIdp` options object belong to a
+* different option shape (e.g. `userAuthPolicy`) and are left alone, so only
+* what the transform genuinely missed is reported.
+* @param source - File contents
+* @param filePath - Path to the file being reviewed
+* @param relativePath - Repository-relative path reported to the user
+* @returns Findings for occurrences needing a manual rename
+*/
+function reviewFindings(source, filePath, relativePath) {
+	if (!source.includes(LEGACY_KEY) || !source.includes(SDK_MODULE)) return [];
+	const root = parseRoot(source, filePath);
+	if (!root) return [];
+	const names = collectDefineIdpNames(root);
+	const hasDefineIdp = names.direct.size > 0 || names.namespaces.size > 0;
+	if (hasDefineIdp && shadowsDefineIdp(root, names)) return [{
+		file: relativePath,
+		line: 1,
+		message: `A local declaration shadows the SDK ${DEFINE_IDP} import; rename ${LEGACY_KEY} to ${NEW_KEY} by hand.`,
+		excerpt: LEGACY_KEY
+	}];
+	const rewritten = /* @__PURE__ */ new Set();
+	const optionRanges = [];
+	const findings = [];
+	if (hasDefineIdp) for (const call of root.findAll({ rule: { kind: "call_expression" } })) {
+		if (!isDefineIdpCall(call, names)) continue;
+		for (const object of objectArguments(call)) {
+			const range = object.range();
+			optionRanges.push({
+				start: range.start.index,
+				end: range.end.index
+			});
+			for (const entry of findLegacyEntries(object)) rewritten.add(entry.node.range().start.index);
+			for (const key of computedKeyEntries(object)) findings.push({
+				file: relativePath,
+				line: lineOf(key),
+				message: `A computed ${DEFINE_IDP} option key may be ${LEGACY_KEY}; rename it to ${NEW_KEY} if so.`,
+				excerpt: excerptOf(key)
+			});
+		}
+	}
+	const residual = [...root.findAll({ rule: { any: [{
+		kind: "property_identifier",
+		regex: `^${LEGACY_KEY}$`
+	}, {
+		kind: "shorthand_property_identifier",
+		regex: `^${LEGACY_KEY}$`
+	}] } }), ...quotedLegacyKeys(root)];
+	for (const node of residual) {
+		const index = node.range().start.index;
+		if (rewritten.has(index) || coversIndex(optionRanges, index)) continue;
+		findings.push({
+			file: relativePath,
+			line: lineOf(node),
+			message: `Rename the IdP option ${LEGACY_KEY} to ${NEW_KEY}.`,
+			excerpt: excerptOf(node)
+		});
+	}
+	return findings;
+}
+//#endregion
+export { transform as default, reviewFindings };