@backstage/cli 0.28.0-next.0 → 0.28.0-next.2

package/dist/lib/builder/packager.cjs.js

@@ -0,0 +1,131 @@
+'use strict';
+
+var fs = require('fs-extra');
+var rollup = require('rollup');
+var chalk = require('chalk');
+var path = require('path');
+var paths = require('../paths.cjs.js');
+var config = require('./config.cjs.js');
+var types = require('./types.cjs.js');
+var cliNode = require('@backstage/cli-node');
+var parallel = require('../parallel.cjs.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+var chalk__default = /*#__PURE__*/_interopDefaultCompat(chalk);
+
+function formatErrorMessage(error) {
+  let msg = "";
+  if (error.code === "PLUGIN_ERROR") {
+    if (error.plugin === "esbuild") {
+      msg += `${error.message}`;
+      if (error.errors?.length) {
+        msg += `
+
+`;
+        for (const { text, location } of error.errors) {
+          const { line, column } = location;
+          const path$1 = path.relative(paths.paths.targetDir, error.id);
+          const loc = chalk__default.default.cyan(`${path$1}:${line}:${column}`);
+          if (text === 'Unexpected "<"' && error.id.endsWith(".js")) {
+            msg += `${loc}: ${text}, JavaScript files with JSX should use a .jsx extension`;
+          } else {
+            msg += `${loc}: ${text}`;
+          }
+        }
+      }
+    } else {
+      msg += `(plugin ${error.plugin}) ${error}
+`;
+    }
+  } else {
+    if (error.loc) {
+      const file = `${paths.paths.resolveTarget(error.loc.file || error.id)}`;
+      const pos = `${error.loc.line}:${error.loc.column}`;
+      msg += `${file} [${pos}]
+`;
+    } else if (error.id) {
+      msg += `${paths.paths.resolveTarget(error.id)}
+`;
+    }
+    msg += `${error}
+`;
+    if (error.url) {
+      msg += `${chalk__default.default.cyan(error.url)}
+`;
+    }
+    if (error.frame) {
+      msg += `${chalk__default.default.dim(error.frame)}
+`;
+    }
+  }
+  return msg;
+}
+async function rollupBuild(config) {
+  try {
+    const bundle = await rollup.rollup(config);
+    if (config.output) {
+      for (const output of [config.output].flat()) {
+        await bundle.generate(output);
+        await bundle.write(output);
+      }
+    }
+  } catch (error) {
+    throw new Error(formatErrorMessage(error));
+  }
+}
+const buildPackage = async (options) => {
+  try {
+    const { resolutions } = await fs__default.default.readJson(
+      paths.paths.resolveTargetRoot("package.json")
+    );
+    if (resolutions?.esbuild) {
+      console.warn(
+        chalk__default.default.red(
+          'Your root package.json contains a "resolutions" entry for "esbuild". This was included in older @backstage/create-app templates in order to work around build issues that have since been fixed. Please remove the entry and run `yarn install`'
+        )
+      );
+    }
+  } catch {
+  }
+  const rollupConfigs = await config.makeRollupConfigs(options);
+  await fs__default.default.remove(paths.paths.resolveTarget("dist"));
+  const buildTasks = rollupConfigs.map(rollupBuild);
+  await Promise.all(buildTasks);
+};
+const buildPackages = async (options) => {
+  if (options.some((opt) => !opt.targetDir)) {
+    throw new Error("targetDir must be set for all build options");
+  }
+  const rollupConfigs = await Promise.all(options.map(config.makeRollupConfigs));
+  await Promise.all(
+    options.map(({ targetDir }) => fs__default.default.remove(path.resolve(targetDir, "dist")))
+  );
+  const buildTasks = rollupConfigs.flat().map((opts) => () => rollupBuild(opts));
+  await parallel.runParallelWorkers({
+    items: buildTasks,
+    worker: async (task) => task()
+  });
+};
+function getOutputsForRole(role) {
+  const outputs = /* @__PURE__ */ new Set();
+  for (const output of cliNode.PackageRoles.getRoleInfo(role).output) {
+    if (output === "cjs") {
+      outputs.add(types.Output.cjs);
+    }
+    if (output === "esm") {
+      outputs.add(types.Output.esm);
+    }
+    if (output === "types") {
+      outputs.add(types.Output.types);
+    }
+  }
+  return outputs;
+}
+
+exports.buildPackage = buildPackage;
+exports.buildPackages = buildPackages;
+exports.formatErrorMessage = formatErrorMessage;
+exports.getOutputsForRole = getOutputsForRole;
+//# sourceMappingURL=packager.cjs.js.map

package/dist/lib/builder/plugins.cjs.js

@@ -0,0 +1,71 @@
+'use strict';
+
+var fs = require('fs-extra');
+var path = require('path');
+var rollupPluginutils = require('rollup-pluginutils');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+
+function forwardFileImports(options) {
+  const filter = rollupPluginutils.createFilter(options.include, options.exclude);
+  const exportedFiles = /* @__PURE__ */ new Set();
+  const generatedFor = /* @__PURE__ */ new Set();
+  return {
+    name: "forward-file-imports",
+    async generateBundle(outputOptions, bundle, isWrite) {
+      if (!isWrite) {
+        return;
+      }
+      const dir = outputOptions.dir || path.dirname(outputOptions.file);
+      if (generatedFor.has(dir)) {
+        return;
+      }
+      for (const output of Object.values(bundle)) {
+        if (output.type !== "chunk") {
+          continue;
+        }
+        const chunk = output;
+        if (!chunk.facadeModuleId) {
+          continue;
+        }
+        generatedFor.add(dir);
+        const srcRoot = path.dirname(chunk.facadeModuleId);
+        await Promise.all(
+          Array.from(exportedFiles).map(async (exportedFile) => {
+            const outputPath = path.relative(srcRoot, exportedFile);
+            const targetFile = path.resolve(dir, outputPath);
+            await fs__default.default.ensureDir(path.dirname(targetFile));
+            await fs__default.default.copyFile(exportedFile, targetFile);
+          })
+        );
+        return;
+      }
+    },
+    options(inputOptions) {
+      const origExternal = inputOptions.external;
+      const external = (id, importer, isResolved) => {
+        if (typeof origExternal === "function" && origExternal(id, importer, isResolved)) {
+          return true;
+        }
+        if (Array.isArray(origExternal) && origExternal.includes(id)) {
+          return true;
+        }
+        if (!filter(id)) {
+          return false;
+        }
+        if (!importer) {
+          throw new Error(`Unknown importer of file module ${id}`);
+        }
+        const fullId = isResolved ? id : path.resolve(path.dirname(importer), id);
+        exportedFiles.add(fullId);
+        return true;
+      };
+      return { ...inputOptions, external };
+    }
+  };
+}
+
+exports.forwardFileImports = forwardFileImports;
+//# sourceMappingURL=plugins.cjs.js.map

package/dist/lib/builder/types.cjs.js

@@ -0,0 +1,11 @@
+'use strict';
+
+var Output = /* @__PURE__ */ ((Output2) => {
+  Output2[Output2["esm"] = 0] = "esm";
+  Output2[Output2["cjs"] = 1] = "cjs";
+  Output2[Output2["types"] = 2] = "types";
+  return Output2;
+})(Output || {});
+
+exports.Output = Output;
+//# sourceMappingURL=types.cjs.js.map

package/dist/lib/bundler/LinkedPackageResolvePlugin.cjs.js

@@ -0,0 +1,47 @@
+'use strict';
+
+var path = require('path');
+var cliCommon = require('@backstage/cli-common');
+
+class LinkedPackageResolvePlugin {
+  constructor(targetModules, packages) {
+    this.targetModules = targetModules;
+    this.packages = packages;
+  }
+  apply(resolver) {
+    resolver.hooks.resolve.tapAsync(
+      "LinkedPackageResolvePlugin",
+      (data, context, callback) => {
+        const pkg = this.packages.find(
+          (pkge) => data.path && cliCommon.isChildPath(pkge.dir, data.path)
+        );
+        if (!pkg) {
+          callback();
+          return;
+        }
+        const modulesLocation = path.resolve(
+          this.targetModules,
+          pkg.packageJson.name
+        );
+        const newContext = data.context?.issuer ? {
+          ...data.context,
+          issuer: data.context.issuer.replace(pkg.dir, modulesLocation)
+        } : data.context;
+        resolver.doResolve(
+          resolver.hooks.resolve,
+          {
+            ...data,
+            context: newContext,
+            path: data.path && data.path.replace(pkg.dir, modulesLocation)
+          },
+          `resolve ${data.request} in ${modulesLocation}`,
+          context,
+          callback
+        );
+      }
+    );
+  }
+}
+
+exports.LinkedPackageResolvePlugin = LinkedPackageResolvePlugin;
+//# sourceMappingURL=LinkedPackageResolvePlugin.cjs.js.map

package/dist/lib/bundler/backend.cjs.js

@@ -0,0 +1,36 @@
+'use strict';
+
+var webpack = require('webpack');
+var config = require('./config.cjs.js');
+var paths = require('./paths.cjs.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var webpack__default = /*#__PURE__*/_interopDefaultCompat(webpack);
+
+async function serveBackend(options) {
+  const paths$1 = paths.resolveBundlingPaths(options);
+  const config$1 = await config.createBackendConfig(paths$1, {
+    ...options,
+    isDev: true
+  });
+  process.env.NODE_ENV = "development";
+  const compiler = webpack__default.default(config$1, (err) => {
+    if (err) {
+      console.error(err);
+    } else console.log("Build succeeded");
+  });
+  const waitForExit = async () => {
+    for (const signal of ["SIGINT", "SIGTERM"]) {
+      process.on(signal, () => {
+        compiler.close(() => process.exit());
+      });
+    }
+    return new Promise(() => {
+    });
+  };
+  return waitForExit;
+}
+
+exports.serveBackend = serveBackend;
+//# sourceMappingURL=backend.cjs.js.map

package/dist/{cjs/buildBackend-DXvz7jvh.cjs.js → lib/bundler/bundle.cjs.js}

@@ -1,45 +1,23 @@
 'use strict';
 
+var yn = require('yn');
 var fs = require('fs-extra');
 var path = require('path');
 var webpack = require('webpack');
-var chalk = 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('./index-v57xnvgT.cjs.js');
-require('@manypkg/get-packages');
-require('webpack-node-externals');
-var moduleFederation = require('./moduleFederation-Dq0n1quT.cjs.js');
-require('lodash/pickBy');
-require('./run-HW3lfDbM.cjs.js');
-require('mini-css-extract-plugin');
-var yn = require('yn');
 var FileSizeReporter = require('react-dev-utils/FileSizeReporter');
 var formatWebpackMessages = require('react-dev-utils/formatWebpackMessages');
-require('react-dev-utils/openBrowser');
-require('webpack-dev-server');
-var config = require('./config-nCB2LQK-.cjs.js');
-var parallel = require('./parallel-BszNaKyc.cjs.js');
-var os = require('os');
-var tar = require('tar');
-var createDistWorkspace = require('./createDistWorkspace-DKzy-L-f.cjs.js');
-var cliNode = require('@backstage/cli-node');
+var config = require('./config.cjs.js');
+var paths = require('./paths.cjs.js');
+var chalk = require('chalk');
+var packageDetection = require('./packageDetection.cjs.js');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
 
+var yn__default = /*#__PURE__*/_interopDefaultCompat(yn);
 var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
 var webpack__default = /*#__PURE__*/_interopDefaultCompat(webpack);
-var chalk__default = /*#__PURE__*/_interopDefaultCompat(chalk);
-var yn__default = /*#__PURE__*/_interopDefaultCompat(yn);
 var formatWebpackMessages__default = /*#__PURE__*/_interopDefaultCompat(formatWebpackMessages);
-var os__default = /*#__PURE__*/_interopDefaultCompat(os);
-var tar__default = /*#__PURE__*/_interopDefaultCompat(tar);
+var chalk__default = /*#__PURE__*/_interopDefaultCompat(chalk);
 
 const WARN_AFTER_BUNDLE_GZIP_SIZE = 512 * 1024;
 const WARN_AFTER_CHUNK_GZIP_SIZE = 1024 * 1024;
@@ -49,8 +27,8 @@ function applyContextToError(error, moduleName) {
 }
 async function buildBundle(options) {
   const { statsJsonEnabled, schema: configSchema } = options;
-  const paths = moduleFederation.resolveBundlingPaths(options);
-  const publicPaths = await moduleFederation.resolveOptionalBundlingPaths({
+  const paths$1 = paths.resolveBundlingPaths(options);
+  const publicPaths = await paths.resolveOptionalBundlingPaths({
     targetDir: options.targetDir,
     entry: "src/index-public-experimental",
     dist: "dist/public"
@@ -63,14 +41,14 @@ async function buildBundle(options) {
   };
   const configs = [];
   if (options.moduleFederation?.mode === "remote") {
-    configs.push(await moduleFederation.createConfig(paths, commonConfigOptions));
+    configs.push(await config.createConfig(paths$1, commonConfigOptions));
   } else {
-    const detectedModulesEntryPoint = await moduleFederation.createDetectedModulesEntryPoint({
+    const detectedModulesEntryPoint = await packageDetection.createDetectedModulesEntryPoint({
       config: options.fullConfig,
-      targetPath: paths.targetPath
+      targetPath: paths$1.targetPath
     });
     configs.push(
-      await moduleFederation.createConfig(paths, {
+      await config.createConfig(paths$1, {
         ...commonConfigOptions,
         additionalEntryPoints: detectedModulesEntryPoint,
         appMode: publicPaths ? "protected" : "public"
@@ -83,7 +61,7 @@ async function buildBundle(options) {
         )
       );
       configs.push(
-        await moduleFederation.createConfig(publicPaths, {
+        await config.createConfig(publicPaths, {
           ...commonConfigOptions,
           appMode: "public"
         })
@@ -91,24 +69,24 @@ async function buildBundle(options) {
     }
   }
   const isCi = yn__default.default(process.env.CI, { default: false });
-  const previousFileSizes = await FileSizeReporter.measureFileSizesBeforeBuild(paths.targetDist);
+  const previousFileSizes = await FileSizeReporter.measureFileSizesBeforeBuild(paths$1.targetDist);
   const previousAuthSizes = publicPaths ? await FileSizeReporter.measureFileSizesBeforeBuild(publicPaths.targetDist) : void 0;
-  await fs__default.default.emptyDir(paths.targetDist);
-  if (paths.targetPublic) {
-    await fs__default.default.copy(paths.targetPublic, paths.targetDist, {
+  await fs__default.default.emptyDir(paths$1.targetDist);
+  if (paths$1.targetPublic) {
+    await fs__default.default.copy(paths$1.targetPublic, paths$1.targetDist, {
       dereference: true,
-      filter: (file) => file !== paths.targetHtml
+      filter: (file) => file !== paths$1.targetHtml
     });
     if (publicPaths) {
-      await fs__default.default.copy(paths.targetPublic, publicPaths.targetDist, {
+      await fs__default.default.copy(paths$1.targetPublic, publicPaths.targetDist, {
         dereference: true,
-        filter: (file) => file !== paths.targetHtml
+        filter: (file) => file !== paths$1.targetHtml
       });
     }
   }
   if (configSchema) {
     await fs__default.default.writeJson(
-      path.resolve(paths.targetDist, ".config-schema.json"),
+      path.resolve(paths$1.targetDist, ".config-schema.json"),
       configSchema.serialize(),
       { spaces: 2 }
     );
@@ -120,14 +98,14 @@ async function buildBundle(options) {
   const [mainStats, authStats] = stats.stats;
   if (statsJsonEnabled) {
     await require("bfj").write(
-      path.resolve(paths.targetDist, "bundle-stats.json"),
+      path.resolve(paths$1.targetDist, "bundle-stats.json"),
       mainStats.toJson()
     );
   }
   FileSizeReporter.printFileSizesAfterBuild(
     mainStats,
     previousFileSizes,
-    paths.targetDist,
+    paths$1.targetDist,
     WARN_AFTER_BUNDLE_GZIP_SIZE,
     WARN_AFTER_CHUNK_GZIP_SIZE
   );
@@ -199,70 +177,5 @@ async function build(configs, isCi) {
   return { stats };
 }
 
-async function buildFrontend(options) {
-  const { targetDir, writeStats, configPaths } = options;
-  const { name } = await fs__default.default.readJson(path.resolve(targetDir, "package.json"));
-  await buildBundle({
-    targetDir,
-    entry: "src/index",
-    parallelism: parallel.getEnvironmentParallelism(),
-    statsJsonEnabled: writeStats,
-    moduleFederation: moduleFederation.getModuleFederationOptions(
-      name,
-      options.isModuleFederationRemote
-    ),
-    ...await config.loadCliConfig({
-      args: configPaths,
-      fromPackage: name
-    })
-  });
-}
-
-const BUNDLE_FILE = "bundle.tar.gz";
-const SKELETON_FILE = "skeleton.tar.gz";
-async function buildBackend(options) {
-  const { targetDir, skipBuildDependencies, configPaths, minify } = options;
-  const pkg = await fs__default.default.readJson(path.resolve(targetDir, "package.json"));
-  await createDistWorkspace.buildPackage({
-    targetDir,
-    packageJson: pkg,
-    outputs: /* @__PURE__ */ new Set([createDistWorkspace.Output.cjs]),
-    minify,
-    workspacePackages: await cliNode.PackageGraph.listTargetPackages()
-  });
-  const tmpDir = await fs__default.default.mkdtemp(path.resolve(os__default.default.tmpdir(), "backstage-bundle"));
-  try {
-    await createDistWorkspace.createDistWorkspace([pkg.name], {
-      targetDir: tmpDir,
-      configPaths,
-      buildDependencies: !skipBuildDependencies,
-      buildExcludes: [pkg.name],
-      parallelism: parallel.getEnvironmentParallelism(),
-      skeleton: SKELETON_FILE,
-      minify
-    });
-    const distDir = path.resolve(targetDir, "dist");
-    await fs__default.default.remove(distDir);
-    await fs__default.default.mkdir(distDir);
-    await fs__default.default.move(
-      path.resolve(tmpDir, SKELETON_FILE),
-      path.resolve(distDir, SKELETON_FILE)
-    );
-    await tar__default.default.create(
-      {
-        file: path.resolve(distDir, BUNDLE_FILE),
-        cwd: tmpDir,
-        portable: true,
-        noMtime: true,
-        gzip: true
-      },
-      [""]
-    );
-  } finally {
-    await fs__default.default.remove(tmpDir);
-  }
-}
-
-exports.buildBackend = buildBackend;
-exports.buildFrontend = buildFrontend;
-//# sourceMappingURL=buildBackend-DXvz7jvh.cjs.js.map
+exports.buildBundle = buildBundle;
+//# sourceMappingURL=bundle.cjs.js.map