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

package/dist/transforms/create-turbo-config.js

@@ -23,82 +23,279 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/transforms/create-turbo-config.ts
 var create_turbo_config_exports = {};
 __export(create_turbo_config_exports, {
-  default: () => createTurboConfig
+  default: () => create_turbo_config_default,
+  transformer: () => transformer
 });
 module.exports = __toCommonJS(create_turbo_config_exports);
+var import_fs_extra2 = __toESM(require("fs-extra"));
+var import_path2 = __toESM(require("path"));
+
+// src/runner/Runner.ts
+var import_chalk3 = __toESM(require("chalk"));
+
+// src/runner/FileTransform.ts
+var import_chalk = __toESM(require("chalk"));
+var import_diff = require("diff");
 var import_fs_extra = __toESM(require("fs-extra"));
-var import_chalk2 = __toESM(require("chalk"));
+var import_os = __toESM(require("os"));
 var import_path = __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_path.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 = "";
+      }
+    } 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_path.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 {
+          process.stdout.write(import_chalk.default.dim(part.value));
+        }
+      });
+      console.log(import_os.default.EOL);
+    } else {
+      console.log(this.after);
+    }
+  }
+};
 
-// src/logger.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/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/transforms/create-turbo-config.ts
-function createTurboConfig(files, flags) {
-  if (files.length === 1) {
-    const dir = files[0];
-    const root = import_path.default.resolve(process.cwd(), dir);
-    console.log(`Migrating "package.json" "turbo" key to "turbo.json" file...`);
-    const turboConfigPath = import_path.default.join(root, "turbo.json");
-    const rootPackageJsonPath = import_path.default.join(root, "package.json");
-    let modifiedCount = 0;
-    let skippedCount = 0;
-    let unmodifiedCount = 2;
-    if (!import_fs_extra.default.existsSync(rootPackageJsonPath)) {
-      error(`No package.json found at ${root}. Is the path correct?`);
-      process.exit(1);
-    }
-    const rootPackageJson = import_fs_extra.default.readJsonSync(rootPackageJsonPath);
-    if (import_fs_extra.default.existsSync(turboConfigPath)) {
-      skip("turbo.json", import_chalk2.default.dim("(already exists)"));
-      skip("package.json", import_chalk2.default.dim("(skipped)"));
-      skippedCount += 2;
-    } else if (rootPackageJson.hasOwnProperty("turbo")) {
-      const { turbo: turboConfig, ...remainingPkgJson } = rootPackageJson;
-      if (flags.dry) {
-        if (flags.print) {
-          console.log(JSON.stringify(turboConfig, null, 2));
+// 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);
+          }
         }
-        skip("turbo.json", import_chalk2.default.dim("(dry run)"));
-        if (flags.print) {
-          console.log(JSON.stringify(remainingPkgJson, null, 2));
+        if (this.print) {
+          mod.log({ diff: true });
         }
-        skip("package.json", import_chalk2.default.dim("(dry run)"));
-        skippedCount += 2;
       } else {
-        if (flags.print) {
-          console.log(JSON.stringify(turboConfig, null, 2));
-        }
-        ok("turbo.json", import_chalk2.default.dim("(created)"));
-        import_fs_extra.default.writeJsonSync(turboConfigPath, turboConfig, { spaces: 2 });
-        if (flags.print) {
-          console.log(JSON.stringify(remainingPkgJson, null, 2));
-        }
-        ok("package.json", import_chalk2.default.dim("(remove turbo key)"));
-        import_fs_extra.default.writeJsonSync(rootPackageJsonPath, remainingPkgJson, { spaces: 2 });
-        modifiedCount += 2;
-        unmodifiedCount -= 2;
+        this.logger.unchanged(import_chalk3.default.dim(mod.fileName()));
       }
-    } else {
-      error('"turbo" key does not exist in "package.json"');
-      process.exit(1);
+      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
+      });
+    }
+    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();
     }
-    console.log("All done.");
-    console.log("Results:");
-    console.log(import_chalk2.default.red(`0 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`));
   }
+};
+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/create-turbo-config.ts
+var TRANSFORMER = "create-turbo-config";
+var DESCRIPTION = 'Create the `turbo.json` file from an existing "turbo" key in `package.json`';
+var INTRODUCED_IN = "1.1.0";
+function transformer({
+  root,
+  options
+}) {
+  const { log, runner } = getTransformerHelpers({
+    transformer: TRANSFORMER,
+    rootPath: root,
+    options
+  });
+  log.info(`Migrating "package.json" "turbo" key to "turbo.json" file...`);
+  const turboConfigPath = import_path2.default.join(root, "turbo.json");
+  const rootPackageJsonPath = import_path2.default.join(root, "package.json");
+  if (!import_fs_extra2.default.existsSync(rootPackageJsonPath)) {
+    return runner.abortTransform({
+      reason: `No package.json found at ${root}. Is the path correct?`
+    });
+  }
+  const rootPackageJson = import_fs_extra2.default.readJsonSync(rootPackageJsonPath);
+  let rootTurboJson = null;
+  try {
+    rootTurboJson = import_fs_extra2.default.readJSONSync(turboConfigPath);
+  } catch (err) {
+    rootTurboJson = null;
+  }
+  let transformedPackageJson = rootPackageJson;
+  let transformedTurboConfig = rootTurboJson;
+  if (!rootTurboJson && rootPackageJson["turbo"]) {
+    const { turbo: turboConfig, ...remainingPkgJson } = rootPackageJson;
+    transformedTurboConfig = turboConfig;
+    transformedPackageJson = remainingPkgJson;
+  }
+  runner.modifyFile({
+    filePath: turboConfigPath,
+    after: transformedTurboConfig
+  });
+  runner.modifyFile({
+    filePath: rootPackageJsonPath,
+    after: transformedPackageJson
+  });
+  return runner.finish();
 }
+var transformerMeta = {
+  name: `${TRANSFORMER}: ${DESCRIPTION}`,
+  value: TRANSFORMER,
+  introducedIn: INTRODUCED_IN,
+  transformer
+};
+var create_turbo_config_default = transformerMeta;
 // Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {});
+0 && (module.exports = {
+  transformer
+});