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

package/dist/codemods/v2/auth-attributes-rename/scripts/transform.js

@@ -0,0 +1,213 @@
+import { Lang, parse } from "@ast-grep/napi";
+//#region codemods/v2/auth-attributes-rename/scripts/transform.ts
+const SDK_MODULE = "@tailor-platform/sdk";
+const TYPE_RENAME_MAP = {
+	AttributeMap: "Attributes",
+	UserAttributeMap: "UserAttributes",
+	InferredAttributeMap: "InferredAttributes"
+};
+function quickFilter(source) {
+	return source.includes(SDK_MODULE) && Object.keys(TYPE_RENAME_MAP).some((name) => source.includes(name));
+}
+function isSdkModuleLiteral(node) {
+	return node.kind() === "string" && /^["']@tailor-platform\/sdk["']$/.test(node.text());
+}
+function hasSdkModuleLiteral(node) {
+	return node.findAll({ rule: { kind: "string" } }).some(isSdkModuleLiteral);
+}
+function moduleSpecifierLiteral(node) {
+	const directLiteral = node.children().find((child) => child.kind() === "string");
+	if (directLiteral) return directLiteral;
+	return node.children().find((child) => child.kind() === "module")?.children().find((child) => child.kind() === "string");
+}
+function hasSdkModuleSpecifier(node) {
+	const literal = moduleSpecifierLiteral(node);
+	return literal ? isSdkModuleLiteral(literal) : false;
+}
+function identifierChildren(node) {
+	return node.children().filter((child) => child.kind() === "identifier");
+}
+function typeIdentifierChildren(node) {
+	return node.children().filter((child) => child.kind() === "type_identifier");
+}
+function sameRange(a, b) {
+	const ar = a.range();
+	const br = b.range();
+	return ar.start.index === br.start.index && ar.end.index === br.end.index;
+}
+function addReplacement(edits, editedRanges, node, replacement) {
+	if (node.text() === replacement) return;
+	const r = node.range();
+	const key = `${r.start.index}:${r.end.index}`;
+	if (editedRanges.has(key)) return;
+	editedRanges.add(key);
+	edits.push(node.replace(replacement));
+}
+function renamedType(name) {
+	return TYPE_RENAME_MAP[name];
+}
+function isDeclarationName(node) {
+	const parent = node.parent();
+	if (!parent || ![
+		"class_declaration",
+		"enum_declaration",
+		"interface_declaration",
+		"type_alias_declaration",
+		"type_parameter"
+	].includes(parent.kind())) return false;
+	const name = parent?.field("name");
+	return !!name && sameRange(name, node);
+}
+function isNestedTypeName(node) {
+	return node.parent()?.kind() === "nested_type_identifier";
+}
+function declarationName(node) {
+	if ([
+		"class_declaration",
+		"enum_declaration",
+		"interface_declaration",
+		"type_alias_declaration"
+	].includes(node.kind())) return node.field("name") ?? void 0;
+	if (node.kind() !== "export_statement") return void 0;
+	return node.children().find((child) => [
+		"class_declaration",
+		"enum_declaration",
+		"interface_declaration",
+		"type_alias_declaration"
+	].includes(child.kind()))?.field("name") ?? void 0;
+}
+function scopeDeclaresType(scope, name, reference) {
+	return scope.children().some((child) => {
+		const declaredName = declarationName(child);
+		return !!declaredName && declaredName.text() === name && !sameRange(declaredName, reference);
+	});
+}
+function hasTypeParameterShadow(node, name) {
+	return node.findAll({ rule: { kind: "type_parameter" } }).some((parameter) => typeIdentifierChildren(parameter)[0]?.text() === name);
+}
+function isShadowedTypeReference(node, name) {
+	let current = node.parent();
+	while (current) {
+		if (current.kind() === "statement_block" && scopeDeclaresType(current, name, node)) return true;
+		if ([
+			"class_declaration",
+			"function_declaration",
+			"interface_declaration",
+			"method_definition",
+			"type_alias_declaration"
+		].includes(current.kind()) && hasTypeParameterShadow(current, name)) return true;
+		current = current.parent();
+	}
+	return false;
+}
+function collectSdkImports(root, edits, editedRanges) {
+	const localTypeRenames = /* @__PURE__ */ new Map();
+	const namespaceNames = /* @__PURE__ */ new Set();
+	const importStmts = root.findAll({ rule: { kind: "import_statement" } });
+	for (const importStmt of importStmts) {
+		if (!hasSdkModuleSpecifier(importStmt)) continue;
+		const namespaceImports = importStmt.findAll({ rule: { kind: "namespace_import" } });
+		for (const namespaceImport of namespaceImports) {
+			const localName = identifierChildren(namespaceImport).at(-1)?.text();
+			if (localName) namespaceNames.add(localName);
+		}
+		const specs = importStmt.findAll({ rule: { kind: "import_specifier" } });
+		for (const spec of specs) {
+			const identifiers = identifierChildren(spec);
+			const imported = identifiers[0];
+			if (!imported) continue;
+			const replacement = renamedType(imported.text());
+			if (!replacement) continue;
+			addReplacement(edits, editedRanges, imported, replacement);
+			if (identifiers.length === 1) localTypeRenames.set(imported.text(), replacement);
+		}
+	}
+	return {
+		localTypeRenames,
+		namespaceNames
+	};
+}
+function rewriteSdkExports(root, edits, editedRanges) {
+	const exportStmts = root.findAll({ rule: { kind: "export_statement" } });
+	for (const exportStmt of exportStmts) {
+		if (!hasSdkModuleSpecifier(exportStmt)) continue;
+		const specs = exportStmt.findAll({ rule: { kind: "export_specifier" } });
+		for (const spec of specs) {
+			const exported = identifierChildren(spec)[0];
+			if (!exported) continue;
+			const replacement = renamedType(exported.text());
+			if (replacement) addReplacement(edits, editedRanges, exported, replacement);
+		}
+	}
+}
+function rewriteModuleAugmentations(root, edits, editedRanges) {
+	const declarations = root.findAll({ rule: { kind: "ambient_declaration" } });
+	for (const declaration of declarations) {
+		if (!hasSdkModuleSpecifier(declaration)) continue;
+		const interfaces = declaration.findAll({ rule: { kind: "interface_declaration" } });
+		for (const iface of interfaces) {
+			const name = typeIdentifierChildren(iface)[0];
+			if (name?.text() === "AttributeMap") addReplacement(edits, editedRanges, name, "Attributes");
+		}
+	}
+}
+function rewriteLocalTypeReferences(root, edits, editedRanges, localTypeRenames) {
+	if (localTypeRenames.size === 0) return;
+	const typeIdentifiers = root.findAll({ rule: { kind: "type_identifier" } });
+	for (const typeIdentifier of typeIdentifiers) {
+		if (isDeclarationName(typeIdentifier) || isNestedTypeName(typeIdentifier)) continue;
+		const replacement = localTypeRenames.get(typeIdentifier.text());
+		if (replacement && isShadowedTypeReference(typeIdentifier, typeIdentifier.text())) continue;
+		if (replacement) addReplacement(edits, editedRanges, typeIdentifier, replacement);
+	}
+}
+function rewriteNamespaceTypeReferences(root, edits, editedRanges, namespaceNames) {
+	if (namespaceNames.size === 0) return;
+	const nestedTypes = root.findAll({ rule: { kind: "nested_type_identifier" } });
+	for (const nestedType of nestedTypes) {
+		const namespaceName = identifierChildren(nestedType)[0]?.text();
+		if (!namespaceName || !namespaceNames.has(namespaceName)) continue;
+		const typeName = typeIdentifierChildren(nestedType).at(-1);
+		if (!typeName) continue;
+		const replacement = renamedType(typeName.text());
+		if (replacement) addReplacement(edits, editedRanges, typeName, replacement);
+	}
+}
+function isSdkImportCall(node) {
+	return node.kind() === "call_expression" && hasSdkModuleLiteral(node);
+}
+function rewriteImportTypeReferences(root, edits, editedRanges) {
+	const members = root.findAll({ rule: { kind: "member_expression" } });
+	for (const member of members) {
+		const object = member.field("object");
+		if (!object || !isSdkImportCall(object)) continue;
+		const property = member.field("property");
+		if (!property || property.kind() !== "property_identifier") continue;
+		const replacement = renamedType(property.text());
+		if (replacement) addReplacement(edits, editedRanges, property, replacement);
+	}
+}
+/**
+* Rename the v1 auth attribute type API to its v2 names only when a reference
+* can be tied to `@tailor-platform/sdk`.
+* @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 filePath = _filePath?.toLowerCase();
+	const root = parse(filePath?.endsWith(".tsx") || filePath?.endsWith(".jsx") ? Lang.Tsx : filePath ? Lang.TypeScript : source.includes("</") || source.includes("/>") ? Lang.Tsx : Lang.TypeScript, source).root();
+	const edits = [];
+	const editedRanges = /* @__PURE__ */ new Set();
+	const { localTypeRenames, namespaceNames } = collectSdkImports(root, edits, editedRanges);
+	rewriteSdkExports(root, edits, editedRanges);
+	rewriteModuleAugmentations(root, edits, editedRanges);
+	rewriteLocalTypeReferences(root, edits, editedRanges, localTypeRenames);
+	rewriteNamespaceTypeReferences(root, edits, editedRanges, namespaceNames);
+	rewriteImportTypeReferences(root, edits, editedRanges);
+	if (edits.length === 0) return null;
+	return root.commitEdits(edits);
+}
+//#endregion
+export { transform as default };

package/dist/codemods/v2/auth-connection-token-helper/scripts/transform.js

@@ -0,0 +1,243 @@
+import { a as importSource, c as localDeclarationNames, i as importBindings, o as importSpecNames, r as findImportStatements, s as isTypeOnlyImport, t as buildAddNamedImportEdit } from "../../../ast-grep-helpers-CXtWn3RB.js";
+import { Lang, parse } from "@ast-grep/napi";
+//#region codemods/v2/auth-connection-token-helper/scripts/transform.ts
+const RUNTIME_MODULE = "@tailor-platform/sdk/runtime";
+const AUTHCONNECTION = "authconnection";
+const GET_CONNECTION_TOKEN = "getConnectionToken";
+const JSX_FILE_EXTENSIONS = /* @__PURE__ */ new Set([".tsx", ".jsx"]);
+const JS_FILE_EXTENSIONS = /* @__PURE__ */ new Set([
+	".js",
+	".mjs",
+	".cjs"
+]);
+function quickFilter(source) {
+	return source.includes(GET_CONNECTION_TOKEN);
+}
+function sourceLang(filePath, source) {
+	const lower = filePath.toLowerCase();
+	const extension = lower.slice(lower.lastIndexOf("."));
+	if (JSX_FILE_EXTENSIONS.has(extension)) return Lang.Tsx;
+	if (JS_FILE_EXTENSIONS.has(extension) && /<>|<\/>|<[A-Za-z][\w.$:-]/.test(source)) return Lang.Tsx;
+	return Lang.TypeScript;
+}
+function parseRoot(source, filePath) {
+	if (!quickFilter(source)) return null;
+	try {
+		return parse(sourceLang(filePath, source), source).root();
+	} catch {
+		return null;
+	}
+}
+function isTailorConfigSource(source) {
+	return /(^|\/)tailor\.config(?:\.(?:ts|tsx|js|jsx|mts|cts|mjs|cjs))?$/.test(source);
+}
+function findAuthImports(imports) {
+	const authImports = [];
+	for (const importStmt of imports) {
+		const source = importSource(importStmt);
+		if (!source || !isTailorConfigSource(source) || isTypeOnlyImport(importStmt)) continue;
+		for (const spec of importStmt.findAll({ rule: { kind: "import_specifier" } })) {
+			const names = importSpecNames(spec);
+			if (names?.importedName !== "auth" || names.typeOnly) continue;
+			authImports.push({
+				importStmt,
+				localName: names.localName,
+				spec
+			});
+		}
+	}
+	return authImports;
+}
+function runtimeAuthconnectionReference(imports) {
+	for (const importStmt of imports) {
+		if (importSource(importStmt) !== RUNTIME_MODULE || isTypeOnlyImport(importStmt)) continue;
+		for (const binding of importBindings(importStmt)) if (binding.importedName === AUTHCONNECTION && !binding.typeOnly) return binding.localName;
+		const local = (importStmt.children().find((child) => child.kind() === "import_clause")?.children().find((child) => child.kind() === "namespace_import"))?.children().find((child) => child.kind() === "identifier");
+		if (local) return `${local.text()}.${AUTHCONNECTION}`;
+	}
+	return null;
+}
+function hasRuntimeImportCollision(root, imports) {
+	if (localDeclarationNames(root).has(AUTHCONNECTION)) return true;
+	return imports.some((importStmt) => importSource(importStmt) !== RUNTIME_MODULE && importBindings(importStmt).some((binding) => binding.localName === AUTHCONNECTION && !binding.typeOnly));
+}
+function hasAuthLocalCollision(root, authLocalNames) {
+	const localNames = localDeclarationNames(root);
+	return Array.from(authLocalNames).some((name) => localNames.has(name));
+}
+function findDirectAuthCalls(root, authLocalNames) {
+	const calls = [];
+	for (const call of root.findAll({ rule: { kind: "call_expression" } })) {
+		const callee = call.field("function");
+		if (callee?.kind() !== "member_expression") continue;
+		const object = callee.field("object");
+		const property = callee.field("property");
+		if (object?.kind() !== "identifier" || property?.text() !== GET_CONNECTION_TOKEN || !authLocalNames.has(object.text())) continue;
+		const range = object.range();
+		calls.push({
+			objectNode: object,
+			localName: object.text(),
+			range: [range.start.index, range.end.index]
+		});
+	}
+	return calls;
+}
+function isInsideImportStatement(node) {
+	let current = node.parent();
+	while (current) {
+		if (current.kind() === "import_statement") return true;
+		current = current.parent();
+	}
+	return false;
+}
+function isInsideScheduledRange(node, ranges) {
+	const start = node.range().start.index;
+	return ranges.some(([rangeStart, rangeEnd]) => start >= rangeStart && start < rangeEnd);
+}
+function countRemainingRefs(root, localName, scheduledRanges) {
+	return root.findAll({ rule: { any: [{ kind: "identifier" }, { kind: "shorthand_property_identifier" }] } }).filter((node) => node.text() === localName).filter((node) => !isInsideImportStatement(node) && !isInsideScheduledRange(node, scheduledRanges)).length;
+}
+function importInsertionIndex(root, imports, source) {
+	const lastImport = imports.at(-1);
+	if (lastImport) return lastImport.range().end.index;
+	if (source.startsWith("#!")) {
+		const newlineIndex = source.indexOf("\n");
+		return newlineIndex === -1 ? source.length : newlineIndex + 1;
+	}
+	return root.children().find((child) => child.kind() !== "comment")?.range().start.index ?? 0;
+}
+function buildAddRuntimeImportEdit(root, source, imports) {
+	return buildAddNamedImportEdit({
+		importName: AUTHCONNECTION,
+		imports,
+		insertionIndex: importInsertionIndex,
+		moduleName: RUNTIME_MODULE,
+		root,
+		source
+	});
+}
+function lineStartIndex(source, index) {
+	let pos = index;
+	while (pos > 0 && source[pos - 1] !== "\n" && source[pos - 1] !== "\r") pos--;
+	return pos;
+}
+function consumeLineBreak(source, index) {
+	if (source[index] === "\r") return source[index + 1] === "\n" ? index + 2 : index + 1;
+	if (source[index] === "\n") return index + 1;
+	return index;
+}
+function isHorizontalWhitespace(source, start, end) {
+	for (let index = start; index < end; index++) if (source[index] !== " " && source[index] !== "	") return false;
+	return true;
+}
+function buildImportRemovalEdit(source, binding) {
+	if (binding.importStmt.findAll({ rule: { kind: "import_specifier" } }).length === 1) {
+		const range = binding.importStmt.range();
+		let end = range.end.index;
+		if (source[end] === "\n") end++;
+		return {
+			startPos: range.start.index,
+			endPos: end,
+			insertedText: ""
+		};
+	}
+	const range = binding.spec.range();
+	let start = range.start.index;
+	let end = range.end.index;
+	const specEnd = end;
+	while (end < source.length && /[ \t]/.test(source[end])) end++;
+	if (source[end] === ",") {
+		end++;
+		while (end < source.length && /[ \t]/.test(source[end])) end++;
+		const nextLine = consumeLineBreak(source, end);
+		const lineStart = lineStartIndex(source, start);
+		if (nextLine !== end && isHorizontalWhitespace(source, lineStart, start)) return {
+			startPos: lineStart,
+			endPos: nextLine,
+			insertedText: ""
+		};
+		return {
+			startPos: start,
+			endPos: end,
+			insertedText: ""
+		};
+	}
+	const nextLine = consumeLineBreak(source, end);
+	const lineStart = lineStartIndex(source, start);
+	if (nextLine !== end && isHorizontalWhitespace(source, lineStart, start)) return {
+		startPos: lineStart,
+		endPos: nextLine,
+		insertedText: ""
+	};
+	while (start > 0 && /[ \t]/.test(source[start - 1])) start--;
+	if (source[start - 1] === ",") start--;
+	return {
+		startPos: start,
+		endPos: specEnd,
+		insertedText: ""
+	};
+}
+function applyEdits(source, edits) {
+	return edits.toSorted((a, b) => b.startPos - a.startPos || b.endPos - a.endPos).reduce((current, edit) => `${current.slice(0, edit.startPos)}${edit.insertedText}${current.slice(edit.endPos)}`, source).replace(/^\n+/, "");
+}
+function transformParsed(source, root) {
+	const imports = findImportStatements(root);
+	const authImports = findAuthImports(imports);
+	if (authImports.length === 0) return null;
+	const authLocalNames = new Set(authImports.map((binding) => binding.localName));
+	if (hasAuthLocalCollision(root, authLocalNames)) return null;
+	const calls = findDirectAuthCalls(root, authLocalNames);
+	if (calls.length === 0) return null;
+	const existingRuntimeRef = runtimeAuthconnectionReference(imports);
+	if (!existingRuntimeRef && hasRuntimeImportCollision(root, imports)) return null;
+	const runtimeRef = existingRuntimeRef ?? AUTHCONNECTION;
+	const edits = calls.map((call) => call.objectNode.replace(runtimeRef));
+	if (!existingRuntimeRef) edits.push(buildAddRuntimeImportEdit(root, source, imports));
+	const scheduledRangesByLocalName = /* @__PURE__ */ new Map();
+	for (const call of calls) {
+		const ranges = scheduledRangesByLocalName.get(call.localName) ?? [];
+		ranges.push(call.range);
+		scheduledRangesByLocalName.set(call.localName, ranges);
+	}
+	for (const binding of authImports) {
+		if (!scheduledRangesByLocalName.has(binding.localName)) continue;
+		if (countRemainingRefs(root, binding.localName, scheduledRangesByLocalName.get(binding.localName) ?? []) > 0) continue;
+		const edit = buildImportRemovalEdit(source, binding);
+		if (edit) edits.push(edit);
+	}
+	const result = applyEdits(source, edits);
+	return result === source ? null : result;
+}
+function transform(source, filePath) {
+	const root = parseRoot(source, filePath);
+	return root ? transformParsed(source, root) : null;
+}
+function lineForIndex(source, index) {
+	return source.slice(0, index).split(/\r\n|\r|\n/).length;
+}
+function excerptForLine(line) {
+	return line.trim();
+}
+function isReviewLine(excerpt) {
+	if (!excerpt.includes(GET_CONNECTION_TOKEN)) return false;
+	if (excerpt.includes(`${AUTHCONNECTION}.${GET_CONNECTION_TOKEN}`) || excerpt.includes(`tailor.${AUTHCONNECTION}.${GET_CONNECTION_TOKEN}`)) return false;
+	return excerpt.includes(`.${GET_CONNECTION_TOKEN}`) || excerpt.includes(`["${GET_CONNECTION_TOKEN}"]`) || excerpt.includes(`['${GET_CONNECTION_TOKEN}']`) || new RegExp(`[,{]\\s*${GET_CONNECTION_TOKEN}\\s*[:}=,]`).test(excerpt);
+}
+function reviewFindings(source, _filePath, relativePath) {
+	if (!quickFilter(source)) return [];
+	const findings = [];
+	let offset = 0;
+	for (const line of source.split(/\n/)) {
+		const excerpt = excerptForLine(line);
+		if (isReviewLine(excerpt)) findings.push({
+			file: relativePath,
+			line: lineForIndex(source, offset),
+			message: "Replace defineAuth auth.getConnectionToken() with runtime authconnection.",
+			excerpt
+		});
+		offset += line.length + 1;
+	}
+	return findings;
+}
+//#endregion
+export { transform as default, reviewFindings };

package/dist/codemods/v2/auth-invoker-call-unwrap/scripts/transform.js

@@ -0,0 +1,7 @@
+import { transformAuthInvoker } from "../../auth-invoker-unwrap/scripts/transform.js";
+//#region codemods/v2/auth-invoker-call-unwrap/scripts/transform.ts
+function transform(source, filePath) {
+	return transformAuthInvoker(source, filePath, { renameOptionKeys: false });
+}
+//#endregion
+export { transform as default };

package/dist/codemods/v2/auth-invoker-unwrap/scripts/transform.js

@@ -1,8 +1,8 @@
 import { Lang, parse } from "@ast-grep/napi";
 //#region codemods/v2/auth-invoker-unwrap/scripts/transform.ts
-const QUICK_FILTER_NEEDLE = "auth.invoker";
+const QUICK_FILTER_NEEDLES = ["auth.invoker", "authInvoker"];
 function quickFilter(source) {
-	return source.includes(QUICK_FILTER_NEEDLE);
+	return QUICK_FILTER_NEEDLES.some((needle) => source.includes(needle));
 }
 function isInsideImportStatement(node) {
 	let current = node.parent();
@@ -121,32 +121,127 @@ function findAuthImports(root) {
 		return false;
 	});
 }
+function sameRange(a, b) {
+	const ar = a.range();
+	const br = b.range();
+	return ar.start.index === br.start.index && ar.end.index === br.end.index;
+}
+function keyText(node) {
+	if (!node) return null;
+	return node.text().replace(/^['"]|['"]$/g, "");
+}
+function expressionArguments(args) {
+	return args.children().filter((child) => ![
+		"(",
+		")",
+		","
+	].includes(child.kind()));
+}
+function argumentCallForObject(objectNode) {
+	const args = objectNode.parent();
+	const call = args?.parent();
+	if (args?.kind() !== "arguments" || call?.kind() !== "call_expression") return null;
+	const index = expressionArguments(args).findIndex((arg) => sameRange(arg, objectNode));
+	return index === -1 ? null : {
+		call,
+		index
+	};
+}
+function calleeText(call) {
+	return call.field("function")?.text() ?? "";
+}
+function isCreateCallOptionObject(objectNode, functionName) {
+	const callInfo = argumentCallForObject(objectNode);
+	return callInfo?.index === 0 && callInfo.call.field("function")?.kind() === "identifier" && calleeText(callInfo.call) === functionName;
+}
+function isExecutorOperationObject(objectNode) {
+	const operationPair = objectNode.parent();
+	if (operationPair?.kind() !== "pair" || keyText(operationPair.field("key")) !== "operation") return false;
+	const configObject = operationPair.parent();
+	return configObject?.kind() === "object" && isCreateCallOptionObject(configObject, "createExecutor");
+}
+function isSupportedInvokerOptionObject(objectNode) {
+	return isCreateCallOptionObject(objectNode, "createResolver") || isCreateCallOptionObject(objectNode, "startWorkflow") || isExecutorOperationObject(objectNode);
+}
+function optionObjectForPairKey(node) {
+	const parent = node.parent();
+	if (!parent || parent.kind() !== "pair") return null;
+	const key = parent.field("key");
+	if (!key || !sameRange(key, node)) return null;
+	const objectNode = parent.parent();
+	return objectNode?.kind() === "object" ? objectNode : null;
+}
+function isSupportedInvokerOptionKey(node) {
+	const objectNode = optionObjectForPairKey(node) ?? node.parent();
+	return objectNode?.kind() === "object" && isSupportedInvokerOptionObject(objectNode);
+}
+function isSupportedInvokerValueCall(node) {
+	const pair = node.parent();
+	if (pair?.kind() !== "pair") return false;
+	const value = pair.field("value");
+	if (!value || !sameRange(value, node)) return false;
+	const key = keyText(pair.field("key"));
+	if (key !== "authInvoker" && key !== "invoker") return false;
+	const objectNode = pair.parent();
+	return objectNode?.kind() === "object" && isSupportedInvokerOptionObject(objectNode);
+}
+function findAuthInvokerShorthands(root) {
+	return root.findAll({ rule: {
+		kind: "shorthand_property_identifier",
+		regex: "^authInvoker$"
+	} }).filter(isSupportedInvokerOptionKey);
+}
+function findAuthInvokerPropertyKeys(root) {
+	return root.findAll({ rule: {
+		kind: "property_identifier",
+		regex: "^authInvoker$"
+	} }).filter(isSupportedInvokerOptionKey);
+}
+function findQuotedAuthInvokerPropertyKeys(root) {
+	return root.findAll({ rule: {
+		kind: "string",
+		regex: "^['\"]authInvoker['\"]$"
+	} }).filter(isSupportedInvokerOptionKey);
+}
+function renameQuotedKey(node) {
+	const quote = node.text().startsWith("'") ? "'" : "\"";
+	return `${quote}invoker${quote}`;
+}
 /**
-* Replace `auth.invoker("name")` calls with the bare `"name"` string literal.
+* Replace `auth.invoker("name")` calls with the bare `"name"` string literal
+* and optionally rename `authInvoker:` option keys to `invoker:`.
 * If no other `auth` references remain after the rewrite, drop the `auth`
 * specifier (or the entire import line when `auth` was its sole specifier).
 *
-* `auth.invoker()` was deprecated in favor of passing the machine user name
-* directly; carrying the `auth` import only for `.invoker()` would otherwise
-* pull config-layer (Node-only) modules into runtime bundles.
+* `auth.invoker()` was removed in favor of passing the machine user name
+* directly to `invoker`; carrying the `auth` import only for `.invoker()`
+* would otherwise pull config-layer modules into runtime bundles.
 * @param source - File contents
 * @param filePath - Absolute path to the file (kept for the runner signature)
+* @param options - Transform behavior flags
 * @returns Transformed source or null when nothing matched.
 */
-function transform(source, _filePath) {
+function transformAuthInvoker(source, _filePath, options = {}) {
 	if (!quickFilter(source)) return null;
+	const renameOptionKeys = options.renameOptionKeys ?? true;
 	const root = parse(source.includes("</") || source.includes("/>") ? Lang.Tsx : Lang.TypeScript, source).root();
-	const calls = findInvokerCalls(root);
-	if (calls.length === 0) return null;
+	const calls = findInvokerCalls(root).filter((c) => isSupportedInvokerValueCall(c.callNode));
 	const edits = calls.map((c) => c.callNode.replace(c.argText));
-	if (countRemainingAuthRefs(root, calls.map((c) => c.range)) === 0) for (const importStmt of findAuthImports(root)) {
+	if (renameOptionKeys) {
+		edits.push(...findAuthInvokerPropertyKeys(root).map((node) => node.replace("invoker")));
+		edits.push(...findQuotedAuthInvokerPropertyKeys(root).map((node) => node.replace(renameQuotedKey(node))));
+		edits.push(...findAuthInvokerShorthands(root).map((node) => node.replace("invoker: authInvoker")));
+	}
+	if (calls.length > 0 && countRemainingAuthRefs(root, calls.map((c) => c.range)) === 0) for (const importStmt of findAuthImports(root)) {
 		const edit = buildAuthImportRemovalEdit(source, importStmt);
 		if (edit) edits.push(edit);
 	}
-	if (edits.length === 0) return null;
-	let result = root.commitEdits(edits);
+	let result = edits.length === 0 ? source : root.commitEdits(edits);
 	result = result.replace(/^[\t ]*\n+/, "").replace(/\n{3,}/g, "\n\n");
 	return result === source ? null : result;
 }
+function transform(source, filePath) {
+	return transformAuthInvoker(source, filePath);
+}
 //#endregion
-export { transform as default };
+export { transform as default, transformAuthInvoker };