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

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-D3FXAKNz.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/db-type-to-table/scripts/transform.js

@@ -0,0 +1,383 @@
+import { a as importSource, i as importBindings, r as findImportStatements } from "../../../ast-grep-helpers-D3FXAKNz.js";
+import { Lang, parse } from "@ast-grep/napi";
+//#region codemods/v2/db-type-to-table/scripts/transform.ts
+const SDK_MODULE = "@tailor-platform/sdk";
+function sourceLang(filePath, source) {
+	return filePath.endsWith(".tsx") || filePath.endsWith(".jsx") || source.includes("</") ? Lang.Tsx : Lang.TypeScript;
+}
+function namespaceImportNames(importStmt) {
+	return importStmt.findAll({ rule: { kind: "namespace_import" } }).flatMap((node) => node.children().filter((child) => child.kind() === "identifier")).map((node) => node.text());
+}
+function isInsideImportStatement(node) {
+	let current = node.parent();
+	while (current) {
+		if (current.kind() === "import_statement") return true;
+		current = current.parent();
+	}
+	return false;
+}
+function isBindingLeafKind(kind) {
+	return kind === "identifier" || kind === "shorthand_property_identifier_pattern";
+}
+function isBindingPatternKind(kind) {
+	return isBindingLeafKind(kind) || kind === "object_pattern" || kind === "array_pattern" || kind === "rest_pattern";
+}
+function collectBindingNodes(node, names, result) {
+	if (isBindingLeafKind(node.kind())) {
+		if (names.has(node.text())) result.push(node);
+		return;
+	}
+	for (const child of node.children()) {
+		if (child.kind() === "property_identifier") continue;
+		if (child.kind() === "=") break;
+		collectBindingNodes(child, names, result);
+	}
+}
+function bindingNodes(node, names) {
+	const result = [];
+	collectBindingNodes(node, names, result);
+	return result;
+}
+function directBindingNodes(node, names) {
+	const result = [];
+	for (const child of node.children()) {
+		if (child.kind() === "=") break;
+		if (isBindingPatternKind(child.kind())) collectBindingNodes(child, names, result);
+	}
+	return result;
+}
+function firstDeclaratorChild(node) {
+	return node.children().find((child) => child.kind() !== "=") ?? null;
+}
+function declaratorValue(node) {
+	const children = node.children();
+	const equalsIndex = children.findIndex((child) => child.kind() === "=");
+	if (equalsIndex === -1) return null;
+	return children.slice(equalsIndex + 1).find((child) => child.kind() !== "comment") ?? null;
+}
+function assignmentTarget(node) {
+	const children = node.children();
+	const equalsIndex = children.findIndex((child) => child.kind() === "=");
+	if (equalsIndex === -1) return null;
+	return children.slice(0, equalsIndex).find((child) => child.kind() !== "comment") ?? null;
+}
+function assignmentValue(node) {
+	const children = node.children();
+	const equalsIndex = children.findIndex((child) => child.kind() === "=");
+	if (equalsIndex === -1) return null;
+	return children.slice(equalsIndex + 1).find((child) => child.kind() !== "comment") ?? null;
+}
+function parameterDefaultTarget(node) {
+	const children = node.children();
+	const equalsIndex = children.findIndex((child) => child.kind() === "=");
+	if (equalsIndex === -1) return null;
+	return children.slice(0, equalsIndex).find((child) => isBindingPatternKind(child.kind())) ?? null;
+}
+function parameterDefaultValue(node) {
+	const children = node.children();
+	const equalsIndex = children.findIndex((child) => child.kind() === "=");
+	if (equalsIndex === -1) return null;
+	return children.slice(equalsIndex + 1).find((child) => child.kind() !== "comment") ?? null;
+}
+function addShadowedRange(shadowedRanges, name, scopeNode) {
+	const range = scopeNode.range();
+	if (!shadowedRanges.has(name)) shadowedRanges.set(name, []);
+	shadowedRanges.get(name).push({
+		start: range.start.index,
+		end: range.end.index
+	});
+}
+function nearestScope(node) {
+	let current = node.parent();
+	while (current) {
+		const kind = current.kind();
+		if (kind === "statement_block" || kind === "program" || kind === "switch_body" || kind === "for_statement" || kind === "for_in_statement") return current;
+		current = current.parent();
+	}
+	return node;
+}
+function functionScope(node) {
+	let current = node.parent();
+	while (current) {
+		const kind = current.kind();
+		if (kind === "function_declaration" || kind === "function_expression" || kind === "arrow_function" || kind === "method_definition" || kind === "program") return current;
+		current = current.parent();
+	}
+	return node;
+}
+function variableDeclarationScope(node) {
+	const declaration = node.parent();
+	if (/^var\b/.test(declaration?.text().trimStart() ?? "")) return functionScope(node);
+	return nearestScope(node);
+}
+function parameterScope(node) {
+	let current = node.parent();
+	while (current) {
+		const kind = current.kind();
+		if (kind === "formal_parameters") {
+			current = current.parent();
+			continue;
+		}
+		if (kind === "function_declaration" || kind === "function_expression" || kind === "arrow_function" || kind === "method_definition") return current;
+		break;
+	}
+	return nearestScope(node);
+}
+function buildShadowedRanges(root, names) {
+	const shadowedRanges = /* @__PURE__ */ new Map();
+	for (const decl of root.findAll({ rule: { kind: "variable_declarator" } })) {
+		if (isInsideImportStatement(decl)) continue;
+		const binding = firstDeclaratorChild(decl);
+		if (!binding) continue;
+		for (const name of bindingNodes(binding, names)) addShadowedRange(shadowedRanges, name.text(), variableDeclarationScope(decl));
+	}
+	for (const decl of root.findAll({ rule: { any: [
+		{ kind: "function_declaration" },
+		{ kind: "class_declaration" },
+		{ kind: "enum_declaration" }
+	] } })) {
+		const name = decl.children().find((child) => child.kind() === "identifier" && names.has(child.text()));
+		if (name) addShadowedRange(shadowedRanges, name.text(), nearestScope(decl));
+	}
+	for (const param of root.findAll({ rule: { any: [{ kind: "required_parameter" }, { kind: "optional_parameter" }] } })) for (const name of directBindingNodes(param, names)) addShadowedRange(shadowedRanges, name.text(), parameterScope(param));
+	for (const arrow of root.findAll({ rule: { kind: "arrow_function" } })) {
+		const children = arrow.children();
+		const arrowIndex = children.findIndex((child) => child.kind() === "=>");
+		if (arrowIndex === -1) continue;
+		for (const child of children.slice(0, arrowIndex)) {
+			if (child.kind() === "=") break;
+			if (!isBindingPatternKind(child.kind())) continue;
+			for (const name of bindingNodes(child, names)) addShadowedRange(shadowedRanges, name.text(), arrow);
+		}
+	}
+	for (const catchClause of root.findAll({ rule: { kind: "catch_clause" } })) for (const name of directBindingNodes(catchClause, names)) addShadowedRange(shadowedRanges, name.text(), catchClause);
+	for (const loop of root.findAll({ rule: { kind: "for_in_statement" } })) {
+		const children = loop.children();
+		const keywordIndex = children.findIndex((child) => child.kind() === "in" || child.kind() === "of");
+		if (keywordIndex === -1) continue;
+		for (const child of children.slice(0, keywordIndex)) for (const name of bindingNodes(child, names)) addShadowedRange(shadowedRanges, name.text(), loop);
+	}
+	return shadowedRanges;
+}
+function isShadowed(node, shadowedRanges) {
+	const ranges = shadowedRanges.get(node.text());
+	if (!ranges) return false;
+	const position = node.range().start.index;
+	return ranges.some((range) => position >= range.start && position < range.end);
+}
+function unwrapExpression(node) {
+	let current = node;
+	while (current) {
+		const kind = current.kind();
+		if (kind === "parenthesized_expression") {
+			current = current.children().find((child) => child.kind() !== "(" && child.kind() !== ")") ?? null;
+			continue;
+		}
+		if (kind === "as_expression" || kind === "satisfies_expression" || kind === "non_null_expression") {
+			current = current.children()[0] ?? null;
+			continue;
+		}
+		if (kind === "type_assertion") {
+			current = current.children().find((child) => child.kind() !== "type_arguments") ?? null;
+			continue;
+		}
+		return current;
+	}
+	return null;
+}
+function isSdkDbMember(object, dbNames, namespaceNames, shadowedRanges) {
+	const unwrapped = unwrapExpression(object);
+	if (!unwrapped) return false;
+	if (unwrapped.kind() === "identifier") return dbNames.has(unwrapped.text()) && !isShadowed(unwrapped, shadowedRanges);
+	if (unwrapped.kind() !== "member_expression") return false;
+	const base = unwrapExpression(unwrapped.field("object"));
+	const property = memberProperty(unwrapped);
+	return base?.kind() === "identifier" && namespaceNames.has(base.text()) && !isShadowed(base, shadowedRanges) && property?.text() === "db";
+}
+function memberProperty(member) {
+	const children = member.children();
+	for (let index = children.length - 1; index >= 0; index -= 1) {
+		const child = children[index];
+		if (child.kind() === "property_identifier") return child;
+	}
+	return member.field("property");
+}
+function typeStringLiteral(node) {
+	if (!node) return null;
+	const kind = node.kind();
+	if (kind !== "string" && kind !== "template_string") return null;
+	const fragments = node.children().filter((child) => child.kind() === "string_fragment");
+	return fragments.length === 1 && fragments[0].text() === "type" ? node : null;
+}
+function replaceStringLiteralValue(node, value) {
+	const text = node.text();
+	const quote = text.startsWith("'") ? "'" : text.startsWith("`") ? "`" : "\"";
+	return node.replace(`${quote}${value}${quote}`);
+}
+function hasTypeBuilderUse(root, name, afterIndex) {
+	for (const member of root.findAll({ rule: { kind: "member_expression" } })) {
+		if (member.range().start.index <= afterIndex) continue;
+		if (memberProperty(member)?.text() !== "type") continue;
+		const object = unwrapExpression(member.field("object"));
+		if (object?.kind() === "identifier" && object.text() === name) return true;
+	}
+	for (const subscript of root.findAll({ rule: { kind: "subscript_expression" } })) {
+		if (subscript.range().start.index <= afterIndex) continue;
+		if (!typeStringLiteral(subscript.field("index"))) continue;
+		const object = unwrapExpression(subscript.field("object"));
+		if (object?.kind() === "identifier" && object.text() === name) return true;
+	}
+	return false;
+}
+function transform(source, filePath) {
+	if (!source.includes("type") || !source.includes(SDK_MODULE)) return null;
+	let root;
+	try {
+		root = parse(sourceLang(filePath, source), source).root();
+	} catch {
+		return null;
+	}
+	const imports = findImportStatements(root).filter((importStmt) => importSource(importStmt) === SDK_MODULE);
+	if (imports.length === 0) return null;
+	const dbNames = /* @__PURE__ */ new Set();
+	const namespaceNames = /* @__PURE__ */ new Set();
+	for (const importStmt of imports) {
+		for (const binding of importBindings(importStmt)) if (binding.importedName === "db") dbNames.add(binding.localName);
+		for (const name of namespaceImportNames(importStmt)) namespaceNames.add(name);
+	}
+	if (dbNames.size === 0 && namespaceNames.size === 0) return null;
+	const shadowedRanges = buildShadowedRanges(root, /* @__PURE__ */ new Set([...dbNames, ...namespaceNames]));
+	const edits = [];
+	for (const member of root.findAll({ rule: { kind: "member_expression" } })) {
+		const property = memberProperty(member);
+		if (property?.text() !== "type") continue;
+		if (!isSdkDbMember(member.field("object"), dbNames, namespaceNames, shadowedRanges)) continue;
+		edits.push(property.replace("table"));
+	}
+	for (const subscript of root.findAll({ rule: { kind: "subscript_expression" } })) {
+		const index = typeStringLiteral(subscript.field("index"));
+		if (!index) continue;
+		if (!isSdkDbMember(subscript.field("object"), dbNames, namespaceNames, shadowedRanges)) continue;
+		edits.push(replaceStringLiteralValue(index, "table"));
+	}
+	return edits.length > 0 ? root.commitEdits(edits) : null;
+}
+function lineForIndex(source, index) {
+	return source.slice(0, index).split(/\r\n|\r|\n/).length;
+}
+function excerptAtIndex(source, index) {
+	const lineStart = Math.max(source.lastIndexOf("\n", index - 1) + 1, 0);
+	const lineEnd = source.indexOf("\n", index);
+	return source.slice(lineStart, lineEnd === -1 ? source.length : lineEnd).trim();
+}
+function objectPatternHasTypeProperty(pattern) {
+	return pattern.findAll({ rule: { any: [{
+		kind: "property_identifier",
+		regex: "^type$"
+	}, {
+		kind: "shorthand_property_identifier_pattern",
+		regex: "^type$"
+	}] } }).some((node) => node.text() === "type");
+}
+function namespaceDbAliasBindings(pattern) {
+	const aliases = [];
+	for (const child of pattern.children()) {
+		if (child.kind() === "shorthand_property_identifier_pattern" && child.text() === "db") {
+			aliases.push(child);
+			continue;
+		}
+		if (child.kind() !== "pair_pattern") continue;
+		if (child.field("key")?.text() !== "db") continue;
+		const value = child.field("value");
+		if (value?.kind() === "identifier") aliases.push(value);
+	}
+	return aliases;
+}
+function isSdkNamespaceMember(node, namespaceNames, shadowedRanges) {
+	const unwrapped = unwrapExpression(node);
+	return unwrapped?.kind() === "identifier" && namespaceNames.has(unwrapped.text()) && !isShadowed(unwrapped, shadowedRanges);
+}
+function reviewFindings(source, filePath, relativePath) {
+	if (!source.includes("type") || !source.includes(SDK_MODULE)) return [];
+	let root;
+	try {
+		root = parse(sourceLang(filePath, source), source).root();
+	} catch {
+		return [];
+	}
+	const imports = findImportStatements(root).filter((importStmt) => importSource(importStmt) === SDK_MODULE);
+	if (imports.length === 0) return [];
+	const dbNames = /* @__PURE__ */ new Set();
+	const namespaceNames = /* @__PURE__ */ new Set();
+	for (const importStmt of imports) {
+		for (const binding of importBindings(importStmt)) if (binding.importedName === "db") dbNames.add(binding.localName);
+		for (const name of namespaceImportNames(importStmt)) namespaceNames.add(name);
+	}
+	if (dbNames.size === 0 && namespaceNames.size === 0) return [];
+	const shadowedRanges = buildShadowedRanges(root, /* @__PURE__ */ new Set([...dbNames, ...namespaceNames]));
+	const findings = [];
+	for (const decl of root.findAll({ rule: { kind: "variable_declarator" } })) {
+		const binding = firstDeclaratorChild(decl);
+		if (binding?.kind() !== "object_pattern" || !objectPatternHasTypeProperty(binding)) continue;
+		if (!isSdkDbMember(declaratorValue(decl), dbNames, namespaceNames, shadowedRanges)) continue;
+		findings.push({
+			file: relativePath,
+			line: lineForIndex(source, binding.range().start.index),
+			message: "Review destructured db.type builder usage and migrate it to db.table.",
+			excerpt: excerptAtIndex(source, binding.range().start.index)
+		});
+	}
+	for (const decl of root.findAll({ rule: { kind: "variable_declarator" } })) {
+		const binding = firstDeclaratorChild(decl);
+		if (binding?.kind() !== "object_pattern") continue;
+		if (!isSdkNamespaceMember(declaratorValue(decl), namespaceNames, shadowedRanges)) continue;
+		for (const alias of namespaceDbAliasBindings(binding)) {
+			if (!hasTypeBuilderUse(root, alias.text(), decl.range().end.index)) continue;
+			findings.push({
+				file: relativePath,
+				line: lineForIndex(source, binding.range().start.index),
+				message: "Review SDK db alias usage and migrate db.type builder calls to db.table.",
+				excerpt: excerptAtIndex(source, binding.range().start.index)
+			});
+		}
+	}
+	for (const decl of root.findAll({ rule: { kind: "variable_declarator" } })) {
+		const binding = firstDeclaratorChild(decl);
+		if (binding?.kind() !== "identifier") continue;
+		if (!isSdkDbMember(declaratorValue(decl), dbNames, namespaceNames, shadowedRanges)) continue;
+		if (!hasTypeBuilderUse(root, binding.text(), decl.range().end.index)) continue;
+		findings.push({
+			file: relativePath,
+			line: lineForIndex(source, binding.range().start.index),
+			message: "Review SDK db alias usage and migrate db.type builder calls to db.table.",
+			excerpt: excerptAtIndex(source, binding.range().start.index)
+		});
+	}
+	for (const assignment of root.findAll({ rule: { kind: "assignment_expression" } })) {
+		const target = assignmentTarget(assignment);
+		if (target?.kind() !== "identifier") continue;
+		if (!isSdkDbMember(assignmentValue(assignment), dbNames, namespaceNames, shadowedRanges)) continue;
+		if (!hasTypeBuilderUse(root, target.text(), assignment.range().end.index)) continue;
+		findings.push({
+			file: relativePath,
+			line: lineForIndex(source, assignment.range().start.index),
+			message: "Review SDK db alias usage and migrate db.type builder calls to db.table.",
+			excerpt: excerptAtIndex(source, assignment.range().start.index)
+		});
+	}
+	for (const param of root.findAll({ rule: { any: [{ kind: "required_parameter" }, { kind: "optional_parameter" }] } })) {
+		const target = parameterDefaultTarget(param);
+		if (target?.kind() !== "identifier") continue;
+		if (!isSdkDbMember(parameterDefaultValue(param), dbNames, namespaceNames, shadowedRanges)) continue;
+		if (!hasTypeBuilderUse(root, target.text(), param.range().end.index)) continue;
+		findings.push({
+			file: relativePath,
+			line: lineForIndex(source, param.range().start.index),
+			message: "Review SDK db alias usage and migrate db.type builder calls to db.table.",
+			excerpt: excerptAtIndex(source, param.range().start.index)
+		});
+	}
+	return findings;
+}
+//#endregion
+export { transform as default, reviewFindings };