better-supabase 0.3.0 → 0.5.0

package/dist/cli/codemod-DqV7612m.js

@@ -0,0 +1,388 @@
+import { r as defineCliCommand } from "./command-CK14fP91.js";
+import { r as writeIfChanged } from "./io-k41_z-jT.js";
+import { i as plain, r as painter } from "./style-C0NFdJRL.js";
+import { t as fileDiff } from "./diff-SjkO5rNr.js";
+import { extname, join, relative, resolve } from "node:path";
+import { readFile, readdir, stat } from "node:fs/promises";
+//#region src/cli/codemod.ts
+const CODEMODS = {
+	"0.4": {
+		name: "0.4",
+		description: "Renames from 0.3 to 0.4 (the naming page lists them)",
+		imports: {
+			createBrowser: "createClient",
+			BetterBrowser: "BetterClient",
+			BrowserOptions: "ClientOptions",
+			BrowserAuth: "ClientAuth",
+			BetterEnv: "HonoEnv",
+			HandlerOptions: "MiddlewareOptions",
+			Queries: "BetterQueries",
+			CreateQueriesOptions: "QueriesOptions",
+			Postgres: "BetterPostgres",
+			DefineSupabaseOptions: "SupabaseOptions"
+		},
+		members: [
+			{
+				from: "serverFor",
+				to: "contextForSession"
+			},
+			{
+				from: "toORPCError",
+				to: "toOrpcError"
+			},
+			{
+				from: "$table",
+				to: "$tableName",
+				notCalled: true
+			}
+		],
+		props: [{
+			component: "BetterSupabaseProvider",
+			from: "browser",
+			to: "client"
+		}],
+		review: [
+			{
+				pattern: /\.server\(\)/,
+				message: "`next.server()` is `bs.context()` on the createNext() instance"
+			},
+			{
+				pattern: /\.handle\(\)/,
+				message: "Hono's `bs.handle()` is `bs.handler()`"
+			},
+			{
+				pattern: /\bmcp\.handler\b/,
+				message: "`mcp.handler` is `bs.endpoint`"
+			},
+			{
+				pattern: /\.sb\b/,
+				message: "`client.sb` is `client.betterSupabase`"
+			},
+			{
+				pattern: /\btestExecutor\(\s*\{[^}]*\bsb\b/,
+				message: "`{ sb }` in testExecutor is `{ betterSupabase }`"
+			}
+		]
+	},
+	"0.5": {
+		name: "0.5",
+		description: "Renames from 0.4 to 0.5: createMcp's scopes is advertisedScopes",
+		options: [{
+			call: "createMcp",
+			from: "scopes",
+			to: "advertisedScopes"
+		}]
+	}
+};
+/** `[start, end)` ranges of code, outside strings, template literals and comments. */
+function codeRanges(text) {
+	const ranges = [];
+	let start = 0;
+	let index = 0;
+	const skip = (end) => {
+		if (index > start) ranges.push([start, index]);
+		index = end;
+		start = end;
+	};
+	while (index < text.length) {
+		const char = text[index];
+		const next = text[index + 1];
+		if (char === "/" && next === "/") {
+			const end = text.indexOf("\n", index);
+			skip(end === -1 ? text.length : end);
+		} else if (char === "/" && next === "*") {
+			const end = text.indexOf("*/", index + 2);
+			skip(end === -1 ? text.length : end + 2);
+		} else if (char === "\"" || char === "'" || char === "`") {
+			let end = index + 1;
+			while (end < text.length && text[end] !== char) {
+				if (text[end] === "\\") end += 1;
+				if (char !== "`" && text[end] === "\n") break;
+				end += 1;
+			}
+			skip(text[end] === char ? end + 1 : Math.min(end, text.length));
+		} else index += 1;
+	}
+	if (index > start) ranges.push([start, index]);
+	return ranges;
+}
+function applyEdits(text, edits) {
+	let out = "";
+	let cursor = 0;
+	for (const edit of [...edits].sort((a, b) => a.start - b.start)) {
+		if (edit.start < cursor) continue;
+		out += text.slice(cursor, edit.start) + edit.text;
+		cursor = edit.end;
+	}
+	return out + text.slice(cursor);
+}
+const escapeRegExp = (value) => value.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function inCode(ranges, index) {
+	let low = 0;
+	let high = ranges.length - 1;
+	while (low <= high) {
+		const middle = low + high >> 1;
+		const [start, end] = ranges[middle];
+		if (index < start) high = middle - 1;
+		else if (index >= end) low = middle + 1;
+		else return true;
+	}
+	return false;
+}
+const OPENING = "({[";
+const CLOSING = ")}]";
+/** Matches of `pattern` that start in code. */
+function codeMatches(text, pattern, ranges) {
+	return [...text.matchAll(pattern)].filter((match) => inCode(ranges, match.index));
+}
+const IMPORT = /\b(import|export)\s+(type\s+)?\{([^}]*)\}\s*from\s*(["'])better-supabase(?:\/[\w./-]*)?\4/g;
+function renameImports(text, renames) {
+	const ranges = codeRanges(text);
+	const locals = /* @__PURE__ */ new Set();
+	const edits = [];
+	for (const match of codeMatches(text, IMPORT, ranges)) {
+		const list = match[3];
+		const listStart = match.index + match[0].indexOf("{") + 1;
+		const renamed = list.replaceAll(/(\btype\s+)?([\w$]+)(\s+as\s+[\w$]+)?/g, (spec, type, name, alias) => {
+			const to = renames[name];
+			if (to === void 0) return spec;
+			if (alias === void 0 && match[1] === "import") locals.add(name);
+			return `${type ?? ""}${to}${alias ?? ""}`;
+		});
+		if (renamed !== list) edits.push({
+			start: listStart,
+			end: listStart + list.length,
+			text: renamed
+		});
+	}
+	return {
+		text: applyEdits(text, edits),
+		locals
+	};
+}
+function renameIdentifiers(text, renames) {
+	if (renames.size === 0) return text;
+	const ranges = codeRanges(text);
+	const names = [...renames.keys()].map(escapeRegExp).join("|");
+	return applyEdits(text, codeMatches(text, new RegExp(`(?<![\\w$.])(?:${names})(?![\\w$])`, "g"), ranges).map((match) => ({
+		start: match.index,
+		end: match.index + match[0].length,
+		text: renames.get(match[0])
+	})));
+}
+function renameMembers(text, members) {
+	const ranges = codeRanges(text);
+	return applyEdits(text, members.flatMap((member) => codeMatches(text, new RegExp(`\\.${escapeRegExp(member.from)}(?![\\w$])${member.notCalled === true ? "(?!\\s*\\()" : ""}`, "g"), ranges).map((match) => ({
+		start: match.index,
+		end: match.index + match[0].length,
+		text: `.${member.to}`
+	}))));
+}
+function renameProps(text, props) {
+	const ranges = codeRanges(text);
+	const edits = [];
+	for (const prop of props) {
+		const tag = new RegExp(`<${escapeRegExp(prop.component)}(?![\\w$.])`, "g");
+		for (const match of codeMatches(text, tag, ranges)) {
+			let depth = 0;
+			for (let index = match.index + match[0].length; index < text.length; index += 1) {
+				if (!inCode(ranges, index)) continue;
+				const char = text[index];
+				if (char === "{") depth += 1;
+				else if (char === "}") depth -= 1;
+				else if (char === ">" && depth === 0) break;
+				if (depth === 0 && /\s/.test(text[index - 1] ?? "") && text.startsWith(`${prop.from}=`, index)) edits.push({
+					start: index,
+					end: index + prop.from.length,
+					text: prop.to
+				});
+			}
+		}
+	}
+	return applyEdits(text, edits);
+}
+/** The index after the bracket that closes the one at `open`, in code only. */
+function closing(text, open, ranges) {
+	let depth = 0;
+	for (let index = open; index < text.length; index += 1) {
+		if (!inCode(ranges, index)) continue;
+		const char = text[index];
+		if (OPENING.includes(char)) depth += 1;
+		else if (CLOSING.includes(char)) {
+			depth -= 1;
+			if (depth === 0) return index + 1;
+		}
+	}
+	return text.length;
+}
+/** Calls `visit(index, depth)` for each code character from `open` to its closing bracket. */
+function walkBrackets(text, open, ranges, visit) {
+	const end = closing(text, open, ranges);
+	let depth = 0;
+	for (let index = open; index < end; index += 1) {
+		if (!inCode(ranges, index)) continue;
+		const char = text[index];
+		if (OPENING.includes(char)) depth += 1;
+		else if (CLOSING.includes(char)) depth -= 1;
+		visit(index, depth, char);
+	}
+}
+/** Where `key` is a top-level key of the object literal at `open`. */
+function topLevelKeys(text, open, key, ranges) {
+	const keys = [];
+	let previous = "";
+	walkBrackets(text, open, ranges, (index, depth, char) => {
+		if (depth === 1 && (previous === "{" || previous === ",") && text.startsWith(key, index) && !/[\w$]/.test(text[index + key.length] ?? "")) {
+			const after = /^\s*(\S)/.exec(text.slice(index + key.length))?.[1];
+			if (after === ":") keys.push({
+				index,
+				shorthand: false
+			});
+			else if (after === "," || after === "}") keys.push({
+				index,
+				shorthand: true
+			});
+		}
+		if (depth === 1 && !/\s/.test(char)) previous = char;
+	});
+	return keys;
+}
+function renameOptions(text, options) {
+	const ranges = codeRanges(text);
+	const edits = [];
+	for (const option of options) {
+		const call = new RegExp(`(?<![\\w$.])${escapeRegExp(option.call)}\\s*(?:<[^>]*>)?\\s*\\(`, "g");
+		for (const match of codeMatches(text, call, ranges)) {
+			const objects = [];
+			walkBrackets(text, match.index + match[0].length - 1, ranges, (index, depth, char) => {
+				if (depth === 2 && char === "{") objects.push(index);
+			});
+			for (const object of objects) for (const { index, shorthand } of topLevelKeys(text, object, option.from, ranges)) edits.push({
+				start: index,
+				end: index + option.from.length,
+				text: shorthand ? `${option.to}: ${option.from}` : option.to
+			});
+		}
+	}
+	return applyEdits(text, edits);
+}
+/** Applies one codemod to a source file. */
+function applyCodemod(codemod, source) {
+	let text = source;
+	if (codemod.imports) {
+		const imported = renameImports(text, codemod.imports);
+		text = renameIdentifiers(imported.text, new Map([...imported.locals].map((name) => [name, codemod.imports[name]])));
+	}
+	if (codemod.members) text = renameMembers(text, codemod.members);
+	if (codemod.props) text = renameProps(text, codemod.props);
+	if (codemod.options) text = renameOptions(text, codemod.options);
+	const review = (codemod.review ?? []).flatMap((hint) => text.split("\n").flatMap((line, index) => hint.pattern.test(line) ? [{
+		line: index + 1,
+		message: hint.message
+	}] : []));
+	return {
+		text,
+		review
+	};
+}
+//#endregion
+//#region src/cli/commands/codemod.ts
+const CODEMOD_ARGS = {
+	name: {
+		type: "positional",
+		required: false,
+		description: "The codemod (0.4 or 0.5), then the files or directories to rewrite (default: the project)"
+	},
+	"dry-run": {
+		type: "boolean",
+		description: "Show the changes without writing them"
+	}
+};
+const SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
+	".ts",
+	".tsx",
+	".mts",
+	".cts",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs"
+]);
+const SKIPPED_DIRS = /* @__PURE__ */ new Set([
+	"node_modules",
+	".git",
+	".next",
+	".turbo",
+	".vercel",
+	"dist",
+	"build",
+	"coverage"
+]);
+/** Source files under `path`, skipping dependencies, build output and `.d.ts` files. */
+async function sourceFiles(path) {
+	const info = await stat(path).catch(() => void 0);
+	if (!info) return [];
+	if (info.isFile()) return [path];
+	const files = [];
+	for (const entry of await readdir(path, { withFileTypes: true })) {
+		const full = join(path, entry.name);
+		if (entry.isDirectory()) {
+			if (!SKIPPED_DIRS.has(entry.name)) files.push(...await sourceFiles(full));
+		} else if (SOURCE_EXTENSIONS.has(extname(entry.name)) && !entry.name.endsWith(".d.ts")) files.push(full);
+	}
+	return files.sort();
+}
+async function runCodemod(config, args, paint = plain) {
+	const [name, ...paths] = args._;
+	const names = Object.entries(CODEMODS).map(([key, codemod]) => `  ${key.padEnd(5)} ${codemod.description}`).join("\n");
+	if (name === void 0) return {
+		code: 2,
+		error: `Name a codemod:\n${names}`
+	};
+	const codemod = CODEMODS[name];
+	if (!codemod) return {
+		code: 2,
+		error: `Unknown codemod "${name}". Codemods:\n${names}`
+	};
+	const roots = (paths.length > 0 ? paths : ["."]).map((path) => resolve(config.root, path));
+	const files = [...new Set((await Promise.all(roots.map(sourceFiles))).flat())];
+	const dryRun = args["dry-run"] === true;
+	const changed = [];
+	const diffs = [];
+	const review = [];
+	for (const file of files) {
+		const source = await readFile(file, "utf8");
+		const result = applyCodemod(codemod, source);
+		const path = relative(config.root, file);
+		review.push(...result.review.map((hint) => ({
+			file: path,
+			...hint
+		})));
+		if (result.text === source) continue;
+		changed.push(path);
+		if (dryRun) diffs.push(fileDiff(path, source, result.text, paint));
+		else await writeIfChanged(file, result.text);
+	}
+	const lines = [...diffs, changed.length === 0 ? `Nothing to change in ${String(files.length)} files.` : `${dryRun ? "Would update" : "Updated"} ${String(changed.length)} of ${String(files.length)} files:\n${changed.map((path) => `  ${path}`).join("\n")}`];
+	if (review.length > 0) lines.push("", "Check these by hand:", ...review.map((hint) => `  ${hint.file}:${String(hint.line)}: ${hint.message}`));
+	return {
+		code: 0,
+		output: lines.join("\n"),
+		data: {
+			codemod: codemod.name,
+			dryRun,
+			changed,
+			review
+		}
+	};
+}
+const codemodCommand = defineCliCommand({
+	meta: {
+		name: "codemod",
+		description: "Rewrites imports and calls for renamed better-supabase APIs"
+	},
+	args: CODEMOD_ARGS,
+	run: (args, { config, io }) => runCodemod(config, args, painter(io.color))
+});
+//#endregion
+export { codemodCommand };