@tailor-platform/sdk-codemod 0.1.0

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

@@ -0,0 +1,120 @@
+import { Lang, parse } from "@ast-grep/napi";
+//#region codemods/v2/define-generators-to-plugins/scripts/transform.ts
+/**
+* Known plugin mappings from package name to plugin function/import.
+*/
+const PLUGIN_MAP = {
+	"@tailor-platform/kysely-type": {
+		functionName: "kyselyTypePlugin",
+		importPath: "@tailor-platform/sdk/plugin/kysely-type"
+	},
+	"@tailor-platform/seed": {
+		functionName: "seedPlugin",
+		importPath: "@tailor-platform/sdk/plugin/seed"
+	},
+	"@tailor-platform/enum-constants": {
+		functionName: "enumConstantsPlugin",
+		importPath: "@tailor-platform/sdk/plugin/enum-constants"
+	},
+	"@tailor-platform/file-utils": {
+		functionName: "fileUtilsPlugin",
+		importPath: "@tailor-platform/sdk/plugin/file-utils"
+	}
+};
+/**
+* Transform defineGenerators() to definePlugins():
+*
+* 1. Rename `defineGenerators` → `definePlugins` in import and call
+* 2. Transform tuple arguments `["pkg-name", config]` → `pluginFn(config)`
+* 3. Add plugin imports from their respective SDK paths
+* @param source - Source code to transform
+* @returns Transformed source or null if no changes needed
+*/
+function transform(source) {
+	const tree = parse(Lang.TypeScript, source).root();
+	if (!source.includes("defineGenerators")) return null;
+	if (!source.includes("@tailor-platform/sdk")) return null;
+	const edits = [];
+	const importsToAdd = /* @__PURE__ */ new Map();
+	const callNodes = tree.findAll({ rule: { pattern: "defineGenerators($$$ARGS)" } });
+	let totalArgs = 0;
+	let migratedArgs = 0;
+	for (const callNode of callNodes) {
+		const args = callNode.getMultipleMatches("ARGS");
+		for (const arg of args) {
+			if (!arg.isNamed() || arg.kind() === "comment") continue;
+			totalArgs++;
+			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, "")];
+					if (mapping) {
+						migratedArgs++;
+						importsToAdd.set(mapping.importPath, mapping.functionName);
+						const configNodes = children.slice(1);
+						const configText = configNodes.length > 0 ? configNodes.map((c) => c.text()).join(", ") : "";
+						const replacement = `${mapping.functionName}(${configText})`;
+						edits.push(arg.replace(replacement));
+					}
+				}
+			}
+		}
+	}
+	if (totalArgs > 0 && migratedArgs < totalArgs) return null;
+	const callIdentifiers = tree.findAll({ rule: {
+		pattern: "defineGenerators",
+		kind: "identifier",
+		inside: { kind: "call_expression" }
+	} });
+	for (const id of callIdentifiers) edits.push(id.replace("definePlugins"));
+	const sdkImportStatements = tree.findAll({ rule: {
+		kind: "import_statement",
+		has: {
+			kind: "string",
+			regex: "^[\"']@tailor-platform/sdk[\"']$"
+		}
+	} });
+	const hasDefinePlugins = sdkImportStatements.some((stmt) => stmt.findAll({ rule: { kind: "import_specifier" } }).some((s) => s.children().some((c) => c.kind() === "identifier" && c.text() === "definePlugins")));
+	for (const importStmt of sdkImportStatements) {
+		const specifiers = importStmt.findAll({ rule: { kind: "import_specifier" } });
+		for (const spec of specifiers) {
+			const identNode = spec.children().find((c) => c.kind() === "identifier" && c.text() === "defineGenerators");
+			if (!identNode) continue;
+			if (hasDefinePlugins) {
+				const specText = spec.text();
+				const importText = importStmt.text();
+				const idx = importText.indexOf(specText);
+				if (idx !== -1) {
+					const afterSpec = importText.slice(idx + specText.length);
+					const beforeSpec = importText.slice(0, idx);
+					let removeFrom = idx;
+					let removeTo = idx + specText.length;
+					if (afterSpec.match(/^\s*,/)) removeTo = idx + specText.length + (afterSpec.match(/^\s*,\s*/)[0]?.length ?? 0);
+					else if (beforeSpec.match(/,\s*$/)) removeFrom = idx - (beforeSpec.match(/,\s*$/)[0]?.length ?? 0);
+					const cleaned = importText.slice(0, removeFrom) + importText.slice(removeTo);
+					edits.push(importStmt.replace(cleaned));
+				}
+			} else edits.push(identNode.replace("definePlugins"));
+		}
+	}
+	if (edits.length === 0) return null;
+	let result = tree.commitEdits(edits);
+	if (importsToAdd.size > 0) {
+		const importLines = [];
+		for (const [importPath, functionName] of importsToAdd) {
+			const line = `import { ${functionName} } from "${importPath}";`;
+			if (new RegExp(`import\\s*\\{[^}]*\\b${functionName}\\b[^}]*\\}`, "m").test(result)) continue;
+			importLines.push(line);
+		}
+		importLines.sort();
+		if (importLines.length === 0) return result;
+		const match = /^(import\s+.*from\s+["']@tailor-platform\/sdk["'];?)$/m.exec(result);
+		if (match) {
+			const insertPos = (match.index ?? 0) + match[0].length;
+			result = result.slice(0, insertPos) + "\n" + importLines.join("\n") + result.slice(insertPos);
+		} else result = importLines.join("\n") + "\n" + result;
+	}
+	return result;
+}
+//#endregion
+export { transform as default };

package/dist/index.js

@@ -0,0 +1,198 @@
+#!/usr/bin/env node
+import * as url from "node:url";
+import { fileURLToPath } from "node:url";
+import * as path from "pathe";
+import { arg, defineCommand, runMain } from "politty";
+import { readPackageJSON } from "pkg-types";
+import { z } from "zod";
+import { gte, lt, valid } from "semver";
+import * as fs from "node:fs";
+import { glob } from "node:fs/promises";
+import chalk from "chalk";
+import { structuredPatch } from "diff";
+import picomatch from "picomatch";
+//#region src/registry.ts
+const CODEMODS_ROOT = path.resolve(path.dirname(url.fileURLToPath(import.meta.url)), "codemods");
+const allCodemods = [{
+	id: "v2/define-generators-to-plugins",
+	name: "defineGenerators → definePlugins",
+	description: "Migrate defineGenerators() tuple syntax to definePlugins() with explicit plugin imports",
+	since: "1.0.0",
+	until: "2.0.0",
+	scriptPath: "v2/define-generators-to-plugins/scripts/transform.js"
+}];
+/**
+* Resolve the absolute path to a codemod script.
+* @param scriptPath - Relative path from the codemods root
+* @returns Absolute path to the script file
+*/
+function resolveCodemodScript(scriptPath) {
+	return path.resolve(CODEMODS_ROOT, scriptPath);
+}
+/**
+* Get codemod packages applicable for a version range.
+* A codemod applies when: since <= fromVersion < until <= toVersion
+* @param fromVersion - Current SDK version (semver)
+* @param toVersion - Target SDK version (semver)
+* @returns Array of applicable codemod packages in registration order
+*/
+function getApplicableCodemods(fromVersion, toVersion) {
+	if (!valid(fromVersion)) throw new Error(`Invalid fromVersion: ${fromVersion}`);
+	if (!valid(toVersion)) throw new Error(`Invalid toVersion: ${toVersion}`);
+	return allCodemods.filter((codemod) => gte(fromVersion, codemod.since) && lt(fromVersion, codemod.until) && gte(toVersion, codemod.until));
+}
+//#endregion
+//#region src/runner.ts
+/** Default file patterns for TypeScript files. */
+const DEFAULT_FILE_PATTERNS = ["**/*.{ts,tsx,mts,cts}"];
+/** Directory names always excluded from file scanning. */
+const EXCLUDE_DIRS = new Set([
+	"node_modules",
+	"dist",
+	".git"
+]);
+/**
+* Print a colorized unified diff for a single file to stderr.
+* @param filePath - Absolute path to the file
+* @param before - Original content
+* @param after - Transformed content
+*/
+function printDiff(filePath, before, after) {
+	const patch = structuredPatch(filePath, filePath, before, after, "", "", { context: 3 });
+	if (patch.hunks.length === 0) return;
+	process.stderr.write(`\n${chalk.bold(`--- ${filePath}`)}\n`);
+	process.stderr.write(`${chalk.bold(`+++ ${filePath}`)}\n`);
+	for (const hunk of patch.hunks) {
+		process.stderr.write(chalk.cyan(`@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@\n`));
+		for (const line of hunk.lines) if (line.startsWith("+")) process.stderr.write(`${chalk.green(line)}\n`);
+		else if (line.startsWith("-")) process.stderr.write(`${chalk.red(line)}\n`);
+		else process.stderr.write(`${line}\n`);
+	}
+}
+/**
+* Load a transform module from a TypeScript file path.
+* Expects the module to have a default export that is a TransformFn.
+* @param scriptPath - Absolute path to the transform script
+* @returns The transform function
+*/
+async function loadTransform(scriptPath) {
+	const mod = await import(url.pathToFileURL(scriptPath).href);
+	if (typeof mod.default !== "function") throw new Error(`Transform at ${scriptPath} does not have a default export function`);
+	return mod.default;
+}
+/**
+* Run multiple codemods on a project directory using in-memory chaining.
+* Each file is processed through all transforms whose filePatterns match it.
+* Later transforms see earlier transforms' output — even in dry-run mode.
+*
+* In dry-run mode, colorized diffs are printed to stderr.
+* @param codemods - Codemod packages to run (with resolved script paths)
+* @param targetPath - Project directory to transform
+* @param dryRun - Whether to preview changes without writing
+* @returns Combined result of all codemod executions
+*/
+async function runCodemods(codemods, targetPath, dryRun) {
+	const loaded = [];
+	for (const { codemod, scriptPath } of codemods) {
+		const patterns = codemod.filePatterns ?? DEFAULT_FILE_PATTERNS;
+		loaded.push({
+			id: codemod.id,
+			transform: await loadTransform(scriptPath),
+			matches: picomatch(patterns)
+		});
+	}
+	const allPatterns = /* @__PURE__ */ new Set();
+	for (const { codemod } of codemods) for (const p of codemod.filePatterns ?? DEFAULT_FILE_PATTERNS) allPatterns.add(p);
+	const filesModified = [];
+	const warnings = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const pattern of allPatterns) for await (const relative of glob(pattern, {
+		cwd: targetPath,
+		exclude: (name) => EXCLUDE_DIRS.has(name)
+	})) {
+		const absolute = path.resolve(targetPath, relative);
+		if (seen.has(absolute)) continue;
+		seen.add(absolute);
+		let original;
+		try {
+			original = await fs.promises.readFile(absolute, "utf-8");
+		} catch {
+			continue;
+		}
+		let current = original;
+		const matchedRules = [];
+		for (const { id, transform, matches } of loaded) {
+			if (!matches(relative)) continue;
+			matchedRules.push(id);
+			const result = await transform(current, absolute);
+			if (result != null) current = result;
+		}
+		if (current !== original) {
+			filesModified.push(absolute);
+			if (dryRun) printDiff(absolute, original, current);
+			else await fs.promises.writeFile(absolute, current, "utf-8");
+		} else if (matchedRules.length > 0 && original.includes("defineGenerators")) warnings.push(`${relative}: contains defineGenerators but was not migrated automatically (matched rules: ${matchedRules.join(", ")}). Manual migration may be needed.`);
+	}
+	return {
+		changed: filesModified.length > 0,
+		filesModified,
+		warnings
+	};
+}
+//#endregion
+//#region src/index.ts
+const packageJson = await readPackageJSON(path.dirname(fileURLToPath(import.meta.url)) + "/..");
+runMain(defineCommand({
+	name: packageJson.name ?? "sdk-codemod",
+	description: packageJson.description ?? "Codemod runner for Tailor Platform SDK upgrades",
+	args: z.object({
+		from: arg(z.string(), { description: "Source SDK version (the version before upgrade)" }),
+		to: arg(z.string(), { description: "Target SDK version (the version after upgrade)" }),
+		target: arg(z.string().default("."), { description: "Project directory to transform" }),
+		"dry-run": arg(z.boolean().default(false), {
+			alias: "d",
+			description: "Preview changes without modifying files"
+		})
+	}).strict(),
+	run: async (args) => {
+		const targetPath = path.resolve(args.target);
+		const dryRun = args["dry-run"];
+		const codemods = getApplicableCodemods(args.from, args.to);
+		const output = {
+			codemodsApplied: 0,
+			codemodsSkipped: 0,
+			filesModified: [],
+			warnings: [],
+			errors: []
+		};
+		if (codemods.length === 0) {
+			process.stdout.write(JSON.stringify(output) + "\n");
+			return;
+		}
+		const codemodEntries = codemods.map((codemod) => ({
+			codemod,
+			scriptPath: resolveCodemodScript(codemod.scriptPath)
+		}));
+		for (const { codemod } of codemodEntries) process.stderr.write(`Running: ${codemod.name} - ${codemod.description}\n`);
+		try {
+			const result = await runCodemods(codemodEntries, targetPath, dryRun);
+			output.codemodsApplied = result.changed ? codemods.length : 0;
+			output.codemodsSkipped = result.changed ? 0 : codemods.length;
+			output.filesModified = result.filesModified;
+			output.warnings = result.warnings;
+			if (result.changed) process.stderr.write(`  ${result.filesModified.length} file(s) modified\n`);
+			else process.stderr.write("  No changes needed\n");
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			output.errors.push({
+				codemodId: "pipeline",
+				message
+			});
+			process.stderr.write(`  Failed: ${message}\n`);
+		}
+		process.stdout.write(JSON.stringify(output) + "\n");
+		if (output.errors.length > 0) process.exit(1);
+	}
+}), { version: packageJson.version });
+//#endregion
+export {};

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@tailor-platform/sdk-codemod",
+  "version": "0.1.0",
+  "description": "Codemod runner for Tailor Platform SDK upgrades",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tailor-platform/sdk.git",
+    "directory": "packages/sdk-codemod"
+  },
+  "bin": "dist/index.js",
+  "files": [
+    "CHANGELOG.md",
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "type": "module",
+  "scripts": {
+    "build": "tsdown",
+    "lint": "oxlint . && eslint --cache .",
+    "lint:fix": "oxlint --fix . && eslint --cache --fix .",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest",
+    "prepublish": "pnpm run build",
+    "publint": "publint --strict"
+  },
+  "dependencies": {
+    "@ast-grep/napi": "^0.42.0",
+    "chalk": "5.6.2",
+    "diff": "8.0.4",
+    "pathe": "2.0.3",
+    "picomatch": "4.0.4",
+    "pkg-types": "2.3.0",
+    "politty": "0.4.12",
+    "semver": "7.7.4",
+    "zod": "4.3.6"
+  },
+  "devDependencies": {
+    "@eslint/js": "10.0.1",
+    "@types/node": "24.12.0",
+    "@types/picomatch": "4.0.2",
+    "@types/semver": "7.7.1",
+    "eslint": "10.1.0",
+    "eslint-plugin-oxlint": "1.57.0",
+    "oxlint": "1.57.0",
+    "tsdown": "0.21.7",
+    "typescript": "5.9.3",
+    "typescript-eslint": "8.57.2",
+    "vitest": "4.1.2"
+  }
+}