@backstage/cli 0.28.0-next.1 → 0.28.0

package/dist/commands/pack.cjs.js

@@ -0,0 +1,29 @@
+'use strict';
+
+var productionPack = require('../lib/packager/productionPack.cjs.js');
+var paths = require('../lib/paths.cjs.js');
+var fs = require('fs-extra');
+var publishing = require('../lib/publishing.cjs.js');
+var typeDistProject = require('../lib/typeDistProject.cjs.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+
+const pre = async () => {
+  publishing.publishPreflightCheck({
+    dir: paths.paths.targetDir,
+    packageJson: await fs__default.default.readJson(paths.paths.resolveTarget("package.json"))
+  });
+  await productionPack.productionPack({
+    packageDir: paths.paths.targetDir,
+    featureDetectionProject: await typeDistProject.createTypeDistProject()
+  });
+};
+const post = async () => {
+  await productionPack.revertProductionPack(paths.paths.targetDir);
+};
+
+exports.post = post;
+exports.pre = pre;
+//# sourceMappingURL=pack.cjs.js.map

package/dist/commands/repo/build.cjs.js

@@ -0,0 +1,113 @@
+'use strict';
+
+var chalk = require('chalk');
+var path = require('path');
+var packager = require('../../lib/builder/packager.cjs.js');
+var paths = require('../../lib/paths.cjs.js');
+var cliNode = require('@backstage/cli-node');
+var parallel = require('../../lib/parallel.cjs.js');
+var buildFrontend = require('../build/buildFrontend.cjs.js');
+var buildBackend = require('../build/buildBackend.cjs.js');
+var optionsParser = require('./optionsParser.cjs.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var chalk__default = /*#__PURE__*/_interopDefaultCompat(chalk);
+
+async function command(opts, cmd) {
+  let packages = await cliNode.PackageGraph.listTargetPackages();
+  if (opts.since) {
+    const graph = cliNode.PackageGraph.fromPackages(packages);
+    const changedPackages = await graph.listChangedPackages({
+      ref: opts.since,
+      analyzeLockfile: true
+    });
+    const withDevDependents = graph.collectPackageNames(
+      changedPackages.map((pkg) => pkg.name),
+      (pkg) => pkg.localDevDependents.keys()
+    );
+    packages = Array.from(withDevDependents).map((name) => graph.get(name));
+  }
+  const apps = new Array();
+  const backends = new Array();
+  const parseBuildScript = optionsParser.createScriptOptionsParser(cmd, ["package", "build"]);
+  const options = packages.flatMap((pkg) => {
+    const role = pkg.packageJson.backstage?.role ?? cliNode.PackageRoles.detectRoleFromPackage(pkg.packageJson);
+    if (!role) {
+      console.warn(`Ignored ${pkg.packageJson.name} because it has no role`);
+      return [];
+    }
+    if (role === "frontend") {
+      apps.push(pkg);
+      return [];
+    } else if (role === "backend") {
+      backends.push(pkg);
+      return [];
+    }
+    const outputs = packager.getOutputsForRole(role);
+    if (outputs.size === 0) {
+      console.warn(`Ignored ${pkg.packageJson.name} because it has no output`);
+      return [];
+    }
+    const buildOptions = parseBuildScript(pkg.packageJson.scripts?.build);
+    if (!buildOptions) {
+      console.warn(
+        `Ignored ${pkg.packageJson.name} because it does not have a matching build script`
+      );
+      return [];
+    }
+    return {
+      targetDir: pkg.dir,
+      packageJson: pkg.packageJson,
+      outputs,
+      logPrefix: `${chalk__default.default.cyan(path.relative(paths.paths.targetRoot, pkg.dir))}: `,
+      workspacePackages: packages,
+      minify: opts.minify ?? buildOptions.minify
+    };
+  });
+  console.log("Building packages");
+  await packager.buildPackages(options);
+  if (opts.all) {
+    console.log("Building apps");
+    await parallel.runParallelWorkers({
+      items: apps,
+      parallelismFactor: 1 / 2,
+      worker: async (pkg) => {
+        const buildOptions = parseBuildScript(pkg.packageJson.scripts?.build);
+        if (!buildOptions) {
+          console.warn(
+            `Ignored ${pkg.packageJson.name} because it does not have a matching build script`
+          );
+          return;
+        }
+        await buildFrontend.buildFrontend({
+          targetDir: pkg.dir,
+          configPaths: buildOptions.config ?? [],
+          writeStats: Boolean(buildOptions.stats)
+        });
+      }
+    });
+    console.log("Building backends");
+    await parallel.runParallelWorkers({
+      items: backends,
+      parallelismFactor: 1 / 2,
+      worker: async (pkg) => {
+        const buildOptions = parseBuildScript(pkg.packageJson.scripts?.build);
+        if (!buildOptions) {
+          console.warn(
+            `Ignored ${pkg.packageJson.name} because it does not have a matching build script`
+          );
+          return;
+        }
+        await buildBackend.buildBackend({
+          targetDir: pkg.dir,
+          skipBuildDependencies: true,
+          minify: opts.minify ?? buildOptions.minify
+        });
+      }
+    });
+  }
+}
+
+exports.command = command;
+//# sourceMappingURL=build.cjs.js.map

package/dist/{cjs/clean-a6Q4k9Vm.cjs.js → commands/repo/clean.cjs.js}

@@ -5,12 +5,7 @@ var fs = require('fs-extra');
 var path = require('path');
 var util = require('util');
 var cliNode = require('@backstage/cli-node');
-var index = require('./index-b1ouG3q6.cjs.js');
-require('commander');
-require('chalk');
-require('semver');
-require('@backstage/cli-common');
-require('@backstage/errors');
+var paths = require('../../lib/paths.cjs.js');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
 
@@ -19,9 +14,9 @@ var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
 const execFile = util.promisify(child_process.execFile);
 async function command() {
   const packages = await cliNode.PackageGraph.listTargetPackages();
-  await fs__default.default.remove(index.paths.resolveTargetRoot("dist"));
-  await fs__default.default.remove(index.paths.resolveTargetRoot("dist-types"));
-  await fs__default.default.remove(index.paths.resolveTargetRoot("coverage"));
+  await fs__default.default.remove(paths.paths.resolveTargetRoot("dist"));
+  await fs__default.default.remove(paths.paths.resolveTargetRoot("dist-types"));
+  await fs__default.default.remove(paths.paths.resolveTargetRoot("coverage"));
   await Promise.all(
     Array.from(Array(10), async () => {
       while (packages.length > 0) {
@@ -45,4 +40,4 @@ async function command() {
 }
 
 exports.command = command;
-//# sourceMappingURL=clean-a6Q4k9Vm.cjs.js.map
+//# sourceMappingURL=clean.cjs.js.map

package/dist/{cjs/fix-COitqgqm.cjs.js → commands/repo/fix.cjs.js}

@@ -3,13 +3,8 @@
 var cliNode = require('@backstage/cli-node');
 var fs = require('fs-extra');
 var path = require('path');
-var index = require('./index-b1ouG3q6.cjs.js');
-var publishing = require('./publishing-DQtsKTbc.cjs.js');
-require('commander');
-require('chalk');
-require('semver');
-require('@backstage/cli-common');
-require('@backstage/errors');
+var paths = require('../../lib/paths.cjs.js');
+var publishing = require('../../lib/publishing.cjs.js');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
 
@@ -22,7 +17,7 @@ async function readFixablePackages() {
 function printPackageFixHint(packages) {
   const changed = packages.filter((pkg) => pkg.changed);
   if (changed.length > 0) {
-    const rootPkg = require(index.paths.resolveTargetRoot("package.json"));
+    const rootPkg = require(paths.paths.resolveTargetRoot("package.json"));
     const fixCmd = rootPkg.scripts?.fix === "backstage-cli repo fix" ? "fix" : "backstage-cli repo fix";
     console.log(
       `The following packages are out of sync, run 'yarn ${fixCmd}' to fix them:`
@@ -141,7 +136,7 @@ function fixSideEffects(pkg) {
   pkg.changed = true;
 }
 function createRepositoryFieldFixer() {
-  const rootPkg = require(index.paths.resolveTargetRoot("package.json"));
+  const rootPkg = require(paths.paths.resolveTargetRoot("package.json"));
   const rootRepoField = rootPkg.repository;
   if (!rootRepoField) {
     return () => {
@@ -153,7 +148,7 @@ function createRepositoryFieldFixer() {
   return (pkg) => {
     const expectedPath = path.posix.join(
       rootDir,
-      path.relative(index.paths.targetRoot, pkg.dir)
+      path.relative(paths.paths.targetRoot, pkg.dir)
     );
     const repoField = pkg.packageJson.repository;
     if (!repoField || typeof repoField === "string") {
@@ -227,7 +222,7 @@ function fixPluginId(pkg) {
   const guessedPluginId = guessPluginId(role, pkg.packageJson.name);
   if (!guessedPluginId && (role === "frontend-plugin" || role === "frontend-plugin-module" || role === "backend-plugin" || role === "backend-plugin-module")) {
     const path$1 = path.relative(
-      index.paths.targetRoot,
+      paths.paths.targetRoot,
       path.resolve(pkg.dir, "package.json")
     );
     const msg = `Failed to guess plugin ID for "${pkg.packageJson.name}", please set the 'backstage.pluginId' field manually in "${path$1}"`;
@@ -298,7 +293,7 @@ function fixPluginPackages(pkg, repoPackages) {
         return;
       }
       const path$1 = path.relative(
-        index.paths.targetRoot,
+        paths.paths.targetRoot,
         path.resolve(pkg.dir, "package.json")
       );
       const suggestedRole = role === "frontend-plugin-module" ? "web-library" : "node-library";
@@ -359,4 +354,4 @@ exports.fixSideEffects = fixSideEffects;
 exports.printPackageFixHint = printPackageFixHint;
 exports.readFixablePackages = readFixablePackages;
 exports.writeFixedPackages = writeFixedPackages;
-//# sourceMappingURL=fix-COitqgqm.cjs.js.map
+//# sourceMappingURL=fix.cjs.js.map

package/dist/commands/repo/lint.cjs.js

@@ -0,0 +1,205 @@
+'use strict';
+
+var chalk = require('chalk');
+var fs = require('fs-extra');
+var crypto = require('crypto');
+var path = require('path');
+var cliNode = require('@backstage/cli-node');
+var paths = require('../../lib/paths.cjs.js');
+var parallel = require('../../lib/parallel.cjs.js');
+var optionsParser = require('./optionsParser.cjs.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var chalk__default = /*#__PURE__*/_interopDefaultCompat(chalk);
+var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+
+function depCount(pkg) {
+  const deps = pkg.dependencies ? Object.keys(pkg.dependencies).length : 0;
+  const devDeps = pkg.devDependencies ? Object.keys(pkg.devDependencies).length : 0;
+  return deps + devDeps;
+}
+const CACHE_FILE_NAME = "lint-cache.json";
+async function readCache(dir) {
+  try {
+    const data = await fs__default.default.readJson(path.resolve(dir, CACHE_FILE_NAME));
+    if (!Array.isArray(data)) {
+      return void 0;
+    }
+    if (data.some((x) => typeof x !== "string")) {
+      return void 0;
+    }
+    return data;
+  } catch {
+    return void 0;
+  }
+}
+async function writeCache(dir, cache) {
+  await fs__default.default.mkdirp(dir);
+  await fs__default.default.writeJson(path.resolve(dir, CACHE_FILE_NAME), cache, { spaces: 2 });
+}
+async function command(opts, cmd) {
+  let packages = await cliNode.PackageGraph.listTargetPackages();
+  const cacheDir = path.resolve(
+    opts.successCacheDir ?? "node_modules/.cache/backstage-cli"
+  );
+  const cacheContext = opts.successCache ? {
+    cache: await readCache(cacheDir),
+    lockfile: await cliNode.Lockfile.load(paths.paths.resolveTargetRoot("yarn.lock"))
+  } : void 0;
+  if (opts.since) {
+    const graph = cliNode.PackageGraph.fromPackages(packages);
+    packages = await graph.listChangedPackages({
+      ref: opts.since,
+      analyzeLockfile: true
+    });
+  }
+  packages.sort((a, b) => depCount(b.packageJson) - depCount(a.packageJson));
+  if (opts.format === "eslint-formatter-friendly") {
+    process.chdir(paths.paths.targetRoot);
+  }
+  if (!process.env.FORCE_COLOR) {
+    process.env.FORCE_COLOR = "1";
+  }
+  const parseLintScript = optionsParser.createScriptOptionsParser(cmd, ["package", "lint"]);
+  const items = await Promise.all(
+    packages.map(async (pkg) => {
+      const lintOptions = parseLintScript(pkg.packageJson.scripts?.lint);
+      const base = {
+        fullDir: pkg.dir,
+        relativeDir: path.relative(paths.paths.targetRoot, pkg.dir),
+        lintOptions,
+        parentHash: void 0
+      };
+      if (!cacheContext) {
+        return base;
+      }
+      const hash = crypto.createHash("sha1");
+      hash.update(
+        cacheContext.lockfile.getDependencyTreeHash(pkg.packageJson.name)
+      );
+      hash.update("\0");
+      hash.update(JSON.stringify(lintOptions ?? {}));
+      hash.update("\0");
+      hash.update(process.version);
+      hash.update("\0");
+      hash.update("v1");
+      return {
+        ...base,
+        parentHash: hash.digest("hex")
+      };
+    })
+  );
+  const resultsList = await parallel.runWorkerQueueThreads({
+    items: items.filter((item) => item.lintOptions),
+    // Filter out packages without lint script
+    workerData: {
+      fix: Boolean(opts.fix),
+      format: opts.format,
+      shouldCache: Boolean(cacheContext),
+      successCache: cacheContext?.cache,
+      rootDir: paths.paths.targetRoot
+    },
+    workerFactory: async ({
+      fix,
+      format,
+      shouldCache,
+      successCache,
+      rootDir
+    }) => {
+      const { ESLint } = require("eslint");
+      const crypto = require("crypto");
+      const globby = require("globby");
+      const { readFile } = require("fs/promises");
+      const { relative: workerRelativePath } = require("path");
+      return async ({
+        fullDir,
+        relativeDir,
+        lintOptions,
+        parentHash
+      }) => {
+        process.cwd = () => fullDir;
+        const start = Date.now();
+        const eslint = new ESLint({
+          cwd: fullDir,
+          fix,
+          extensions: ["js", "jsx", "ts", "tsx", "mjs", "cjs"]
+        });
+        let sha = void 0;
+        if (shouldCache) {
+          const result = await globby(relativeDir, {
+            gitignore: true,
+            onlyFiles: true,
+            cwd: rootDir
+          });
+          const hash = crypto.createHash("sha1");
+          hash.update(parentHash);
+          hash.update("\0");
+          for (const path of result.sort()) {
+            if (await eslint.isPathIgnored(path)) {
+              continue;
+            }
+            hash.update(workerRelativePath(fullDir, path));
+            hash.update("\0");
+            hash.update(await readFile(path));
+            hash.update("\0");
+            hash.update(
+              JSON.stringify(await eslint.calculateConfigForFile(path))
+            );
+            hash.update("\0");
+          }
+          sha = await hash.digest("hex");
+          if (successCache?.includes(sha)) {
+            console.log(`Skipped ${relativeDir} due to cache hit`);
+            return { relativeDir, sha, failed: false };
+          }
+        }
+        const formatter = await eslint.loadFormatter(format);
+        const results = await eslint.lintFiles(["."]);
+        const count = String(results.length).padStart(3);
+        const time = ((Date.now() - start) / 1e3).toFixed(2);
+        console.log(`Checked ${count} files in ${relativeDir} ${time}s`);
+        if (fix) {
+          await ESLint.outputFixes(results);
+        }
+        const maxWarnings = lintOptions?.maxWarnings ?? 0;
+        const resultText = formatter.format(results);
+        const failed2 = results.some((r) => r.errorCount > 0) || results.reduce((current, next) => current + next.warningCount, 0) > maxWarnings;
+        return {
+          relativeDir,
+          resultText,
+          failed: failed2,
+          sha
+        };
+      };
+    }
+  });
+  const outputSuccessCache = [];
+  let failed = false;
+  for (const {
+    relativeDir,
+    resultText,
+    failed: runFailed,
+    sha
+  } of resultsList) {
+    if (runFailed) {
+      console.log(chalk__default.default.red(`Lint failed in ${relativeDir}`));
+      failed = true;
+      if (resultText) {
+        console.log();
+        console.log(resultText.trimStart());
+      }
+    } else if (sha) {
+      outputSuccessCache.push(sha);
+    }
+  }
+  if (cacheContext) {
+    await writeCache(cacheDir, outputSuccessCache);
+  }
+  if (failed) {
+    process.exit(1);
+  }
+}
+
+exports.command = command;
+//# sourceMappingURL=lint.cjs.js.map

package/dist/{cjs/list-deprecations-CtUaQgaP.cjs.js → commands/repo/list-deprecations.cjs.js}

@@ -4,12 +4,7 @@ var chalk = require('chalk');
 var eslint = require('eslint');
 var path = require('path');
 var cliNode = require('@backstage/cli-node');
-var index = require('./index-b1ouG3q6.cjs.js');
-require('commander');
-require('fs-extra');
-require('semver');
-require('@backstage/cli-common');
-require('@backstage/errors');
+var paths = require('../../lib/paths.cjs.js');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
 
@@ -18,14 +13,14 @@ var chalk__default = /*#__PURE__*/_interopDefaultCompat(chalk);
 async function command(opts) {
   const packages = await cliNode.PackageGraph.listTargetPackages();
   const eslint$1 = new eslint.ESLint({
-    cwd: index.paths.targetDir,
+    cwd: paths.paths.targetDir,
     overrideConfig: {
       plugins: ["deprecation"],
       rules: {
         "deprecation/deprecation": "error"
       },
       parserOptions: {
-        project: [index.paths.resolveTargetRoot("tsconfig.json")]
+        project: [paths.paths.resolveTargetRoot("tsconfig.json")]
       }
     },
     extensions: ["jsx", "ts", "tsx", "mjs", "cjs"]
@@ -35,14 +30,14 @@ async function command(opts) {
     stderr.write("Initializing TypeScript...");
   }
   const deprecations = [];
-  for (const [index$1, pkg] of packages.entries()) {
+  for (const [index, pkg] of packages.entries()) {
     const results = await eslint$1.lintFiles(pkg.dir);
     for (const result of results) {
       for (const message of result.messages) {
         if (message.ruleId !== "deprecation/deprecation") {
           continue;
         }
-        const path$1 = path.relative(index.paths.targetRoot, result.filePath);
+        const path$1 = path.relative(paths.paths.targetRoot, result.filePath);
         deprecations.push({
           path: path$1,
           message: message.message,
@@ -54,7 +49,7 @@ async function command(opts) {
     if (stderr.isTTY) {
       stderr.clearLine(0);
       stderr.cursorTo(0);
-      stderr.write(`Scanning packages ${index$1 + 1}/${packages.length}`);
+      stderr.write(`Scanning packages ${index + 1}/${packages.length}`);
     }
   }
   if (stderr.isTTY) {
@@ -76,4 +71,4 @@ async function command(opts) {
 }
 
 exports.command = command;
-//# sourceMappingURL=list-deprecations-CtUaQgaP.cjs.js.map
+//# sourceMappingURL=list-deprecations.cjs.js.map

package/dist/commands/repo/optionsParser.cjs.js

@@ -0,0 +1,37 @@
+'use strict';
+
+function createScriptOptionsParser(anyCmd, commandPath) {
+  let rootCmd = anyCmd;
+  while (rootCmd.parent) {
+    rootCmd = rootCmd.parent;
+  }
+  let targetCmd = rootCmd;
+  for (const name of commandPath) {
+    targetCmd = targetCmd?.commands.find((c) => c.name() === name);
+  }
+  if (!targetCmd) {
+    throw new Error(
+      `Could not find package command '${commandPath.join(" ")}'`
+    );
+  }
+  const cmd = targetCmd;
+  const expectedScript = `backstage-cli ${commandPath.join(" ")}`;
+  return (scriptStr) => {
+    if (!scriptStr || !scriptStr.startsWith(expectedScript)) {
+      return void 0;
+    }
+    const argsStr = scriptStr.slice(expectedScript.length).trim();
+    const currentOpts = cmd._optionValues;
+    const currentStore = cmd._storeOptionsAsProperties;
+    const result = {};
+    cmd._storeOptionsAsProperties = false;
+    cmd._optionValues = result;
+    cmd.parseOptions(argsStr.split(" "));
+    cmd._storeOptionsAsProperties = currentOpts;
+    cmd._optionValues = currentStore;
+    return result;
+  };
+}
+
+exports.createScriptOptionsParser = createScriptOptionsParser;
+//# sourceMappingURL=optionsParser.cjs.js.map