@backstage/cli 0.30.0-next.2 → 0.30.0-next.3

package/CHANGELOG.md

@@ -1,5 +1,38 @@
 # @backstage/cli
 
+## 0.30.0-next.3
+
+### Minor Changes
+
+- b30e788: The `new` command is now powered by a new template system that allows you to define your own templates in a declarative way, as well as import existing templates from external sources. See the [CLI templates documentation](https://backstage.io/docs/tooling/cli/templates) for more information.
+
+  The following flags for the `new` command have been deprecated and will be removed in a future release:
+
+  - `--license=<license>`: Configure the global `license` instead.
+  - `--no-private`: Configure the global `private` instead.
+  - `--baseVersion=<version>`: Configure the global `version` instead.
+  - `--npmRegistry=<url>`: Configure the global `publishRegistry` instead.
+  - `--scope=<scope>`: Configure the global `namePrefix` and/or `namePluginInfix` instead.
+
+  As part of this change the template IDs and their options have changed. The following backwards compatibility mappings for the `--select` and `--option` flags are enabled when using the default set of templates, but they will also be removed in the future:
+
+  - `--select=plugin` is mapped to `--select=frontend-plugin` instead.
+  - `--option=id=<id>` is mapped to `--option=pluginId=<id>` instead.
+
+### Patch Changes
+
+- Updated dependencies
+  - @backstage/cli-node@0.2.13-next.1
+  - @backstage/config-loader@1.9.6-next.0
+  - @backstage/catalog-model@1.7.3
+  - @backstage/cli-common@0.1.15
+  - @backstage/config@1.3.2
+  - @backstage/errors@1.2.7
+  - @backstage/eslint-plugin@0.1.10
+  - @backstage/integration@1.16.1
+  - @backstage/release-manifests@0.0.12
+  - @backstage/types@1.2.1
+
 ## 0.30.0-next.2
 
 ### Patch Changes

package/dist/commands/index.cjs.js

@@ -118,6 +118,9 @@ function registerCommands(program) {
     "Pre-fill options for the creation process",
     (opt, arr) => [...arr, opt],
     []
+  ).option(
+    "--skip-install",
+    `Skips running 'yarn install' and 'yarn lint --fix'`
   ).option("--scope <scope>", "The scope to use for new packages").option(
     "--npm-registry <URL>",
     "The package registry to use for new packages"

package/dist/commands/new/new.cjs.js

@@ -2,21 +2,46 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var os = require('os');
-var fs = require('fs-extra');
-var path = require('path');
-var FactoryRegistry = require('../../lib/new/FactoryRegistry.cjs.js');
-var cliNode = require('@backstage/cli-node');
-var paths = require('../../lib/paths.cjs.js');
-var errors = require('@backstage/errors');
-var tasks = require('../../lib/tasks.cjs.js');
+var createNewPackage = require('../../lib/new/createNewPackage.cjs.js');
 
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
-
-var os__default = /*#__PURE__*/_interopDefaultCompat(os);
-var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
-
-function parseOptions(optionStrings) {
+var _new = async (opts) => {
+  const {
+    option: rawArgOptions,
+    select: preselectedTemplateId,
+    skipInstall,
+    scope,
+    private: isPrivate,
+    ...otherGlobals
+  } = opts;
+  const prefilledParams = parseParams(rawArgOptions);
+  let pluginInfix = void 0;
+  let packagePrefix = void 0;
+  if (scope) {
+    const backstagePrefix = scope.startsWith("backstage") ? "" : "backstage-";
+    packagePrefix = scope.includes("/") ? `@${scope}${backstagePrefix}` : `@${scope}/${backstagePrefix}`;
+    pluginInfix = scope.includes("backstage") ? "plugin-" : "backstage-plugin-";
+  }
+  if (isPrivate === false || // set to false with --no-private flag
+  Object.values(otherGlobals).filter(Boolean).length !== 0) {
+    console.warn(
+      `Global template configuration via CLI flags is deprecated, see https://backstage.io/docs/cli/new for information on how to configure package templating`
+    );
+  }
+  await createNewPackage.createNewPackage({
+    prefilledParams,
+    preselectedTemplateId,
+    configOverrides: {
+      license: otherGlobals.license,
+      version: otherGlobals.baseVersion,
+      private: isPrivate,
+      publishRegistry: otherGlobals.npmRegistry,
+      packageNamePrefix: packagePrefix,
+      packageNamePluginInfix: pluginInfix
+    },
+    skipInstall
+  });
+};
+function parseParams(optionStrings) {
   const options = {};
   for (const str of optionStrings) {
     const [key] = str.split("=", 1);
@@ -30,72 +55,6 @@ function parseOptions(optionStrings) {
   }
   return options;
 }
-var _new = async (opts) => {
-  const factory = await FactoryRegistry.FactoryRegistry.interactiveSelect(opts.select);
-  const providedOptions = parseOptions(opts.option);
-  const options = await FactoryRegistry.FactoryRegistry.populateOptions(
-    factory,
-    providedOptions
-  );
-  let defaultVersion = "0.1.0";
-  if (opts.baseVersion) {
-    defaultVersion = opts.baseVersion;
-  } else {
-    const lernaVersion = await fs__default.default.readJson(paths.paths.resolveTargetRoot("lerna.json")).then((pkg) => pkg.version).catch(() => void 0);
-    if (lernaVersion) {
-      defaultVersion = lernaVersion;
-    }
-  }
-  const tempDirs = new Array();
-  async function createTemporaryDirectory(name) {
-    const dir = await fs__default.default.mkdtemp(path.join(os__default.default.tmpdir(), name));
-    tempDirs.push(dir);
-    return dir;
-  }
-  const license = opts.license ?? "Apache-2.0";
-  let modified = false;
-  try {
-    await factory.create(options, {
-      isMonoRepo: await cliNode.isMonoRepo(),
-      defaultVersion,
-      license,
-      scope: opts.scope?.replace(/^@/, ""),
-      npmRegistry: opts.npmRegistry,
-      private: Boolean(opts.private),
-      createTemporaryDirectory,
-      markAsModified() {
-        modified = true;
-      }
-    });
-    tasks.Task.log();
-    tasks.Task.log(`\u{1F389}  Successfully created ${factory.name}`);
-    tasks.Task.log();
-  } catch (error) {
-    errors.assertError(error);
-    tasks.Task.error(error.message);
-    if (modified) {
-      tasks.Task.log("It seems that something went wrong in the creation process \u{1F914}");
-      tasks.Task.log();
-      tasks.Task.log(
-        "We have left the changes that were made intact in case you want to"
-      );
-      tasks.Task.log(
-        "continue manually, but you can also revert the changes and try again."
-      );
-      tasks.Task.error(`\u{1F525}  Failed to create ${factory.name}!`);
-    }
-  } finally {
-    for (const dir of tempDirs) {
-      try {
-        await fs__default.default.remove(dir);
-      } catch (error) {
-        console.error(
-          `Failed to remove temporary directory '${dir}', ${error}`
-        );
-      }
-    }
-  }
-};
 
 exports.default = _new;
 //# sourceMappingURL=new.cjs.js.map

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

@@ -0,0 +1,32 @@
+'use strict';
+
+var collectPortableTemplateInput = require('./preparation/collectPortableTemplateInput.cjs.js');
+var loadPortableTemplateConfig = require('./preparation/loadPortableTemplateConfig.cjs.js');
+var selectTemplateInteractively = require('./preparation/selectTemplateInteractively.cjs.js');
+var loadPortableTemplate = require('./preparation/loadPortableTemplate.cjs.js');
+var executePortableTemplate = require('./execution/executePortableTemplate.cjs.js');
+
+async function createNewPackage(options) {
+  const config = await loadPortableTemplateConfig.loadPortableTemplateConfig({
+    overrides: options.configOverrides
+  });
+  const selectedTemplate = await selectTemplateInteractively.selectTemplateInteractively(
+    config,
+    options.preselectedTemplateId
+  );
+  const template = await loadPortableTemplate.loadPortableTemplate(selectedTemplate);
+  const input = await collectPortableTemplateInput.collectPortableTemplateInput({
+    config,
+    template,
+    prefilledParams: options.prefilledParams
+  });
+  await executePortableTemplate.executePortableTemplate({
+    config,
+    template,
+    input,
+    skipInstall: options.skipInstall
+  });
+}
+
+exports.createNewPackage = createNewPackage;
+//# sourceMappingURL=createNewPackage.cjs.js.map

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

@@ -0,0 +1,16 @@
+'use strict';
+
+const defaultTemplates = [
+  "@backstage/cli/templates/frontend-plugin",
+  "@backstage/cli/templates/backend-plugin",
+  "@backstage/cli/templates/backend-plugin-module",
+  "@backstage/cli/templates/plugin-web-library",
+  "@backstage/cli/templates/plugin-node-library",
+  "@backstage/cli/templates/plugin-common-library",
+  "@backstage/cli/templates/web-library",
+  "@backstage/cli/templates/node-library",
+  "@backstage/cli/templates/scaffolder-backend-module"
+];
+
+exports.defaultTemplates = defaultTemplates;
+//# sourceMappingURL=defaultTemplates.cjs.js.map

package/dist/lib/new/execution/PortableTemplater.cjs.js

@@ -0,0 +1,91 @@
+'use strict';
+
+var handlebars = require('handlebars');
+var camelCase = require('lodash/camelCase');
+var kebabCase = require('lodash/kebabCase');
+var lowerCase = require('lodash/lowerCase');
+var snakeCase = require('lodash/snakeCase');
+var startCase = require('lodash/startCase');
+var upperCase = require('lodash/upperCase');
+var upperFirst = require('lodash/upperFirst');
+var lowerFirst = require('lodash/lowerFirst');
+var Lockfile = require('../../versioning/Lockfile.cjs.js');
+require('minimatch');
+require('@manypkg/get-packages');
+require('chalk');
+require('../../yarn.cjs.js');
+require('../../run.cjs.js');
+var paths = require('../../paths.cjs.js');
+var version = require('../../version.cjs.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var handlebars__default = /*#__PURE__*/_interopDefaultCompat(handlebars);
+var camelCase__default = /*#__PURE__*/_interopDefaultCompat(camelCase);
+var kebabCase__default = /*#__PURE__*/_interopDefaultCompat(kebabCase);
+var lowerCase__default = /*#__PURE__*/_interopDefaultCompat(lowerCase);
+var snakeCase__default = /*#__PURE__*/_interopDefaultCompat(snakeCase);
+var startCase__default = /*#__PURE__*/_interopDefaultCompat(startCase);
+var upperCase__default = /*#__PURE__*/_interopDefaultCompat(upperCase);
+var upperFirst__default = /*#__PURE__*/_interopDefaultCompat(upperFirst);
+var lowerFirst__default = /*#__PURE__*/_interopDefaultCompat(lowerFirst);
+
+const builtInHelpers = {
+  camelCase: camelCase__default.default,
+  kebabCase: kebabCase__default.default,
+  lowerCase: lowerCase__default.default,
+  snakeCase: snakeCase__default.default,
+  startCase: startCase__default.default,
+  upperCase: upperCase__default.default,
+  upperFirst: upperFirst__default.default,
+  lowerFirst: lowerFirst__default.default
+};
+class PortableTemplater {
+  static async create(options = {}) {
+    let lockfile;
+    try {
+      lockfile = await Lockfile.Lockfile.load(paths.paths.resolveTargetRoot("yarn.lock"));
+    } catch {
+    }
+    const versionProvider = version.createPackageVersionProvider(lockfile);
+    const templater = new PortableTemplater(
+      {
+        versionQuery(name, versionHint) {
+          return versionProvider(
+            name,
+            typeof versionHint === "string" ? versionHint : void 0
+          );
+        }
+      },
+      options.values ?? {}
+    );
+    if (options.templatedValues) {
+      templater.appendTemplatedValues(options.templatedValues);
+    }
+    return templater;
+  }
+  #templater;
+  #values;
+  constructor(helpers, values) {
+    this.#templater = handlebars__default.default.create();
+    this.#templater.registerHelper(builtInHelpers);
+    if (helpers) {
+      this.#templater.registerHelper(helpers);
+    }
+    this.#values = values;
+  }
+  template(content) {
+    return this.#templater.compile(content, {
+      strict: true
+    })(this.#values);
+  }
+  appendTemplatedValues(record) {
+    const newValues = Object.fromEntries(
+      Object.entries(record).map(([key, value]) => [key, this.template(value)])
+    );
+    this.#values = { ...this.#values, ...newValues };
+  }
+}
+
+exports.PortableTemplater = PortableTemplater;
+//# sourceMappingURL=PortableTemplater.cjs.js.map

package/dist/lib/new/execution/executePortableTemplate.cjs.js

@@ -0,0 +1,54 @@
+'use strict';
+
+var errors = require('@backstage/errors');
+var codeowners = require('../../codeowners/codeowners.cjs.js');
+var tasks = require('../../tasks.cjs.js');
+var installNewPackage = require('./installNewPackage.cjs.js');
+var writeTemplateContents = require('./writeTemplateContents.cjs.js');
+
+async function executePortableTemplate(options) {
+  const { template, input } = options;
+  let modified = false;
+  try {
+    const { targetDir } = await tasks.Task.forItem(
+      "templating",
+      input.packagePath,
+      () => writeTemplateContents.writeTemplateContents(template, input)
+    );
+    modified = true;
+    await installNewPackage.installNewPackage(input);
+    if (input.owner) {
+      await codeowners.addCodeownersEntry(targetDir, input.owner);
+    }
+    if (!options.skipInstall) {
+      await tasks.Task.forCommand("yarn install", {
+        cwd: targetDir,
+        optional: true
+      });
+      await tasks.Task.forCommand("yarn lint --fix", {
+        cwd: targetDir,
+        optional: true
+      });
+    }
+    tasks.Task.log();
+    tasks.Task.log(`\u{1F389}  Successfully created ${template.name}`);
+    tasks.Task.log();
+  } catch (error) {
+    errors.assertError(error);
+    tasks.Task.error(error.message);
+    if (modified) {
+      tasks.Task.log("It seems that something went wrong in the creation process \u{1F914}");
+      tasks.Task.log();
+      tasks.Task.log(
+        "We have left the changes that were made intact in case you want to"
+      );
+      tasks.Task.log(
+        "continue manually, but you can also revert the changes and try again."
+      );
+      tasks.Task.error(`\u{1F525}  Failed to create ${template.name}!`);
+    }
+  }
+}
+
+exports.executePortableTemplate = executePortableTemplate;
+//# sourceMappingURL=executePortableTemplate.cjs.js.map

package/dist/lib/new/execution/installNewPackage.cjs.js

@@ -0,0 +1,127 @@
+'use strict';
+
+var fs = require('fs-extra');
+var upperFirst = require('lodash/upperFirst');
+var camelCase = require('lodash/camelCase');
+var paths = require('../../paths.cjs.js');
+var tasks = require('../../tasks.cjs.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+var upperFirst__default = /*#__PURE__*/_interopDefaultCompat(upperFirst);
+var camelCase__default = /*#__PURE__*/_interopDefaultCompat(camelCase);
+
+async function installNewPackage(input) {
+  switch (input.roleParams.role) {
+    case "web-library":
+    case "node-library":
+    case "common-library":
+    case "plugin-web-library":
+    case "plugin-node-library":
+    case "plugin-common-library":
+      return;
+    // No installation action needed for library packages
+    case "frontend-plugin":
+      await addDependency(input, "package/app/package.json");
+      await tryAddFrontendLegacy(input);
+      return;
+    case "frontend-plugin-module":
+      await addDependency(input, "package/app/package.json");
+      return;
+    case "backend-plugin":
+      await addDependency(input, "package/backend/package.json");
+      await tryAddBackend(input);
+      return;
+    case "backend-plugin-module":
+      await addDependency(input, "package/backend/package.json");
+      await tryAddBackend(input);
+      return;
+    default:
+      throw new Error(
+        `Unsupported role ${input.roleParams.role}`
+      );
+  }
+}
+async function addDependency(input, path) {
+  const pkgJsonPath = paths.paths.resolveTargetRoot(path);
+  const pkgJson = await fs__default.default.readJson(pkgJsonPath).catch((error) => {
+    if (error.code === "ENOENT") {
+      return void 0;
+    }
+    throw error;
+  });
+  if (!pkgJson) {
+    return;
+  }
+  try {
+    pkgJson.dependencies = {
+      ...pkgJson.dependencies,
+      [input.packageName]: `workspace:^`
+    };
+    await fs__default.default.writeJson(path, pkgJson, { spaces: 2 });
+  } catch (error) {
+    throw new Error(`Failed to add package dependencies, ${error}`);
+  }
+}
+async function tryAddFrontendLegacy(input) {
+  const { roleParams } = input;
+  if (roleParams.role !== "frontend-plugin") {
+    throw new Error(
+      "add-frontend-legacy can only be used for frontend plugins"
+    );
+  }
+  const appDefinitionPath = paths.paths.resolveTargetRoot("packages/app/src/App.tsx");
+  if (!await fs__default.default.pathExists(appDefinitionPath)) {
+    return;
+  }
+  await tasks.Task.forItem("app", "adding import", async () => {
+    const content = await fs__default.default.readFile(appDefinitionPath, "utf8");
+    const revLines = content.split("\n").reverse();
+    const lastImportIndex = revLines.findIndex(
+      (line) => line.match(/ from ("|').*("|')/)
+    );
+    const lastRouteIndex = revLines.findIndex(
+      (line) => line.match(/<\/FlatRoutes/)
+    );
+    if (lastImportIndex !== -1 && lastRouteIndex !== -1) {
+      const extensionName = upperFirst__default.default(`${camelCase__default.default(roleParams.pluginId)}Page`);
+      const importLine = `import { ${extensionName} } from '${input.packageName}';`;
+      if (!content.includes(importLine)) {
+        revLines.splice(lastImportIndex, 0, importLine);
+      }
+      const componentLine = `<Route path="/${roleParams.pluginId}" element={<${extensionName} />} />`;
+      if (!content.includes(componentLine)) {
+        const [indentation] = revLines[lastRouteIndex + 1].match(/^\s*/) ?? [];
+        revLines.splice(lastRouteIndex + 1, 0, indentation + componentLine);
+      }
+      const newContent = revLines.reverse().join("\n");
+      await fs__default.default.writeFile(appDefinitionPath, newContent, "utf8");
+    }
+  });
+}
+async function tryAddBackend(input) {
+  const backendIndexPath = paths.paths.resolveTargetRoot(
+    "packages/backend/src/index.ts"
+  );
+  if (!await fs__default.default.pathExists(backendIndexPath)) {
+    return;
+  }
+  await tasks.Task.forItem("backend", `adding ${input.packageName}`, async () => {
+    const content = await fs__default.default.readFile(backendIndexPath, "utf8");
+    const lines = content.split("\n");
+    const backendAddLine = `backend.add(import('${input.packageName}'));`;
+    const backendStartIndex = lines.findIndex(
+      (line) => line.match(/backend.start/)
+    );
+    if (backendStartIndex !== -1) {
+      const [indentation] = lines[backendStartIndex].match(/^\s*/);
+      lines.splice(backendStartIndex, 0, `${indentation}${backendAddLine}`);
+      const newContent = lines.join("\n");
+      await fs__default.default.writeFile(backendIndexPath, newContent, "utf8");
+    }
+  });
+}
+
+exports.installNewPackage = installNewPackage;
+//# sourceMappingURL=installNewPackage.cjs.js.map

package/dist/lib/new/execution/writeTemplateContents.cjs.js

@@ -0,0 +1,111 @@
+'use strict';
+
+var fs = require('fs-extra');
+var path = require('path');
+var paths = require('../../paths.cjs.js');
+var errors = require('@backstage/errors');
+var cliNode = require('@backstage/cli-node');
+var PortableTemplater = require('./PortableTemplater.cjs.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+
+async function writeTemplateContents(template, input) {
+  const targetDir = paths.paths.resolveTargetRoot(input.packagePath);
+  if (await fs__default.default.pathExists(targetDir)) {
+    throw new errors.InputError(`Package '${input.packagePath}' already exists`);
+  }
+  try {
+    const isMonoRepo = await cliNode.isMonoRepo();
+    const { role, ...roleValues } = input.roleParams;
+    const templater = await PortableTemplater.PortableTemplater.create({
+      values: {
+        ...roleValues,
+        packageName: input.packageName
+      },
+      templatedValues: template.values
+    });
+    if (!isMonoRepo) {
+      await fs__default.default.writeJson(
+        path.resolve(targetDir, "tsconfig.json"),
+        {
+          extends: "@backstage/cli/config/tsconfig.json",
+          include: ["src", "dev", "migrations"],
+          exclude: ["node_modules"],
+          compilerOptions: {
+            outDir: "dist-types",
+            rootDir: "."
+          }
+        },
+        { spaces: 2 }
+      );
+    }
+    for (const file of template.files) {
+      const destPath = path.resolve(targetDir, file.path);
+      await fs__default.default.ensureDir(path.dirname(destPath));
+      let content = file.syntax === "handlebars" ? templater.template(file.content) : file.content;
+      if (file.path === "package.json") {
+        try {
+          content = injectPackageJsonInput(input, content);
+        } catch (error) {
+          throw new errors.ForwardedError(
+            "Failed to transform templated package.json",
+            error
+          );
+        }
+      }
+      await fs__default.default.writeFile(destPath, content).catch((error) => {
+        throw new errors.ForwardedError(`Failed to copy file to ${destPath}`, error);
+      });
+    }
+    return { targetDir };
+  } catch (error) {
+    await fs__default.default.rm(targetDir, { recursive: true, force: true, maxRetries: 10 });
+    throw error;
+  }
+}
+function injectPackageJsonInput(input, content) {
+  const pkgJson = JSON.parse(content);
+  const toAdd = new Array();
+  if (pkgJson.version) {
+    pkgJson.version = input.version;
+  } else {
+    toAdd.push(["version", input.version]);
+  }
+  if (pkgJson.license) {
+    pkgJson.license = input.license;
+  } else {
+    toAdd.push(["license", input.license]);
+  }
+  if (input.private) {
+    if (pkgJson.private === false) {
+      pkgJson.private = true;
+    } else if (!pkgJson.private) {
+      toAdd.push(["private", true]);
+    }
+  } else {
+    delete pkgJson.private;
+  }
+  if (input.publishRegistry) {
+    if (pkgJson.publishConfig) {
+      pkgJson.publishConfig = {
+        ...pkgJson.publishConfig,
+        registry: input.publishRegistry
+      };
+    } else {
+      toAdd.push(["publishConfig", { registry: input.publishRegistry }]);
+    }
+  }
+  const entries = Object.entries(pkgJson);
+  const nameIndex = entries.findIndex(([name]) => name === "name");
+  if (nameIndex === -1) {
+    throw new Error("templated package.json does not contain a name field");
+  }
+  entries.splice(nameIndex + 1, 0, ...toAdd);
+  return JSON.stringify(Object.fromEntries(entries), null, 2);
+}
+
+exports.injectPackageJsonInput = injectPackageJsonInput;
+exports.writeTemplateContents = writeTemplateContents;
+//# sourceMappingURL=writeTemplateContents.cjs.js.map