@backstage/cli 0.18.0 → 0.18.1

package/dist/cjs/{pack-8ab429c0.cjs.js → pack-ce12d4b7.cjs.js}

@@ -1,7 +1,7 @@
 'use strict';
 
 var fs = require('fs-extra');
-var index = require('./index-7e13cc9d.cjs.js');
+var index = require('./index-b7ce30d9.cjs.js');
 var path = require('path');
 require('commander');
 require('chalk');
@@ -22,14 +22,18 @@ function resolveEntrypoint(pkg, name) {
 }
 async function writeReleaseStageEntrypoint(pkg, stage) {
   await fs__default["default"].ensureDir(index.paths.resolveTarget(stage));
-  await fs__default["default"].writeJson(index.paths.resolveTarget(stage, PKG_PATH), {
-    name: pkg.name,
-    version: pkg.version,
-    main: resolveEntrypoint(pkg, "main"),
-    module: resolveEntrypoint(pkg, "module"),
-    browser: resolveEntrypoint(pkg, "browser"),
-    types: path.join("..", pkg.publishConfig[`${stage}Types`])
-  }, { encoding: "utf8", spaces: 2 });
+  await fs__default["default"].writeJson(
+    index.paths.resolveTarget(stage, PKG_PATH),
+    {
+      name: pkg.name,
+      version: pkg.version,
+      main: resolveEntrypoint(pkg, "main"),
+      module: resolveEntrypoint(pkg, "module"),
+      browser: resolveEntrypoint(pkg, "browser"),
+      types: path.join("..", pkg.publishConfig[`${stage}Types`])
+    },
+    { encoding: "utf8", spaces: 2 }
+  );
 }
 const pre = async () => {
   var _a;
@@ -63,10 +67,12 @@ const post = async () => {
       await fs__default["default"].remove(index.paths.resolveTarget("beta"));
     }
   } catch (error) {
-    console.warn(`Failed to restore package.json during postpack, ${error}. Your package will be fine but you may have ended up with some garbage in the repo.`);
+    console.warn(
+      `Failed to restore package.json during postpack, ${error}. Your package will be fine but you may have ended up with some garbage in the repo.`
+    );
   }
 };
 
 exports.post = post;
 exports.pre = pre;
-//# sourceMappingURL=pack-8ab429c0.cjs.js.map
+//# sourceMappingURL=pack-ce12d4b7.cjs.js.map

package/dist/cjs/packageLintConfigs-9f3b0766.cjs.js

@@ -0,0 +1,83 @@
+'use strict';
+
+var fs = require('fs-extra');
+var path = require('path');
+var PackageGraph = require('./PackageGraph-7ea22294.cjs.js');
+var run = require('./run-f4586ef6.cjs.js');
+require('@manypkg/get-packages');
+require('./index-b7ce30d9.cjs.js');
+require('commander');
+require('chalk');
+require('semver');
+require('@backstage/cli-common');
+require('@backstage/errors');
+require('child_process');
+require('util');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
+
+const PREFIX = `module.exports = require('@backstage/cli/config/eslint-factory')`;
+async function command() {
+  const packages = await PackageGraph.PackageGraph.listTargetPackages();
+  const oldConfigs = [
+    require.resolve("@backstage/cli/config/eslint.js"),
+    require.resolve("@backstage/cli/config/eslint.backend.js")
+  ];
+  const configPaths = new Array();
+  await Promise.all(
+    packages.map(async ({ dir, packageJson }) => {
+      var _a;
+      const configPath = path.resolve(dir, ".eslintrc.js");
+      if (!await fs__default["default"].pathExists(configPath)) {
+        console.log(`Skipping ${packageJson.name}, missing .eslintrc.js`);
+        return;
+      }
+      let existingConfig;
+      try {
+        existingConfig = require(configPath);
+      } catch (error) {
+        console.log(
+          `Skipping ${packageJson.name}, failed to load .eslintrc.js, ${error}`
+        );
+        return;
+      }
+      const extendsArray = (_a = existingConfig.extends) != null ? _a : [];
+      const extendIndex = extendsArray.findIndex((p) => oldConfigs.includes(p));
+      if (extendIndex === -1) {
+        console.log(
+          `Skipping ${packageJson.name}, .eslintrc.js does not extend the legacy config`
+        );
+        return;
+      }
+      extendsArray.splice(extendIndex, 1);
+      if (extendsArray.length === 0) {
+        delete existingConfig.extends;
+      }
+      if (Object.keys(existingConfig).length > 0) {
+        await fs__default["default"].writeFile(
+          configPath,
+          `${PREFIX}(__dirname, ${JSON.stringify(existingConfig, null, 2)});
+`
+        );
+      } else {
+        await fs__default["default"].writeFile(configPath, `${PREFIX}(__dirname);
+`);
+      }
+      configPaths.push(configPath);
+    })
+  );
+  let hasPrettier = false;
+  try {
+    require.resolve("prettier");
+    hasPrettier = true;
+  } catch {
+  }
+  if (hasPrettier) {
+    await run.runPlain("prettier", "--write", ...configPaths);
+  }
+}
+
+exports.command = command;
+//# sourceMappingURL=packageLintConfigs-9f3b0766.cjs.js.map

package/dist/cjs/packageRole-582e0558.cjs.js

@@ -0,0 +1,59 @@
+'use strict';
+
+var fs = require('fs-extra');
+var path = require('path');
+var getPackages = require('@manypkg/get-packages');
+var index = require('./index-b7ce30d9.cjs.js');
+var packageRoles = require('./packageRoles-fec3121b.cjs.js');
+require('commander');
+require('chalk');
+require('semver');
+require('@backstage/cli-common');
+require('@backstage/errors');
+require('zod');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
+
+var packageRole = async () => {
+  const { packages } = await getPackages.getPackages(index.paths.targetDir);
+  await Promise.all(
+    packages.map(async ({ dir, packageJson: pkg }) => {
+      const { name } = pkg;
+      const existingRole = packageRoles.getRoleFromPackage(pkg);
+      if (existingRole) {
+        return;
+      }
+      const detectedRole = packageRoles.detectRoleFromPackage(pkg);
+      if (!detectedRole) {
+        console.error(`No role detected for package ${name}`);
+        return;
+      }
+      console.log(`Detected package role of ${name} as ${detectedRole}`);
+      let newPkg = pkg;
+      const pkgKeys = Object.keys(pkg);
+      if (pkgKeys.includes("backstage")) {
+        newPkg.backstage = {
+          ...newPkg.backstage,
+          role: detectedRole
+        };
+      } else {
+        const index = Math.max(
+          pkgKeys.indexOf("version"),
+          pkgKeys.indexOf("private"),
+          pkgKeys.indexOf("publishConfig")
+        ) + 1 || pkgKeys.length;
+        const pkgEntries = Object.entries(pkg);
+        pkgEntries.splice(index, 0, ["backstage", { role: detectedRole }]);
+        newPkg = Object.fromEntries(pkgEntries);
+      }
+      await fs__default["default"].writeJson(path.resolve(dir, "package.json"), newPkg, {
+        spaces: 2
+      });
+    })
+  );
+};
+
+exports["default"] = packageRole;
+//# sourceMappingURL=packageRole-582e0558.cjs.js.map

package/dist/cjs/{packageRoles-a310f84c.cjs.js → packageRoles-fec3121b.cjs.js}

@@ -2,7 +2,7 @@
 
 var zod = require('zod');
 var fs = require('fs-extra');
-var index = require('./index-7e13cc9d.cjs.js');
+var index = require('./index-b7ce30d9.cjs.js');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -78,7 +78,9 @@ function getRoleFromPackage(pkgJson) {
   if (pkg.backstage) {
     const { role } = pkg.backstage;
     if (!role) {
-      throw new Error(`Package ${pkg.name} must specify a role in the "backstage" field`);
+      throw new Error(
+        `Package ${pkg.name} must specify a role in the "backstage" field`
+      );
     }
     return getRoleInfo(role).role;
   }
@@ -155,4 +157,4 @@ exports.detectRoleFromPackage = detectRoleFromPackage;
 exports.findRoleFromCommand = findRoleFromCommand;
 exports.getRoleFromPackage = getRoleFromPackage;
 exports.getRoleInfo = getRoleInfo;
-//# sourceMappingURL=packageRoles-a310f84c.cjs.js.map
+//# sourceMappingURL=packageRoles-fec3121b.cjs.js.map

package/dist/cjs/packageScripts-04ac9bc2.cjs.js

@@ -0,0 +1,98 @@
+'use strict';
+
+var fs = require('fs-extra');
+var path = require('path');
+var PackageGraph = require('./PackageGraph-7ea22294.cjs.js');
+var packageRoles = require('./packageRoles-fec3121b.cjs.js');
+require('@manypkg/get-packages');
+require('./index-b7ce30d9.cjs.js');
+require('commander');
+require('chalk');
+require('semver');
+require('@backstage/cli-common');
+require('@backstage/errors');
+require('child_process');
+require('util');
+require('zod');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
+
+const configArgPattern = /--config[=\s][^\s$]+/;
+const noStartRoles = ["cli", "common-library"];
+async function command() {
+  const packages = await PackageGraph.PackageGraph.listTargetPackages();
+  await Promise.all(
+    packages.map(async ({ dir, packageJson }) => {
+      var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+      const role = packageRoles.getRoleFromPackage(packageJson);
+      if (!role) {
+        return;
+      }
+      const roleInfo = packageRoles.getRoleInfo(role);
+      const hasStart = !noStartRoles.includes(role);
+      const needsPack = !(roleInfo.output.includes("bundle") || role === "cli");
+      const scripts = (_a = packageJson.scripts) != null ? _a : {};
+      const startCmd = ["start"];
+      if ((_b = scripts.start) == null ? void 0 : _b.includes("--check")) {
+        startCmd.push("--check");
+      }
+      if ((_c = scripts.start) == null ? void 0 : _c.includes("--config")) {
+        startCmd.push(...(_d = scripts.start.match(configArgPattern)) != null ? _d : []);
+      }
+      const buildCmd = ["build"];
+      if ((_e = scripts.build) == null ? void 0 : _e.includes("--minify")) {
+        buildCmd.push("--minify");
+      }
+      if ((_f = scripts.build) == null ? void 0 : _f.includes("--experimental-type-build")) {
+        buildCmd.push("--experimental-type-build");
+      }
+      if ((_g = scripts.build) == null ? void 0 : _g.includes("--config")) {
+        buildCmd.push(...(_h = scripts.build.match(configArgPattern)) != null ? _h : []);
+      }
+      const testCmd = ["test"];
+      if ((_i = scripts.test) == null ? void 0 : _i.startsWith("backstage-cli test")) {
+        const args = scripts.test.slice("backstage-cli test".length).split(" ").filter(Boolean);
+        if (args.includes("--passWithNoTests")) {
+          args.splice(args.indexOf("--passWithNoTests"), 1);
+        }
+        testCmd.push(...args);
+      }
+      const expectedScripts = {
+        ...hasStart && {
+          start: `backstage-cli package ${startCmd.join(" ")}`
+        },
+        build: `backstage-cli package ${buildCmd.join(" ")}`,
+        lint: "backstage-cli package lint",
+        test: `backstage-cli package ${testCmd.join(" ")}`,
+        clean: "backstage-cli package clean",
+        ...needsPack && {
+          postpack: "backstage-cli package postpack",
+          prepack: "backstage-cli package prepack"
+        }
+      };
+      let changed = false;
+      const currentScripts = packageJson.scripts = packageJson.scripts || {};
+      for (const [name, value] of Object.entries(expectedScripts)) {
+        const currentScript = currentScripts[name];
+        const isMissing = !currentScript;
+        const isDifferent = currentScript !== value;
+        const isBackstageScript = currentScript == null ? void 0 : currentScript.includes("backstage-cli");
+        if (isMissing || isDifferent && isBackstageScript) {
+          changed = true;
+          currentScripts[name] = value;
+        }
+      }
+      if (changed) {
+        console.log(`Updating scripts for ${packageJson.name}`);
+        await fs__default["default"].writeJson(path.resolve(dir, "package.json"), packageJson, {
+          spaces: 2
+        });
+      }
+    })
+  );
+}
+
+exports.command = command;
+//# sourceMappingURL=packageScripts-04ac9bc2.cjs.js.map

package/dist/cjs/{packages-ea5c38ec.cjs.js → packages-24759dcb.cjs.js}

@@ -2,8 +2,8 @@
 
 var minimatch = require('minimatch');
 var getPackages = require('@manypkg/get-packages');
-var run = require('./run-5e05ba2c.cjs.js');
-var index = require('./index-7e13cc9d.cjs.js');
+var run = require('./run-f4586ef6.cjs.js');
+var index = require('./index-b7ce30d9.cjs.js');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -32,17 +32,22 @@ async function mapDependencies(targetDir, pattern) {
   packages.push(root);
   const dependencyMap = /* @__PURE__ */ new Map();
   for (const pkg of packages) {
-    const deps = DEP_TYPES.flatMap((t) => {
-      var _a2;
-      return Object.entries((_a2 = pkg.packageJson[t]) != null ? _a2 : {});
-    });
+    const deps = DEP_TYPES.flatMap(
+      (t) => {
+        var _a2;
+        return Object.entries((_a2 = pkg.packageJson[t]) != null ? _a2 : {});
+      }
+    );
     for (const [name, range] of deps) {
       if (minimatch__default["default"](name, pattern)) {
-        dependencyMap.set(name, ((_a = dependencyMap.get(name)) != null ? _a : []).concat({
-          range,
-          name: pkg.packageJson.name,
-          location: pkg.dir
-        }));
+        dependencyMap.set(
+          name,
+          ((_a = dependencyMap.get(name)) != null ? _a : []).concat({
+            range,
+            name: pkg.packageJson.name,
+            location: pkg.dir
+          })
+        );
       }
     }
   }
@@ -51,4 +56,4 @@ async function mapDependencies(targetDir, pattern) {
 
 exports.fetchPackageInfo = fetchPackageInfo;
 exports.mapDependencies = mapDependencies;
-//# sourceMappingURL=packages-ea5c38ec.cjs.js.map
+//# sourceMappingURL=packages-24759dcb.cjs.js.map

package/dist/cjs/parallel-a8f6219c.cjs.js

@@ -0,0 +1,187 @@
+'use strict';
+
+var os = require('os');
+var worker_threads = require('worker_threads');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var os__default = /*#__PURE__*/_interopDefaultLegacy(os);
+
+const defaultParallelism = Math.ceil(os__default["default"].cpus().length / 2);
+const PARALLEL_ENV_VAR = "BACKSTAGE_CLI_BUILD_PARALLEL";
+function parseParallelismOption(parallel) {
+  if (parallel === void 0 || parallel === null) {
+    return defaultParallelism;
+  } else if (typeof parallel === "boolean") {
+    return parallel ? defaultParallelism : 1;
+  } else if (typeof parallel === "number" && Number.isInteger(parallel)) {
+    if (parallel < 1) {
+      return 1;
+    }
+    return parallel;
+  } else if (typeof parallel === "string") {
+    if (parallel === "true") {
+      return parseParallelismOption(true);
+    } else if (parallel === "false") {
+      return parseParallelismOption(false);
+    }
+    const parsed = Number(parallel);
+    if (Number.isInteger(parsed)) {
+      return parseParallelismOption(parsed);
+    }
+  }
+  throw Error(
+    `Parallel option value '${parallel}' is not a boolean or integer`
+  );
+}
+function getEnvironmentParallelism() {
+  return parseParallelismOption(process.env[PARALLEL_ENV_VAR]);
+}
+async function runParallelWorkers(options) {
+  const { parallelismFactor = 1, parallelismSetting, items, worker } = options;
+  const parallelism = parallelismSetting ? parseParallelismOption(parallelismSetting) : getEnvironmentParallelism();
+  const sharedIterator = items[Symbol.iterator]();
+  const sharedIterable = {
+    [Symbol.iterator]: () => sharedIterator
+  };
+  const workerCount = Math.max(Math.floor(parallelismFactor * parallelism), 1);
+  return Promise.all(
+    Array(workerCount).fill(0).map(async () => {
+      for (const value of sharedIterable) {
+        await worker(value);
+      }
+    })
+  );
+}
+async function runWorkerQueueThreads(options) {
+  const items = Array.from(options.items);
+  const {
+    workerFactory,
+    workerData,
+    threadCount = Math.min(getEnvironmentParallelism(), items.length)
+  } = options;
+  const iterator = items[Symbol.iterator]();
+  const results = new Array();
+  let itemIndex = 0;
+  await Promise.all(
+    Array(threadCount).fill(0).map(async () => {
+      const thread = new worker_threads.Worker(`(${workerQueueThread})(${workerFactory})`, {
+        eval: true,
+        workerData
+      });
+      return new Promise((resolve, reject) => {
+        thread.on("message", (message) => {
+          if (message.type === "start" || message.type === "result") {
+            if (message.type === "result") {
+              results[message.index] = message.result;
+            }
+            const { value, done } = iterator.next();
+            if (done) {
+              thread.postMessage({ type: "done" });
+            } else {
+              thread.postMessage({
+                type: "item",
+                index: itemIndex,
+                item: value
+              });
+              itemIndex += 1;
+            }
+          } else if (message.type === "error") {
+            const error = new Error(message.error.message);
+            error.name = message.error.name;
+            error.stack = message.error.stack;
+            reject(error);
+          }
+        });
+        thread.on("error", reject);
+        thread.on("exit", (code) => {
+          if (code !== 0) {
+            reject(new Error(`Worker thread exited with code ${code}`));
+          } else {
+            resolve();
+          }
+        });
+      });
+    })
+  );
+  return results;
+}
+function workerQueueThread(workerFuncFactory) {
+  const { parentPort, workerData } = require("worker_threads");
+  Promise.resolve().then(() => workerFuncFactory(workerData)).then(
+    (workerFunc) => {
+      parentPort.on("message", async (message) => {
+        if (message.type === "done") {
+          parentPort.close();
+          return;
+        }
+        if (message.type === "item") {
+          try {
+            const result = await workerFunc(message.item);
+            parentPort.postMessage({
+              type: "result",
+              index: message.index,
+              result
+            });
+          } catch (error) {
+            parentPort.postMessage({ type: "error", error });
+          }
+        }
+      });
+      parentPort.postMessage({ type: "start" });
+    },
+    (error) => parentPort.postMessage({ type: "error", error })
+  );
+}
+async function runWorkerThreads(options) {
+  const { worker, workerData, threadCount = 1, onMessage } = options;
+  return Promise.all(
+    Array(threadCount).fill(0).map(async () => {
+      const thread = new worker_threads.Worker(`(${workerThread})(${worker})`, {
+        eval: true,
+        workerData
+      });
+      return new Promise((resolve, reject) => {
+        thread.on("message", (message) => {
+          if (message.type === "result") {
+            resolve(message.result);
+          } else if (message.type === "error") {
+            reject(message.error);
+          } else if (message.type === "message") {
+            onMessage == null ? void 0 : onMessage(message.message);
+          }
+        });
+        thread.on("error", reject);
+        thread.on("exit", (code) => {
+          reject(
+            new Error(`Unexpected worker thread exit with code ${code}`)
+          );
+        });
+      });
+    })
+  );
+}
+function workerThread(workerFunc) {
+  const { parentPort, workerData } = require("worker_threads");
+  const sendMessage = (message) => {
+    parentPort.postMessage({ type: "message", message });
+  };
+  workerFunc(workerData, sendMessage).then(
+    (result) => {
+      parentPort.postMessage({
+        type: "result",
+        index: 0,
+        result
+      });
+    },
+    (error) => {
+      parentPort.postMessage({ type: "error", error });
+    }
+  );
+}
+
+exports.getEnvironmentParallelism = getEnvironmentParallelism;
+exports.runParallelWorkers = runParallelWorkers;
+exports.runWorkerQueueThreads = runWorkerQueueThreads;
+exports.runWorkerThreads = runWorkerThreads;
+//# sourceMappingURL=parallel-a8f6219c.cjs.js.map