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

package/dist/transforms/migrate-env-var-dependencies.js

@@ -23,31 +23,235 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/transforms/migrate-env-var-dependencies.ts
 var migrate_env_var_dependencies_exports = {};
 __export(migrate_env_var_dependencies_exports, {
-  default: () => migrateEnvVarDependencies,
+  default: () => migrate_env_var_dependencies_default,
   hasLegacyEnvVarDependencies: () => hasLegacyEnvVarDependencies,
   migrateConfig: () => migrateConfig,
   migrateDependencies: () => migrateDependencies,
   migrateGlobal: () => migrateGlobal,
-  migratePipeline: () => migratePipeline
+  migratePipeline: () => migratePipeline,
+  transformer: () => transformer
 });
 module.exports = __toCommonJS(migrate_env_var_dependencies_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_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/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/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/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);
+          }
+        }
+        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
+      });
+    }
+    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/migrate-env-var-dependencies.ts
+var TRANSFORMER = "migrate-env-var-dependencies";
+var DESCRIPTION = 'Migrate environment variable dependencies from "dependsOn" to "env" in `turbo.json`';
+var INTRODUCED_IN = "1.5.0";
 function hasLegacyEnvVarDependencies(config) {
   const dependsOn = [
     config.globalDependencies,
@@ -66,7 +270,7 @@ function migrateDependencies({
   const envDeps = new Set(env);
   const otherDeps = [];
   deps == null ? void 0 : deps.forEach((dep) => {
-    if (dep == null ? void 0 : dep.startsWith("$")) {
+    if (dep.startsWith("$")) {
       envDeps.add(dep.slice(1));
     } else {
       otherDeps.push(dep);
@@ -105,7 +309,7 @@ function migrateGlobal(config) {
     deps: config.globalDependencies
   });
   const migratedConfig = { ...config };
-  if (globalDependencies) {
+  if (globalDependencies && globalDependencies.length) {
     migratedConfig.globalDependencies = globalDependencies;
   } else {
     delete migratedConfig.globalDependencies;
@@ -120,9 +324,9 @@ function migrateGlobal(config) {
 function migrateConfig(config) {
   let migratedConfig = migrateGlobal(config);
   Object.keys(config.pipeline).forEach((pipelineKey) => {
-    var _a, _b;
-    if (migratedConfig.pipeline && ((_a = config.pipeline) == null ? void 0 : _a[pipelineKey])) {
-      const pipeline = (_b = migratedConfig.pipeline) == null ? void 0 : _b[pipelineKey];
+    config.pipeline;
+    if (migratedConfig.pipeline && config.pipeline[pipelineKey]) {
+      const pipeline = migratedConfig.pipeline[pipelineKey];
       migratedConfig.pipeline[pipelineKey] = {
         ...pipeline,
         ...migratePipeline(pipeline)
@@ -131,55 +335,56 @@ function migrateConfig(config) {
   });
   return migratedConfig;
 }
-function migrateEnvVarDependencies(files, flags) {
-  if (files.length === 1) {
-    const dir = files[0];
-    const root = import_path.default.resolve(process.cwd(), dir);
-    console.log(`Migrating environment variable dependencies from "globalDependencies" and "dependsOn" to "env" in "turbo.json"...`);
-    const turboConfigPath = import_path.default.join(root, "turbo.json");
-    let modifiedCount = 0;
-    let skippedCount = 0;
-    let unmodifiedCount = 1;
-    if (!import_fs_extra.default.existsSync(turboConfigPath)) {
-      error(`No turbo.json found at ${root}. Is the path correct?`);
-      process.exit(1);
-    }
-    const rootTurboJson = import_fs_extra.default.readJsonSync(turboConfigPath);
-    if (hasLegacyEnvVarDependencies(rootTurboJson).hasKeys) {
-      if (flags.dry) {
-        if (flags.print) {
-          console.log(JSON.stringify(migrateConfig(rootTurboJson), null, 2));
-        }
-        skip("turbo.json", import_chalk2.default.dim("(dry run)"));
-        skippedCount += 1;
-      } else {
-        if (flags.print) {
-          console.log(JSON.stringify(migrateConfig(rootTurboJson), null, 2));
-        }
-        ok("turbo.json");
-        import_fs_extra.default.writeJsonSync(turboConfigPath, migrateConfig(rootTurboJson), {
-          spaces: 2
-        });
-        modifiedCount += 1;
-        unmodifiedCount -= 1;
-      }
-    } else {
-      ok('no unmigrated environment variable dependencies found in "turbo.json"');
-      process.exit(0);
-    }
-    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`));
+function transformer({
+  root,
+  options
+}) {
+  const { log, runner } = getTransformerHelpers({
+    transformer: TRANSFORMER,
+    rootPath: root,
+    options
+  });
+  log.info(`Migrating environment variable dependencies from "globalDependencies" and "dependsOn" to "env" in "turbo.json"...`);
+  const turboConfigPath = import_path2.default.join(root, "turbo.json");
+  const packageJsonPath = import_path2.default.join(root, "package.json");
+  if (!import_fs_extra2.default.existsSync(turboConfigPath)) {
+    return runner.abortTransform({
+      reason: `No turbo.json found at ${root}. Is the path correct?`
+    });
+  }
+  let packageJSON = {};
+  try {
+    packageJSON = import_fs_extra2.default.readJSONSync(packageJsonPath);
+  } catch (e) {
   }
+  if ("turbo" in packageJSON) {
+    return runner.abortTransform({
+      reason: '"turbo" key detected in package.json. Run `npx @turbo/codemod transform create-turbo-config` first'
+    });
+  }
+  let turboJson = import_fs_extra2.default.readJsonSync(turboConfigPath);
+  if (hasLegacyEnvVarDependencies(turboJson).hasKeys) {
+    turboJson = migrateConfig(turboJson);
+  }
+  runner.modifyFile({
+    filePath: turboConfigPath,
+    after: turboJson
+  });
+  return runner.finish();
 }
+var transformerMeta = {
+  name: `${TRANSFORMER}: ${DESCRIPTION}`,
+  value: TRANSFORMER,
+  introducedIn: INTRODUCED_IN,
+  transformer
+};
+var migrate_env_var_dependencies_default = transformerMeta;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   hasLegacyEnvVarDependencies,
   migrateConfig,
   migrateDependencies,
   migrateGlobal,
-  migratePipeline
+  migratePipeline,
+  transformer
 });