@backstage/cli 0.28.0-next.1 → 0.28.0

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

@@ -0,0 +1,277 @@
+'use strict';
+
+var os = require('os');
+var crypto = require('node:crypto');
+var fs = require('fs-extra');
+var yargs = require('yargs');
+var path = require('path');
+var cliNode = require('@backstage/cli-node');
+var paths = require('../../lib/paths.cjs.js');
+var run = require('../../lib/run.cjs.js');
+var cliCommon = require('@backstage/cli-common');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var os__default = /*#__PURE__*/_interopDefaultCompat(os);
+var crypto__default = /*#__PURE__*/_interopDefaultCompat(crypto);
+var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+var yargs__default = /*#__PURE__*/_interopDefaultCompat(yargs);
+
+const CACHE_FILE_NAME = "test-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;
+  }
+}
+function writeCache(dir, cache) {
+  fs__default.default.mkdirpSync(dir);
+  fs__default.default.writeJsonSync(path.resolve(dir, CACHE_FILE_NAME), cache, { spaces: 2 });
+}
+async function readPackageTreeHashes(graph) {
+  const pkgs = Array.from(graph.values());
+  const output = await run.runPlain(
+    "git",
+    "ls-tree",
+    "--object-only",
+    "HEAD",
+    "--",
+    ...pkgs.map((pkg) => path.relative(paths.paths.targetRoot, pkg.dir))
+  );
+  const treeShaList = output.trim().split(/\r?\n/);
+  if (treeShaList.length !== pkgs.length) {
+    throw new Error(
+      `Error listing project git tree hashes, output length does not equal input length`
+    );
+  }
+  const map = new Map(
+    pkgs.map((pkg, i) => [pkg.packageJson.name, treeShaList[i]])
+  );
+  return (pkgName) => {
+    const sha = map.get(pkgName);
+    if (!sha) {
+      throw new Error(`Tree sha not found for ${pkgName}`);
+    }
+    return sha;
+  };
+}
+function createFlagFinder(args) {
+  const flags = /* @__PURE__ */ new Set();
+  for (const arg of args) {
+    if (arg.startsWith("--no-")) {
+      flags.add(`--${arg.slice("--no-".length)}`);
+    } else if (arg.startsWith("--")) {
+      flags.add(arg.split("=")[0]);
+    } else if (arg.startsWith("-")) {
+      const shortFlags = arg.slice(1).split("");
+      for (const shortFlag of shortFlags) {
+        flags.add(`-${shortFlag}`);
+      }
+    }
+  }
+  return (...findFlags) => {
+    for (const flag of findFlags) {
+      if (flags.has(flag)) {
+        return true;
+      }
+    }
+    return false;
+  };
+}
+function removeOptionArg(args, option, size = 2) {
+  let changed = false;
+  do {
+    changed = false;
+    const index = args.indexOf(option);
+    if (index >= 0) {
+      changed = true;
+      args.splice(index, size);
+    }
+    const indexEq = args.findIndex((arg) => arg.startsWith(`${option}=`));
+    if (indexEq >= 0) {
+      changed = true;
+      args.splice(indexEq, 1);
+    }
+  } while (changed);
+}
+async function command(opts, cmd) {
+  let parent = cmd;
+  while (parent.parent) {
+    parent = parent.parent;
+  }
+  const allArgs = parent.args;
+  const args = allArgs.slice(allArgs.indexOf("test") + 1);
+  const hasFlags = createFlagFinder(args);
+  if (!hasFlags("-c", "--config")) {
+    args.push("--config", paths.paths.resolveOwn("config/jest.js"));
+  }
+  if (!hasFlags("--passWithNoTests")) {
+    args.push("--passWithNoTests");
+  }
+  if (!opts.since && !process.env.CI && !hasFlags("--coverage", "--watch", "--watchAll")) {
+    const isGitRepo = () => run.runCheck("git", "rev-parse", "--is-inside-work-tree");
+    const isMercurialRepo = () => run.runCheck("hg", "--cwd", ".", "root");
+    if (await isGitRepo() || await isMercurialRepo()) {
+      args.push("--watch");
+    } else {
+      args.push("--watchAll");
+    }
+  }
+  if (!hasFlags("--workerIdleMemoryLimit")) {
+    args.push("--workerIdleMemoryLimit=1000M");
+  }
+  if (os__default.default.cpus().length <= 3 && !hasFlags("-i", "--runInBand", "-w", "--maxWorkers")) {
+    args.push("--maxWorkers=2");
+  }
+  if (opts.since) {
+    removeOptionArg(args, "--since");
+  }
+  let packageGraph;
+  async function getPackageGraph() {
+    if (packageGraph) {
+      return packageGraph;
+    }
+    const packages = await cliNode.PackageGraph.listTargetPackages();
+    packageGraph = cliNode.PackageGraph.fromPackages(packages);
+    return packageGraph;
+  }
+  let selectedProjects = void 0;
+  if (opts.since && !hasFlags("--selectProjects")) {
+    const graph = await getPackageGraph();
+    const changedPackages = await graph.listChangedPackages({
+      ref: opts.since,
+      analyzeLockfile: true
+    });
+    selectedProjects = Array.from(
+      graph.collectPackageNames(
+        changedPackages.map((pkg) => pkg.name),
+        (pkg) => pkg.allLocalDependents.keys()
+      )
+    );
+    if (selectedProjects.length === 0) {
+      console.log(`No packages changed since ${opts.since}`);
+      return;
+    }
+    args.push("--selectProjects", ...selectedProjects);
+  }
+  if (!process.env.NODE_ENV) {
+    process.env.NODE_ENV = "test";
+  }
+  if (!process.env.TZ) {
+    process.env.TZ = "UTC";
+  }
+  if (args.includes("--jest-help")) {
+    removeOptionArg(args, "--jest-help");
+    args.push("--help");
+    process.stdout._handle.setBlocking(true);
+  }
+  const jestCli = require("jest-cli");
+  if (opts.successCache) {
+    removeOptionArg(args, "--successCache", 1);
+    removeOptionArg(args, "--successCacheDir");
+    const cacheDir = path.resolve(
+      opts.successCacheDir ?? "node_modules/.cache/backstage-cli"
+    );
+    const { _: parsedArgs } = await yargs__default.default(args).options(jestCli.yargsOptions).argv;
+    if (parsedArgs.length > 0) {
+      throw new Error(
+        `The --successCache flag can not be combined with the following arguments: ${parsedArgs.join(
+          ", "
+        )}`
+      );
+    }
+    if (args.includes("--shard")) {
+      throw new Error(
+        `The --successCache flag can not be combined with the --shard flag`
+      );
+    }
+    const graph = await getPackageGraph();
+    const projectHashes = /* @__PURE__ */ new Map();
+    const outputSuccessCache = new Array();
+    const globalWithCache = global;
+    globalWithCache.__backstageCli_jestSuccessCache = {
+      // This is called by `config/jest.js` after the project configs have been gathered
+      async filterConfigs(projectConfigs, globalRootConfig) {
+        const cache = await readCache(cacheDir);
+        const lockfile = await cliNode.Lockfile.load(
+          paths.paths.resolveTargetRoot("yarn.lock")
+        );
+        const getPackageTreeHash = await readPackageTreeHashes(graph);
+        const baseHash = crypto__default.default.createHash("sha1");
+        baseHash.update("v1");
+        baseHash.update("\0");
+        baseHash.update(process.version);
+        baseHash.update("\0");
+        baseHash.update(JSON.stringify(globalRootConfig));
+        const baseSha = baseHash.digest("hex");
+        return projectConfigs.filter((project) => {
+          const packageName = project.displayName;
+          const pkg = graph.get(packageName);
+          if (!pkg) {
+            throw new Error(
+              `Package ${packageName} not found in package graph`
+            );
+          }
+          const hash = crypto__default.default.createHash("sha1");
+          hash.update(baseSha);
+          const packageTreeSha = getPackageTreeHash(packageName);
+          hash.update(packageTreeSha);
+          for (const [depName, depPkg] of pkg.allLocalDependencies) {
+            const depHash = getPackageTreeHash(depPkg.name);
+            hash.update(`${depName}:${depHash}`);
+          }
+          hash.update(JSON.stringify(project));
+          hash.update(lockfile.getDependencyTreeHash(packageName));
+          const sha = hash.digest("hex");
+          projectHashes.set(packageName, sha);
+          if (cache?.includes(sha)) {
+            if (!selectedProjects || selectedProjects.includes(packageName)) {
+              console.log(`Skipped ${packageName} due to cache hit`);
+            }
+            outputSuccessCache.push(sha);
+            return void 0;
+          }
+          return project;
+        });
+      },
+      // This is called by `config/jestCacheResultProcess.cjs` after all tests have run
+      async reportResults(results) {
+        const successful = /* @__PURE__ */ new Set();
+        const failed = /* @__PURE__ */ new Set();
+        for (const testResult of results.testResults) {
+          for (const [pkgName, pkg] of graph) {
+            if (cliCommon.isChildPath(pkg.dir, testResult.testFilePath)) {
+              if (testResult.testExecError || testResult.failureMessage || testResult.numFailingTests > 0) {
+                failed.add(pkgName);
+                successful.delete(pkgName);
+              } else if (!failed.has(pkgName)) {
+                successful.add(pkgName);
+              }
+              break;
+            }
+          }
+        }
+        for (const pkgName of successful) {
+          const sha = projectHashes.get(pkgName);
+          if (sha) {
+            outputSuccessCache.push(sha);
+          }
+        }
+        await writeCache(cacheDir, outputSuccessCache);
+      }
+    };
+  }
+  await jestCli.run(args);
+}
+
+exports.command = command;
+exports.createFlagFinder = createFlagFinder;
+//# sourceMappingURL=test.cjs.js.map

package/dist/commands/start/command.cjs.js

@@ -0,0 +1,48 @@
+'use strict';
+
+var role = require('../../lib/role.cjs.js');
+var startBackend = require('./startBackend.cjs.js');
+var startFrontend = require('./startFrontend.cjs.js');
+
+async function command(opts) {
+  const role$1 = await role.findRoleFromCommand(opts);
+  const options = {
+    configPaths: opts.config,
+    checksEnabled: Boolean(opts.check),
+    inspectEnabled: opts.inspect,
+    inspectBrkEnabled: opts.inspectBrk,
+    require: opts.require
+  };
+  switch (role$1) {
+    case "backend":
+      return startBackend.startBackend(options);
+    case "backend-plugin":
+    case "backend-plugin-module":
+    case "node-library":
+      return startBackend.startBackendPlugin(options);
+    case "frontend":
+      return startFrontend.startFrontend({
+        ...options,
+        entry: "src/index",
+        verifyVersions: true
+      });
+    case "web-library":
+    case "frontend-plugin":
+    case "frontend-plugin-module":
+      return startFrontend.startFrontend({ entry: "dev/index", ...options });
+    case "frontend-dynamic-container":
+      return startFrontend.startFrontend({
+        entry: "src/index",
+        ...options,
+        skipOpenBrowser: true,
+        isModuleFederationRemote: true
+      });
+    default:
+      throw new Error(
+        `Start command is not supported for package role '${role$1}'`
+      );
+  }
+}
+
+exports.command = command;
+//# sourceMappingURL=command.cjs.js.map

package/dist/commands/start/index.cjs.js

@@ -0,0 +1,8 @@
+'use strict';
+
+var command = require('./command.cjs.js');
+
+
+
+exports.command = command.command;
+//# sourceMappingURL=index.cjs.js.map

package/dist/commands/start/startBackend.cjs.js

@@ -0,0 +1,112 @@
+'use strict';
+
+var fs = require('fs-extra');
+var paths = require('../../lib/paths.cjs.js');
+var backend = require('../../lib/bundler/backend.cjs.js');
+require('yn');
+require('path');
+require('webpack');
+require('react-dev-utils/FileSizeReporter');
+require('react-dev-utils/formatWebpackMessages');
+require('chalk');
+require('eslint-webpack-plugin');
+require('fork-ts-checker-webpack-plugin');
+require('html-webpack-plugin');
+require('@module-federation/enhanced/webpack');
+require('@backstage/cli-common');
+require('react-dev-utils/ModuleScopePlugin');
+require('run-script-webpack-plugin');
+require('@pmmmwh/react-refresh-webpack-plugin');
+require('@manypkg/get-packages');
+require('webpack-node-externals');
+require('../../lib/bundler/optimization.cjs.js');
+require('lodash/pickBy');
+require('../../lib/run.cjs.js');
+require('mini-css-extract-plugin');
+require('../../lib/version.cjs.js');
+require('../../lib/bundler/packageDetection.cjs.js');
+require('react-dev-utils/openBrowser');
+require('webpack-dev-server');
+require('@backstage/config-loader');
+require('@backstage/config');
+require('@backstage/cli-node');
+var startBackendExperimental = require('../../lib/experimental/startBackendExperimental.cjs.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+
+async function startBackend(options) {
+  if (!process.env.LEGACY_BACKEND_START) {
+    const waitForExit = await startBackendExperimental.startBackendExperimental({
+      entry: "src/index",
+      checksEnabled: false,
+      // not supported
+      inspectEnabled: options.inspectEnabled,
+      inspectBrkEnabled: options.inspectBrkEnabled,
+      require: options.require
+    });
+    await waitForExit();
+  } else {
+    console.warn(
+      "LEGACY_BACKEND_START is deprecated and will be removed in a future release"
+    );
+    const waitForExit = await cleanDistAndServeBackend({
+      entry: "src/index",
+      checksEnabled: options.checksEnabled,
+      inspectEnabled: options.inspectEnabled,
+      inspectBrkEnabled: options.inspectBrkEnabled,
+      require: options.require
+    });
+    await waitForExit();
+  }
+}
+async function startBackendPlugin(options) {
+  if (!process.env.LEGACY_BACKEND_START) {
+    const hasDevIndexEntry = await fs__default.default.pathExists(
+      paths.paths.resolveTarget("dev", "index.ts")
+    );
+    if (!hasDevIndexEntry) {
+      console.warn(
+        `The 'dev' directory is missing. Please create a proper dev/index.ts in order to start the plugin.`
+      );
+      return;
+    }
+    const waitForExit = await startBackendExperimental.startBackendExperimental({
+      entry: "dev/index",
+      checksEnabled: false,
+      // not supported
+      inspectEnabled: options.inspectEnabled,
+      inspectBrkEnabled: options.inspectBrkEnabled,
+      require: options.require
+    });
+    await waitForExit();
+  } else {
+    const hasEntry = await fs__default.default.pathExists(paths.paths.resolveTarget("src", "run.ts"));
+    if (!hasEntry) {
+      console.warn(
+        `src/run.ts is missing. Please create the file or run the command without LEGACY_BACKEND_START`
+      );
+      return;
+    }
+    console.warn(
+      "LEGACY_BACKEND_START is deprecated and will be removed in a future release"
+    );
+    const waitForExit = await cleanDistAndServeBackend({
+      entry: "src/run",
+      checksEnabled: options.checksEnabled,
+      inspectEnabled: options.inspectEnabled,
+      inspectBrkEnabled: options.inspectBrkEnabled,
+      require: options.require
+    });
+    await waitForExit();
+  }
+}
+async function cleanDistAndServeBackend(options) {
+  await fs__default.default.remove(paths.paths.resolveTarget("dist"));
+  return backend.serveBackend(options);
+}
+
+exports.startBackend = startBackend;
+exports.startBackendPlugin = startBackendPlugin;
+//# sourceMappingURL=startBackend.cjs.js.map

package/dist/commands/start/startFrontend.cjs.js

@@ -0,0 +1,47 @@
+'use strict';
+
+var fs = require('fs-extra');
+require('webpack');
+require('path');
+require('chalk');
+require('eslint-webpack-plugin');
+require('fork-ts-checker-webpack-plugin');
+require('html-webpack-plugin');
+require('@module-federation/enhanced/webpack');
+require('@backstage/cli-common');
+require('react-dev-utils/ModuleScopePlugin');
+require('run-script-webpack-plugin');
+require('@pmmmwh/react-refresh-webpack-plugin');
+var paths = require('../../lib/paths.cjs.js');
+require('@manypkg/get-packages');
+require('webpack-node-externals');
+require('../../lib/bundler/optimization.cjs.js');
+require('lodash/pickBy');
+require('../../lib/run.cjs.js');
+require('mini-css-extract-plugin');
+require('../../lib/version.cjs.js');
+require('yn');
+require('react-dev-utils/FileSizeReporter');
+require('react-dev-utils/formatWebpackMessages');
+require('../../lib/bundler/packageDetection.cjs.js');
+var moduleFederation = require('../../lib/bundler/moduleFederation.cjs.js');
+var server = require('../../lib/bundler/server.cjs.js');
+
+async function startFrontend(options) {
+  const { name } = await fs.readJson(paths.paths.resolveTarget("package.json"));
+  const waitForExit = await server.serveBundle({
+    entry: options.entry,
+    checksEnabled: options.checksEnabled,
+    configPaths: options.configPaths,
+    verifyVersions: options.verifyVersions,
+    skipOpenBrowser: options.skipOpenBrowser,
+    moduleFederation: moduleFederation.getModuleFederationOptions(
+      name,
+      options.isModuleFederationRemote
+    )
+  });
+  await waitForExit();
+}
+
+exports.startFrontend = startFrontend;
+//# sourceMappingURL=startFrontend.cjs.js.map

package/dist/{cjs/test-COxIko8N.cjs.js → commands/test.cjs.js}

@@ -1,15 +1,9 @@
 'use strict';
 
-var index = require('./index-b1ouG3q6.cjs.js');
-var run = require('./run-CpZGNJQr.cjs.js');
-require('commander');
-require('chalk');
-require('fs-extra');
-require('semver');
-require('@backstage/cli-common');
-require('@backstage/errors');
-require('child_process');
-require('util');
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var paths = require('../lib/paths.cjs.js');
+var run = require('../lib/run.cjs.js');
 
 function includesAnyOf(hayStack, ...needles) {
   for (const needle of needles) {
@@ -27,7 +21,7 @@ var test = async (_opts, cmd) => {
   const allArgs = parent.args;
   const args = allArgs.slice(allArgs.indexOf("test") + 1);
   if (!includesAnyOf(args, "-c", "--config")) {
-    args.push("--config", index.paths.resolveOwn("config/jest.js"));
+    args.push("--config", paths.paths.resolveOwn("config/jest.js"));
   }
   if (!includesAnyOf(args, "--no-passWithNoTests", "--passWithNoTests=false")) {
     args.push("--passWithNoTests");
@@ -56,4 +50,4 @@ var test = async (_opts, cmd) => {
 };
 
 exports.default = test;
-//# sourceMappingURL=test-COxIko8N.cjs.js.map
+//# sourceMappingURL=test.cjs.js.map