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

package/dist/lib/experimental/IpcServer.cjs.js

@@ -0,0 +1,60 @@
+'use strict';
+
+var errors = require('@backstage/errors');
+
+const requestType = "@backstage/cli/channel/request";
+const responseType = "@backstage/cli/channel/response";
+class IpcServer {
+  #generation = 1;
+  #methods = /* @__PURE__ */ new Map();
+  addChild(child) {
+    const generation = this.#generation++;
+    const sendMessage = child.send?.bind(child);
+    if (!sendMessage) {
+      return;
+    }
+    const messageListener = (request) => {
+      if (request.type !== requestType) {
+        return;
+      }
+      const handler = this.#methods.get(request.method);
+      if (!handler) {
+        sendMessage({
+          type: responseType,
+          id: request.id,
+          error: {
+            name: "NotFoundError",
+            message: `No handler registered for method ${request.method}`
+          }
+        });
+        return;
+      }
+      Promise.resolve().then(() => handler(request.body, { generation })).then(
+        (response) => sendMessage({
+          type: responseType,
+          id: request.id,
+          body: response
+        })
+      ).catch(
+        (error) => sendMessage({
+          type: responseType,
+          id: request.id,
+          error: errors.serializeError(error)
+        })
+      );
+    };
+    child.addListener("message", messageListener);
+    child.addListener("exit", () => {
+      child.removeListener("message", messageListener);
+    });
+  }
+  registerMethod(method, handler) {
+    if (this.#methods.has(method)) {
+      throw new Error(`A handler is already registered for method ${method}`);
+    }
+    this.#methods.set(method, handler);
+  }
+}
+
+exports.IpcServer = IpcServer;
+//# sourceMappingURL=IpcServer.cjs.js.map

package/dist/lib/experimental/ServerDataStore.cjs.js

@@ -0,0 +1,36 @@
+'use strict';
+
+class ServerDataStore {
+  static bind(server) {
+    const store = /* @__PURE__ */ new Map();
+    server.registerMethod(
+      "DevDataStore.save",
+      async (request, { generation }) => {
+        const { key, data } = request;
+        if (!key) {
+          throw new Error("Key is required in DevDataStore.save");
+        }
+        const item = store.get(key);
+        if (!item) {
+          store.set(key, { generation, data });
+          return { saved: true };
+        }
+        if (item.generation > generation) {
+          return { saved: false };
+        }
+        store.set(key, { generation, data });
+        return { saved: true };
+      }
+    );
+    server.registerMethod(
+      "DevDataStore.load",
+      async (request) => {
+        const item = store.get(request.key);
+        return { loaded: Boolean(item), data: item?.data };
+      }
+    );
+  }
+}
+
+exports.ServerDataStore = ServerDataStore;
+//# sourceMappingURL=ServerDataStore.cjs.js.map

package/dist/lib/experimental/startBackendExperimental.cjs.js

@@ -0,0 +1,128 @@
+'use strict';
+
+var chokidar = require('chokidar');
+var ctrlcWindows = require('ctrlc-windows');
+var IpcServer = require('./IpcServer.cjs.js');
+var ServerDataStore = require('./ServerDataStore.cjs.js');
+var debounce = require('lodash/debounce');
+var url = require('url');
+var path = require('path');
+var paths = require('../paths.cjs.js');
+var spawn = require('cross-spawn');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var debounce__default = /*#__PURE__*/_interopDefaultCompat(debounce);
+var spawn__default = /*#__PURE__*/_interopDefaultCompat(spawn);
+
+const loaderArgs = [
+  "--enable-source-maps",
+  "--require",
+  require.resolve("@backstage/cli/config/nodeTransform.cjs")
+  // TODO: Support modules, although there's currently no way to load them since import() is transpiled tp require()
+];
+async function startBackendExperimental(options) {
+  const envEnv = process.env;
+  if (!envEnv.NODE_ENV) {
+    envEnv.NODE_ENV = "development";
+  }
+  const server = new IpcServer.IpcServer();
+  ServerDataStore.ServerDataStore.bind(server);
+  let exiting = false;
+  let firstStart = true;
+  let child;
+  let watcher = void 0;
+  let shutdownPromise = void 0;
+  const watchedPaths = /* @__PURE__ */ new Set();
+  const restart = debounce__default.default(async () => {
+    if (firstStart) {
+      firstStart = false;
+    } else {
+      console.log();
+      console.log("Change detected, restarting the development server...");
+      console.log();
+    }
+    if (shutdownPromise) {
+      return;
+    }
+    if (child && !child.killed && child.exitCode === null) {
+      shutdownPromise = new Promise((resolve) => child.once("exit", resolve));
+      if (process.platform === "win32" && child.pid) {
+        ctrlcWindows.ctrlc(child.pid);
+      } else {
+        child.kill();
+      }
+      await shutdownPromise;
+      shutdownPromise = void 0;
+    }
+    if (exiting) {
+      return;
+    }
+    const optionArgs = new Array();
+    if (options.inspectEnabled) {
+      const inspect = typeof options.inspectEnabled === "string" ? `--inspect=${options.inspectEnabled}` : "--inspect";
+      optionArgs.push(inspect);
+    } else if (options.inspectBrkEnabled) {
+      const inspect = typeof options.inspectBrkEnabled === "string" ? `--inspect-brk=${options.inspectBrkEnabled}` : "--inspect-brk";
+      optionArgs.push(inspect);
+    }
+    if (options.require) {
+      optionArgs.push(`--require=${options.require}`);
+    }
+    const userArgs = process.argv.slice(["node", "backstage-cli", "package", "start"].length).filter((arg) => !optionArgs.includes(arg));
+    child = spawn__default.default(
+      process.execPath,
+      [...loaderArgs, ...optionArgs, options.entry, ...userArgs],
+      {
+        stdio: ["ignore", "inherit", "inherit", "ipc"],
+        env: {
+          ...process.env,
+          BACKSTAGE_CLI_CHANNEL: "1",
+          ESBK_TSCONFIG_PATH: paths.paths.resolveTargetRoot("tsconfig.json")
+        },
+        serialization: "advanced"
+      }
+    );
+    server.addChild(child);
+    child.on("message", (data) => {
+      if (!watcher) {
+        return;
+      }
+      if (typeof data === "object" && data?.type === "watch") {
+        let path$1 = data.path;
+        if (path$1.startsWith("file:")) {
+          path$1 = url.fileURLToPath(path$1);
+        }
+        if (path.isAbsolute(path$1) && !watchedPaths.has(path$1)) {
+          watchedPaths.add(path$1);
+          watcher.add(path$1);
+        }
+      }
+    });
+  }, 100);
+  restart();
+  watcher = chokidar.watch(["./package.json"], {
+    cwd: process.cwd(),
+    ignoreInitial: true,
+    ignorePermissionErrors: true
+  }).on("all", restart);
+  process.stdin.on("data", restart);
+  const exitPromise = new Promise((resolveExitPromise) => {
+    async function handleSignal(signal) {
+      exiting = true;
+      if (child && child.exitCode === null) {
+        await new Promise((resolve) => {
+          child.on("close", resolve);
+          child.kill(signal);
+        });
+      }
+      resolveExitPromise();
+    }
+    process.once("SIGINT", handleSignal);
+    process.once("SIGTERM", handleSignal);
+  });
+  return () => exitPromise;
+}
+
+exports.startBackendExperimental = startBackendExperimental;
+//# sourceMappingURL=startBackendExperimental.cjs.js.map

package/dist/lib/new/FactoryRegistry.cjs.js

@@ -0,0 +1,96 @@
+'use strict';
+
+var chalk = require('chalk');
+var inquirer = require('inquirer');
+var index = require('./factories/index.cjs.js');
+var partition = require('lodash/partition');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var chalk__default = /*#__PURE__*/_interopDefaultCompat(chalk);
+var inquirer__default = /*#__PURE__*/_interopDefaultCompat(inquirer);
+var partition__default = /*#__PURE__*/_interopDefaultCompat(partition);
+
+function applyPromptMessageTransforms(prompt, transforms) {
+  return {
+    ...prompt,
+    message: prompt.message && (async (answers) => {
+      if (typeof prompt.message === "function") {
+        return transforms.message(await prompt.message(answers));
+      }
+      return transforms.message(await prompt.message);
+    }),
+    validate: prompt.validate && (async (...args) => {
+      const result = await prompt.validate(...args);
+      if (typeof result === "string") {
+        return transforms.error(result);
+      }
+      return result;
+    })
+  };
+}
+class FactoryRegistry {
+  static factoryMap = new Map(
+    Object.values(index).map((factory) => [factory.name, factory])
+  );
+  static async interactiveSelect(preselected) {
+    let selected = preselected;
+    if (!selected) {
+      const answers = await inquirer__default.default.prompt([
+        {
+          type: "list",
+          name: "name",
+          message: "What do you want to create?",
+          choices: Array.from(this.factoryMap.values()).map((factory2) => ({
+            name: `${factory2.name} - ${factory2.description}`,
+            value: factory2.name
+          }))
+        }
+      ]);
+      selected = answers.name;
+    }
+    const factory = this.factoryMap.get(selected);
+    if (!factory) {
+      throw new Error(`Unknown selection '${selected}'`);
+    }
+    return factory;
+  }
+  static async populateOptions(factory, provided) {
+    let currentOptions = provided;
+    if (factory.optionsDiscovery) {
+      const discoveredOptions = await factory.optionsDiscovery();
+      currentOptions = {
+        ...currentOptions,
+        ...discoveredOptions
+      };
+    }
+    if (factory.optionsPrompts) {
+      const [hasAnswers, needsAnswers] = partition__default.default(
+        factory.optionsPrompts,
+        (option) => option.name in currentOptions
+      );
+      for (const option of hasAnswers) {
+        const value = provided[option.name];
+        if (option.validate) {
+          const result = option.validate(value);
+          if (result !== true) {
+            throw new Error(`Invalid option '${option.name}'. ${result}`);
+          }
+        }
+      }
+      currentOptions = await inquirer__default.default.prompt(
+        needsAnswers.map(
+          (option) => applyPromptMessageTransforms(option, {
+            message: chalk__default.default.blue,
+            error: chalk__default.default.red
+          })
+        ),
+        currentOptions
+      );
+    }
+    return currentOptions;
+  }
+}
+
+exports.FactoryRegistry = FactoryRegistry;
+//# sourceMappingURL=FactoryRegistry.cjs.js.map

package/dist/lib/new/factories/backendModule.cjs.js

@@ -0,0 +1,82 @@
+'use strict';
+
+var fs = require('fs-extra');
+var chalk = require('chalk');
+var camelCase = require('lodash/camelCase');
+var paths = require('../../paths.cjs.js');
+var codeowners = require('../../codeowners/codeowners.cjs.js');
+var types = require('../types.cjs.js');
+var tasks = require('../../tasks.cjs.js');
+var prompts = require('./common/prompts.cjs.js');
+var tasks$1 = require('./common/tasks.cjs.js');
+var util = require('./common/util.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);
+var camelCase__default = /*#__PURE__*/_interopDefaultCompat(camelCase);
+
+const backendModule = types.createFactory({
+  name: "backend-module",
+  description: "A new backend module that extends an existing backend plugin with additional features",
+  optionsDiscovery: async () => ({
+    codeOwnersPath: await codeowners.getCodeownersFilePath(paths.paths.targetRoot)
+  }),
+  optionsPrompts: [prompts.pluginIdPrompt(), prompts.moduleIdIdPrompt(), prompts.ownerPrompt()],
+  async create(options, ctx) {
+    const { id: pluginId, moduleId } = options;
+    const dirName = `${pluginId}-backend-module-${moduleId}`;
+    const name = util.resolvePackageName({
+      baseName: dirName,
+      scope: ctx.scope,
+      plugin: true
+    });
+    tasks.Task.log();
+    tasks.Task.log(`Creating backend module ${chalk__default.default.cyan(name)}`);
+    const targetDir = ctx.isMonoRepo ? paths.paths.resolveTargetRoot("plugins", dirName) : paths.paths.resolveTargetRoot(`backstage-plugin-${dirName}`);
+    const moduleCamelCase = camelCase__default.default(moduleId);
+    const modulePascalCase = moduleCamelCase[0].toUpperCase() + moduleCamelCase.slice(1);
+    const moduleVar = `${camelCase__default.default(pluginId)}Module${modulePascalCase}`;
+    await tasks$1.executePluginPackageTemplate(ctx, {
+      targetDir,
+      templateName: "default-backend-module",
+      values: {
+        pluginId,
+        moduleId,
+        name,
+        moduleVar,
+        packageVersion: ctx.defaultVersion,
+        privatePackage: ctx.private,
+        npmRegistry: ctx.npmRegistry,
+        license: ctx.license
+      }
+    });
+    if (await fs__default.default.pathExists(paths.paths.resolveTargetRoot("packages/backend"))) {
+      await tasks.Task.forItem("backend", "adding dependency", async () => {
+        await tasks.addPackageDependency(
+          paths.paths.resolveTargetRoot("packages/backend/package.json"),
+          {
+            dependencies: {
+              [name]: `^${ctx.defaultVersion}`
+            }
+          }
+        );
+      });
+    }
+    await tasks.addToBackend(name, {
+      type: "module"
+    });
+    if (options.owner) {
+      await codeowners.addCodeownersEntry(`/plugins/${dirName}`, options.owner);
+    }
+    await tasks.Task.forCommand("yarn install", { cwd: targetDir, optional: true });
+    await tasks.Task.forCommand("yarn lint --fix", {
+      cwd: targetDir,
+      optional: true
+    });
+  }
+});
+
+exports.backendModule = backendModule;
+//# sourceMappingURL=backendModule.cjs.js.map

package/dist/lib/new/factories/backendPlugin.cjs.js

@@ -0,0 +1,78 @@
+'use strict';
+
+var fs = require('fs-extra');
+var chalk = require('chalk');
+var camelCase = require('lodash/camelCase');
+var paths = require('../../paths.cjs.js');
+var codeowners = require('../../codeowners/codeowners.cjs.js');
+var types = require('../types.cjs.js');
+var tasks = require('../../tasks.cjs.js');
+var prompts = require('./common/prompts.cjs.js');
+var tasks$1 = require('./common/tasks.cjs.js');
+var util = require('./common/util.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);
+var camelCase__default = /*#__PURE__*/_interopDefaultCompat(camelCase);
+
+const backendPlugin = types.createFactory({
+  name: "backend-plugin",
+  description: "A new backend plugin",
+  optionsDiscovery: async () => ({
+    codeOwnersPath: await codeowners.getCodeownersFilePath(paths.paths.targetRoot)
+  }),
+  optionsPrompts: [prompts.pluginIdPrompt(), prompts.ownerPrompt()],
+  async create(options, ctx) {
+    const { id } = options;
+    const pluginId = `${id}-backend`;
+    const name = util.resolvePackageName({
+      baseName: pluginId,
+      scope: ctx.scope,
+      plugin: true
+    });
+    tasks.Task.log();
+    tasks.Task.log(`Creating backend plugin ${chalk__default.default.cyan(name)}`);
+    const targetDir = ctx.isMonoRepo ? paths.paths.resolveTargetRoot("plugins", pluginId) : paths.paths.resolveTargetRoot(`backstage-plugin-${pluginId}`);
+    await tasks$1.executePluginPackageTemplate(ctx, {
+      targetDir,
+      templateName: "default-backend-plugin",
+      values: {
+        id,
+        name,
+        pluginVar: `${camelCase__default.default(id)}Plugin`,
+        pluginVersion: ctx.defaultVersion,
+        privatePackage: ctx.private,
+        npmRegistry: ctx.npmRegistry,
+        license: ctx.license
+      }
+    });
+    if (await fs__default.default.pathExists(paths.paths.resolveTargetRoot("packages/backend"))) {
+      await tasks.Task.forItem("backend", "adding dependency", async () => {
+        await tasks.addPackageDependency(
+          paths.paths.resolveTargetRoot("packages/backend/package.json"),
+          {
+            dependencies: {
+              [name]: `^${ctx.defaultVersion}`
+            }
+          }
+        );
+      });
+    }
+    await tasks.addToBackend(name, {
+      type: "plugin"
+    });
+    if (options.owner) {
+      await codeowners.addCodeownersEntry(`/plugins/${id}`, options.owner);
+    }
+    await tasks.Task.forCommand("yarn install", { cwd: targetDir, optional: true });
+    await tasks.Task.forCommand("yarn lint --fix", {
+      cwd: targetDir,
+      optional: true
+    });
+  }
+});
+
+exports.backendPlugin = backendPlugin;
+//# sourceMappingURL=backendPlugin.cjs.js.map

package/dist/lib/new/factories/common/prompts.cjs.js

@@ -0,0 +1,57 @@
+'use strict';
+
+var codeowners = require('../../../codeowners/codeowners.cjs.js');
+
+function pluginIdPrompt() {
+  return {
+    type: "input",
+    name: "id",
+    message: "Enter the ID of the plugin [required]",
+    validate: (value) => {
+      if (!value) {
+        return "Please enter the ID of the plugin";
+      } else if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(value)) {
+        return "Plugin IDs must be lowercase and contain only letters, digits, and dashes.";
+      }
+      return true;
+    }
+  };
+}
+function moduleIdIdPrompt() {
+  return {
+    type: "input",
+    name: "moduleId",
+    message: "Enter the ID of the module [required]",
+    validate: (value) => {
+      if (!value) {
+        return "Please enter the ID of the module";
+      } else if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(value)) {
+        return "Module IDs must be lowercase and contain only letters, digits, and dashes.";
+      }
+      return true;
+    }
+  };
+}
+function ownerPrompt() {
+  return {
+    type: "input",
+    name: "owner",
+    message: "Enter an owner to add to CODEOWNERS [optional]",
+    when: (opts) => Boolean(opts.codeOwnersPath),
+    validate: (value) => {
+      if (!value) {
+        return true;
+      }
+      const ownerIds = codeowners.parseOwnerIds(value);
+      if (!ownerIds) {
+        return "The owner must be a space separated list of team names (e.g. @org/team-name), usernames (e.g. @username), or the email addresses (e.g. user@example.com).";
+      }
+      return true;
+    }
+  };
+}
+
+exports.moduleIdIdPrompt = moduleIdIdPrompt;
+exports.ownerPrompt = ownerPrompt;
+exports.pluginIdPrompt = pluginIdPrompt;
+//# sourceMappingURL=prompts.cjs.js.map

package/dist/lib/new/factories/common/tasks.cjs.js

@@ -0,0 +1,66 @@
+'use strict';
+
+var fs = require('fs-extra');
+var chalk = require('chalk');
+var path = require('path');
+var paths = require('../../../paths.cjs.js');
+var tasks = require('../../../tasks.cjs.js');
+var Lockfile = require('../../../versioning/Lockfile.cjs.js');
+require('minimatch');
+require('@manypkg/get-packages');
+require('../../../yarn.cjs.js');
+require('../../../run.cjs.js');
+var version = require('../../../version.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);
+
+async function executePluginPackageTemplate(ctx, options) {
+  const { targetDir } = options;
+  let lockfile;
+  try {
+    lockfile = await Lockfile.Lockfile.load(paths.paths.resolveTargetRoot("yarn.lock"));
+  } catch {
+  }
+  tasks.Task.section("Checking Prerequisites");
+  const shortPluginDir = path.relative(paths.paths.targetRoot, targetDir);
+  await tasks.Task.forItem("availability", shortPluginDir, async () => {
+    if (await fs__default.default.pathExists(targetDir)) {
+      throw new Error(
+        `A package with the same plugin ID already exists at ${chalk__default.default.cyan(
+          shortPluginDir
+        )}. Please try again with a different ID.`
+      );
+    }
+  });
+  const tempDir = await tasks.Task.forItem("creating", "temp dir", async () => {
+    return await ctx.createTemporaryDirectory("backstage-create");
+  });
+  tasks.Task.section("Executing Template");
+  await tasks.templatingTask(
+    paths.paths.resolveOwn("templates", options.templateName),
+    tempDir,
+    options.values,
+    version.createPackageVersionProvider(lockfile),
+    ctx.isMonoRepo
+  );
+  const pkgJsonPath = path.resolve(tempDir, "package.json");
+  if (await fs__default.default.pathExists(pkgJsonPath)) {
+    const pkgJson = await fs__default.default.readJson(pkgJsonPath);
+    await fs__default.default.writeJson(pkgJsonPath, pkgJson, { spaces: 2 });
+  }
+  tasks.Task.section("Installing");
+  await tasks.Task.forItem("moving", shortPluginDir, async () => {
+    await fs__default.default.move(tempDir, targetDir).catch((error) => {
+      throw new Error(
+        `Failed to move package from ${tempDir} to ${targetDir}, ${error.message}`
+      );
+    });
+  });
+  ctx.markAsModified();
+}
+
+exports.executePluginPackageTemplate = executePluginPackageTemplate;
+//# sourceMappingURL=tasks.cjs.js.map

package/dist/lib/new/factories/common/util.cjs.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const resolvePackageName = (options) => {
+  const { baseName, scope, plugin } = options;
+  if (scope) {
+    if (plugin) {
+      const pluginName = scope.startsWith("backstage") ? "plugin" : "backstage-plugin";
+      return scope.includes("/") ? `@${scope}${pluginName}-${baseName}` : `@${scope}/${pluginName}-${baseName}`;
+    }
+    return scope.includes("/") ? `@${scope}${baseName}` : `@${scope}/${baseName}`;
+  }
+  return plugin ? `backstage-plugin-${baseName}` : baseName;
+};
+
+exports.resolvePackageName = resolvePackageName;
+//# sourceMappingURL=util.cjs.js.map