@tailor-platform/sdk-codemod 0.3.0-next.2 → 0.3.0-next.3

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

@@ -0,0 +1,243 @@
+import { a as importSpecNames, i as importSource, n as findImportStatements, o as isTypeOnlyImport, r as importBindings, s as localDeclarationNames, t as buildAddNamedImportEdit } from "../../../ast-grep-helpers-Bfn39biW.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

@@ -209,7 +209,7 @@ function renameQuotedKey(node) {
 }
 /**
 * Replace `auth.invoker("name")` calls with the bare `"name"` string literal
-* and rename `authInvoker:` option keys to `invoker:`.
+* 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).
 *
@@ -218,16 +218,20 @@ function renameQuotedKey(node) {
 * 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).filter((c) => isSupportedInvokerValueCall(c.callNode));
 	const edits = calls.map((c) => c.callNode.replace(c.argText));
-	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 (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);
@@ -236,5 +240,8 @@ function transform(source, _filePath) {
 	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 };

package/dist/codemods/v2/define-generators-to-plugins/scripts/transform.js

@@ -47,7 +47,8 @@ function transform(source) {
 			if (arg.kind() === "array") {
 				const children = arg.children().filter((c) => c.isNamed() && c.kind() !== "comment");
 				if (children.length >= 1) {
-					const mapping = PLUGIN_MAP[children[0].text().replace(/^["']|["']$/g, "")];
+					const packageName = children[0].text().replace(/^["']|["']$/g, "");
+					const mapping = PLUGIN_MAP[packageName];
 					if (mapping) {
 						migratedArgs++;
 						importsToAdd.set(mapping.importPath, mapping.functionName);

package/dist/codemods/v2/env-var-rename/scripts/transform.js

@@ -0,0 +1,88 @@
+import { Lang, parse } from "@ast-grep/napi";
+import * as path from "pathe";
+//#region codemods/v2/env-var-rename/scripts/transform.ts
+const ENV_RENAMES = [
+	["TAILOR_PLATFORM_SDK_CONFIG_PATH", "TAILOR_CONFIG_PATH"],
+	["TAILOR_PLATFORM_SDK_DTS_PATH", "TAILOR_DTS_PATH"],
+	["TAILOR_PLATFORM_SDK_ALLOW_CI_ID_INJECTION", "TAILOR_CI_ALLOW_ID_INJECTION"],
+	["TAILOR_PLATFORM_SDK_BUILD_ONLY", "TAILOR_DEPLOY_BUILD_ONLY"],
+	["TAILOR_SDK_OUTPUT_DIR", "TAILOR_BUILD_OUTPUT_DIR"],
+	["TAILOR_SDK_SKILLS_SOURCE", "TAILOR_SKILLS_SOURCE"],
+	["TAILOR_SDK_VERSION", "TAILOR_TEMPLATE_SDK_VERSION"],
+	["TAILOR_ENABLE_INLINE_SOURCEMAP", "TAILOR_INLINE_SOURCEMAP"],
+	["TAILOR_PLATFORM_QUERY_NEWLINE_ON_ENTER", "TAILOR_QUERY_NEWLINE_ON_ENTER"],
+	["TAILOR_TOKEN", "TAILOR_PLATFORM_TOKEN"]
+];
+const SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
+	".ts",
+	".tsx",
+	".mts",
+	".cts",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs"
+]);
+const ENV_BOUNDARY = "[A-Za-z0-9_]";
+const RENAME_PATTERNS = ENV_RENAMES.map(([from, to]) => ({
+	pattern: new RegExp(`(?<!${ENV_BOUNDARY})${from}(?!${ENV_BOUNDARY})`, "g"),
+	to
+}));
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function replaceTextTokens(source) {
+	let updated = source;
+	for (const { pattern, to } of RENAME_PATTERNS) updated = updated.replace(pattern, to);
+	return updated;
+}
+function sourceLang(filePath) {
+	const ext = path.extname(filePath).toLowerCase();
+	return ext === ".tsx" || ext === ".jsx" ? Lang.Tsx : Lang.TypeScript;
+}
+function collectStringFragmentEdits(root, source) {
+	const edits = [];
+	const visit = (node) => {
+		if (node.kind() === "string_fragment") {
+			const range = node.range();
+			const text = source.slice(range.start.index, range.end.index);
+			const replacement = replaceTextTokens(text);
+			if (replacement !== text) edits.push([
+				range.start.index,
+				range.end.index,
+				replacement
+			]);
+			return;
+		}
+		for (const child of node.children()) visit(child);
+	};
+	visit(root);
+	return edits;
+}
+function replaceSourceStringFragments(source, filePath) {
+	let root;
+	try {
+		root = parse(sourceLang(filePath), source).root();
+	} catch {
+		return source;
+	}
+	let updated = source;
+	const edits = collectStringFragmentEdits(root, source).toSorted(([a], [b]) => b - a);
+	for (const [start, end, replacement] of edits) updated = `${updated.slice(0, start)}${replacement}${updated.slice(end)}`;
+	return updated;
+}
+function replaceSourceTokens(source, filePath) {
+	let updated = source;
+	for (const [from, to] of ENV_RENAMES) {
+		const escaped = escapeRegExp(from);
+		updated = updated.replace(new RegExp(`\\bprocess\\.env\\.${escaped}(?![A-Za-z0-9_$])`, "g"), `process.env.${to}`).replace(new RegExp(`\\bprocess\\.env\\[(["'\`])${escaped}\\1\\]`, "g"), `process.env[$1${to}$1]`).replace(new RegExp(`([,{]\\s*)${escaped}(?=\\s*:)`, "g"), `$1${to}`);
+	}
+	return replaceSourceStringFragments(updated, filePath);
+}
+function transform(source, filePath) {
+	const ext = path.extname(filePath).toLowerCase();
+	const updated = SOURCE_EXTENSIONS.has(ext) ? replaceSourceTokens(source, filePath) : replaceTextTokens(source);
+	return updated === source ? null : updated;
+}
+//#endregion
+export { transform as default };