@turbo/codemod 1.7.1-canary.1 → 1.7.1-canary.2

package/dist/transforms/add-package-manager.js

@@ -23,20 +23,25 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/transforms/add-package-manager.ts
 var add_package_manager_exports = {};
 __export(add_package_manager_exports, {
-  default: () => addPackageManager
+  default: () => add_package_manager_default,
+  transformer: () => transformer
 });
 module.exports = __toCommonJS(add_package_manager_exports);
-var import_path2 = __toESM(require("path"));
+var import_path3 = __toESM(require("path"));
+var import_fs_extra2 = __toESM(require("fs-extra"));
 
-// src/getWorkspaceImplementation.ts
+// src/utils/getPackageManager.ts
 var import_find_up = __toESM(require("find-up"));
 var import_path = __toESM(require("path"));
 var cache = {};
-function getWorkspaceImplementationAndLockFile(cwd) {
+function getPackageManager({
+  directory
+}) {
+  const cwd = directory || process.cwd();
   if (cache[cwd]) {
     return cache[cwd];
   }
-  const lockFile = import_find_up.default.sync(["yarn.lock", "pnpm-workspace.yaml", "package-lock.json"], {
+  const lockFile = import_find_up.default.sync(["yarn.lock", "pnpm-lock.yaml", "package-lock.json"], {
     cwd
   });
   if (!lockFile) {
@@ -44,126 +49,303 @@ function getWorkspaceImplementationAndLockFile(cwd) {
   }
   switch (import_path.default.basename(lockFile)) {
     case "yarn.lock":
-      cache[cwd] = {
-        implementation: "yarn",
-        lockFile
-      };
+      cache[cwd] = "yarn";
       break;
-    case "pnpm-workspace.yaml":
-      cache[cwd] = {
-        implementation: "pnpm",
-        lockFile
-      };
+    case "pnpm-lock.yaml":
+      cache[cwd] = "pnpm";
       break;
     case "package-lock.json":
-      cache[cwd] = {
-        implementation: "npm",
-        lockFile
-      };
+      cache[cwd] = "npm";
       break;
   }
   return cache[cwd];
 }
-function getWorkspaceImplementation(cwd) {
-  var _a;
-  return (_a = getWorkspaceImplementationAndLockFile(cwd)) == null ? void 0 : _a.implementation;
-}
 
-// src/getPackageManagerVersion.ts
+// src/utils/getPackageManagerVersion.ts
 var import_child_process = require("child_process");
-var getPackageManagerVersion = (ws) => {
-  switch (ws) {
+function getPackageManagerVersion(packageManager, root) {
+  switch (packageManager) {
     case "yarn":
-      return (0, import_child_process.execSync)("yarn --version").toString().trim();
+      return (0, import_child_process.execSync)("yarn --version", { cwd: root }).toString().trim();
     case "pnpm":
-      return (0, import_child_process.execSync)("pnpm --version").toString().trim();
+      return (0, import_child_process.execSync)("pnpm --version", { cwd: root }).toString().trim();
     case "npm":
-      return (0, import_child_process.execSync)("npm --version").toString().trim();
-    default:
-      throw new Error(`${ws} is not supported`);
+      return (0, import_child_process.execSync)("npm --version", { cwd: root }).toString().trim();
   }
-};
+}
 
-// src/transforms/add-package-manager.ts
-var import_fs_extra = __toESM(require("fs-extra"));
-var import_chalk2 = __toESM(require("chalk"));
+// src/runner/Runner.ts
+var import_chalk3 = __toESM(require("chalk"));
 
-// src/logger.ts
+// src/runner/FileTransform.ts
 var import_chalk = __toESM(require("chalk"));
-function skip(...args) {
-  console.log(import_chalk.default.yellow.inverse(` SKIP `), ...args);
-}
-function error(...args) {
-  console.log(import_chalk.default.red.inverse(` ERROR `), ...args);
-}
-function ok(...args) {
-  console.log(import_chalk.default.green.inverse(` OK `), ...args);
-}
-
-// src/transforms/add-package-manager.ts
-function addPackageManager(files, flags) {
-  if (files.length === 1) {
-    const dir = files[0];
-    const root = import_path2.default.resolve(process.cwd(), dir);
-    console.log(`Set "packageManager" key in root "package.json" file...`);
-    const packageManager = getWorkspaceImplementation(root);
-    if (!packageManager) {
-      error(`Unable to determine package manager for ${dir}`);
-      process.exit(1);
-    }
-    const version = getPackageManagerVersion(packageManager);
-    const pkgManagerString = `${packageManager}@${version}`;
-    const rootPackageJsonPath = import_path2.default.join(root, "package.json");
-    const rootPackageJson = import_fs_extra.default.readJsonSync(rootPackageJsonPath);
-    const allWorkspaces = [
-      {
-        name: "package.json",
-        path: root,
-        packageJson: {
-          ...rootPackageJson,
-          packageJsonPath: rootPackageJsonPath
+var import_diff = require("diff");
+var import_fs_extra = __toESM(require("fs-extra"));
+var import_os = __toESM(require("os"));
+var import_path2 = __toESM(require("path"));
+var FileTransform = class {
+  constructor(args) {
+    this.changes = [];
+    this.filePath = args.filePath;
+    this.rootPath = args.rootPath;
+    this.after = args.after;
+    this.error = args.error;
+    if (args.before === void 0) {
+      try {
+        if (import_path2.default.extname(args.filePath) === ".json") {
+          this.before = import_fs_extra.default.readJsonSync(args.filePath);
+        } else {
+          this.before = import_fs_extra.default.readFileSync(args.filePath);
         }
+      } catch (err) {
+        this.before = "";
       }
-    ];
-    let modifiedCount = 0;
-    let skippedCount = 0;
-    let errorCount = 0;
-    let unmodifiedCount = allWorkspaces.length;
-    console.log(`Found ${unmodifiedCount} files for modification...`);
-    for (const workspace of allWorkspaces) {
-      const { packageJsonPath, ...pkgJson } = workspace.packageJson;
-      const relPackageJsonPath = import_path2.default.relative(root, packageJsonPath);
-      try {
-        if (pkgJson.packageManager === pkgManagerString) {
-          skip(relPackageJsonPath, import_chalk2.default.dim(`(already set to ${pkgManagerString})`));
+    } else if (args.before === null) {
+      this.before = "";
+    } else {
+      this.before = args.before;
+    }
+    if (args.after) {
+      if (typeof this.before === "object" || typeof args.after === "object") {
+        this.changes = (0, import_diff.diffJson)(this.before, args.after);
+      } else {
+        this.changes = (0, import_diff.diffLines)(this.before, args.after);
+      }
+    } else {
+      this.changes = [];
+    }
+  }
+  fileName() {
+    return import_path2.default.relative(this.rootPath, this.filePath);
+  }
+  write() {
+    if (this.after) {
+      if (typeof this.after === "object") {
+        import_fs_extra.default.writeJsonSync(this.filePath, this.after, { spaces: 2 });
+      } else {
+        import_fs_extra.default.writeFileSync(this.filePath, this.after);
+      }
+    }
+  }
+  additions() {
+    return this.changes.filter((c) => c.added).length;
+  }
+  deletions() {
+    return this.changes.filter((c) => c.removed).length;
+  }
+  hasChanges() {
+    return this.additions() > 0 || this.deletions() > 0;
+  }
+  log(args) {
+    if (args.diff) {
+      this.changes.forEach((part) => {
+        if (part.added) {
+          process.stdout.write(import_chalk.default.green(part.value));
+        } else if (part.removed) {
+          process.stdout.write(import_chalk.default.red(part.value));
         } else {
-          const newJson = { ...pkgJson, packageManager: pkgManagerString };
-          if (flags.print) {
-            console.log(JSON.stringify(newJson, null, 2));
-          }
-          if (!flags.dry) {
-            import_fs_extra.default.writeJsonSync(packageJsonPath, newJson, {
-              spaces: 2
-            });
-            ok(relPackageJsonPath);
-            modifiedCount++;
-            unmodifiedCount--;
-          } else {
-            skip(relPackageJsonPath, import_chalk2.default.dim(`(dry run)`));
+          process.stdout.write(import_chalk.default.dim(part.value));
+        }
+      });
+      console.log(import_os.default.EOL);
+    } else {
+      console.log(this.after);
+    }
+  }
+};
+
+// src/utils/logger.ts
+var import_chalk2 = __toESM(require("chalk"));
+var Logger = class {
+  constructor(args) {
+    this.transform = args.transformer;
+    this.dry = args.dry;
+  }
+  modified(...args) {
+    console.log(import_chalk2.default.green(` MODIFIED `), ...args, this.dry ? import_chalk2.default.dim(`(dry run)`) : "");
+  }
+  unchanged(...args) {
+    console.log(import_chalk2.default.gray(` UNCHANGED `), ...args, this.dry ? import_chalk2.default.dim(`(dry run)`) : "");
+  }
+  skipped(...args) {
+    console.log(import_chalk2.default.yellow(` SKIPPED `), ...args, this.dry ? import_chalk2.default.dim(`(dry run)`) : "");
+  }
+  error(...args) {
+    console.log(import_chalk2.default.red(` ERROR `), ...args, this.dry ? import_chalk2.default.dim(`(dry run)`) : "");
+  }
+  info(...args) {
+    console.log(import_chalk2.default.bold(` INFO `), ...args, this.dry ? import_chalk2.default.dim(`(dry run)`) : "");
+  }
+};
+
+// src/runner/Runner.ts
+var Runner = class {
+  constructor(options) {
+    this.modifications = {};
+    this.transform = options.transformer;
+    this.rootPath = options.rootPath;
+    this.dry = options.dry;
+    this.print = options.print;
+    this.logger = new Logger(options);
+  }
+  abortTransform(args) {
+    this.logger.error(args.reason);
+    return {
+      fatalError: new Error(args.reason),
+      changes: args.changes || {}
+    };
+  }
+  modifyFile(args) {
+    this.modifications[args.filePath] = new FileTransform({
+      rootPath: this.rootPath,
+      ...args
+    });
+  }
+  finish() {
+    const results = { changes: {} };
+    Object.keys(this.modifications).forEach((filePath) => {
+      const mod = this.modifications[filePath];
+      const result = {
+        action: "unchanged",
+        additions: mod.additions(),
+        deletions: mod.deletions()
+      };
+      if (mod.hasChanges()) {
+        if (this.dry) {
+          result.action = "skipped";
+          this.logger.skipped(import_chalk3.default.dim(mod.fileName()));
+        } else {
+          try {
+            mod.write();
+            result.action = "modified";
+            this.logger.modified(import_chalk3.default.bold(mod.fileName()));
+          } catch (err) {
+            let message = "Unknown error";
+            if (err instanceof Error) {
+              message = err.message;
+            }
+            result.error = new Error(message);
+            result.action = "error";
+            this.logger.error(mod.fileName(), message);
           }
         }
-      } catch (err) {
-        console.error(error);
-        error(relPackageJsonPath);
+        if (this.print) {
+          mod.log({ diff: true });
+        }
+      } else {
+        this.logger.unchanged(import_chalk3.default.dim(mod.fileName()));
       }
+      results.changes[mod.fileName()] = result;
+    });
+    const encounteredError = Object.keys(results.changes).some((fileName) => {
+      return results.changes[fileName].action === "error";
+    });
+    if (encounteredError) {
+      return this.abortTransform({
+        reason: "Encountered an error while transforming files",
+        changes: results.changes
+      });
     }
-    console.log("All done.");
-    console.log("Results:");
-    console.log(import_chalk2.default.red(`${errorCount} errors`));
-    console.log(import_chalk2.default.yellow(`${skippedCount} skipped`));
-    console.log(import_chalk2.default.yellow(`${unmodifiedCount} unmodified`));
-    console.log(import_chalk2.default.green(`${modifiedCount} modified`));
+    return results;
   }
+  static logResults(results) {
+    const changedFiles = Object.keys(results.changes);
+    console.log();
+    if (changedFiles.length > 0) {
+      console.log(import_chalk3.default.bold(`Results:`));
+      const table = {};
+      changedFiles.forEach((fileName) => {
+        var _a;
+        const fileChanges = results.changes[fileName];
+        table[fileName] = {
+          action: fileChanges.action,
+          additions: fileChanges.additions,
+          deletions: fileChanges.deletions,
+          error: ((_a = fileChanges.error) == null ? void 0 : _a.message) || "None"
+        };
+      });
+      console.table(table);
+      console.log();
+    }
+  }
+};
+var Runner_default = Runner;
+
+// src/utils/getTransformerHelpers.ts
+function getTransformerHelpers({
+  transformer: transformer2,
+  rootPath,
+  options
+}) {
+  const utilArgs = {
+    transformer: transformer2,
+    rootPath,
+    ...options
+  };
+  const log = new Logger(utilArgs);
+  const runner = new Runner_default(utilArgs);
+  return { log, runner };
 }
+
+// src/transforms/add-package-manager.ts
+var TRANSFORMER = "add-package-manager";
+var DESCRIPTION = "Set the `packageManager` key in root `package.json` file";
+var INTRODUCED_IN = "1.1.0";
+function transformer({
+  root,
+  options
+}) {
+  const { log, runner } = getTransformerHelpers({
+    transformer: TRANSFORMER,
+    rootPath: root,
+    options
+  });
+  log.info(`Set "packageManager" key in root "package.json" file...`);
+  const packageManager = getPackageManager({ directory: root });
+  if (!packageManager) {
+    return runner.abortTransform({
+      reason: `Unable to determine package manager for ${root}`
+    });
+  }
+  let version = null;
+  try {
+    version = getPackageManagerVersion(packageManager, root);
+  } catch (err) {
+    return runner.abortTransform({
+      reason: `Unable to determine package manager version for ${root}`
+    });
+  }
+  const pkgManagerString = `${packageManager}@${version}`;
+  const rootPackageJsonPath = import_path3.default.join(root, "package.json");
+  const rootPackageJson = import_fs_extra2.default.readJsonSync(rootPackageJsonPath);
+  const allWorkspaces = [
+    {
+      name: "package.json",
+      path: root,
+      packageJson: {
+        ...rootPackageJson,
+        packageJsonPath: rootPackageJsonPath
+      }
+    }
+  ];
+  for (const workspace of allWorkspaces) {
+    const { packageJsonPath, ...pkgJson } = workspace.packageJson;
+    const newJson = { ...pkgJson, packageManager: pkgManagerString };
+    runner.modifyFile({
+      filePath: packageJsonPath,
+      after: newJson
+    });
+  }
+  return runner.finish();
+}
+var transformerMeta = {
+  name: `${TRANSFORMER}: ${DESCRIPTION}`,
+  value: TRANSFORMER,
+  introducedIn: INTRODUCED_IN,
+  transformer
+};
+var add_package_manager_default = transformerMeta;
 // Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {});
+0 && (module.exports = {
+  transformer
+});