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

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

package/dist/lib/new/preparation/collectPortableTemplateInput.cjs.js

@@ -0,0 +1,157 @@
+'use strict';
+
+var inquirer = require('inquirer');
+var codeowners = require('../../codeowners/codeowners.cjs.js');
+var paths = require('../../paths.cjs.js');
+var resolvePackageParams = require('./resolvePackageParams.cjs.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var inquirer__default = /*#__PURE__*/_interopDefaultCompat(inquirer);
+
+async function collectPortableTemplateInput(options) {
+  const { config, template, prefilledParams } = options;
+  const codeOwnersFilePath = await codeowners.getCodeownersFilePath(paths.paths.targetRoot);
+  const prompts = getPromptsForRole(template.role);
+  if (codeOwnersFilePath) {
+    prompts.push(ownerPrompt());
+  }
+  const deprecatedParams = {};
+  if (config.isUsingDefaultTemplates && prefilledParams.id) {
+    console.warn(
+      `DEPRECATION WARNING: The 'id' parameter is deprecated, use 'pluginId' instead`
+    );
+    deprecatedParams.pluginId = prefilledParams.id;
+  }
+  const parameters = {
+    ...template.values,
+    ...prefilledParams,
+    ...deprecatedParams
+  };
+  const needsAnswer = [];
+  const prefilledAnswers = {};
+  for (const prompt of prompts) {
+    if (prompt.name && parameters[prompt.name] !== void 0) {
+      prefilledAnswers[prompt.name] = parameters[prompt.name];
+    } else {
+      needsAnswer.push(prompt);
+    }
+  }
+  const promptAnswers = await inquirer__default.default.prompt(
+    needsAnswer
+  );
+  const answers = {
+    ...prefilledAnswers,
+    ...promptAnswers
+  };
+  const roleParams = {
+    role: template.role,
+    name: answers.name,
+    pluginId: answers.pluginId,
+    moduleId: answers.moduleId
+  };
+  const packageParams = resolvePackageParams.resolvePackageParams({
+    roleParams,
+    packagePrefix: config.packageNamePrefix,
+    pluginInfix: config.packageNamePluginInfix
+  });
+  return {
+    roleParams,
+    owner: answers.owner,
+    license: config.license,
+    version: config.version,
+    private: config.private,
+    publishRegistry: config.publishRegistry,
+    packageName: packageParams.packageName,
+    packagePath: packageParams.packagePath
+  };
+}
+function namePrompt() {
+  return {
+    type: "input",
+    name: "name",
+    message: "Enter the name of the package, without scope [required]",
+    validate: (value) => {
+      if (!value) {
+        return "Please enter the name of the package";
+      } else if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(value)) {
+        return "Package names must be lowercase and contain only letters, digits, and dashes.";
+      }
+      return true;
+    }
+  };
+}
+function pluginIdPrompt() {
+  return {
+    type: "input",
+    name: "pluginId",
+    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 getPromptsForRole(role) {
+  switch (role) {
+    case "web-library":
+    case "node-library":
+    case "common-library":
+      return [namePrompt()];
+    case "plugin-web-library":
+    case "plugin-node-library":
+    case "plugin-common-library":
+    case "frontend-plugin":
+    case "backend-plugin":
+      return [pluginIdPrompt()];
+    case "frontend-plugin-module":
+    case "backend-plugin-module":
+      return [pluginIdPrompt(), moduleIdIdPrompt()];
+    default:
+      return [];
+  }
+}
+function ownerPrompt() {
+  return {
+    type: "input",
+    name: "owner",
+    message: "Enter an owner to add to CODEOWNERS [optional]",
+    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.collectPortableTemplateInput = collectPortableTemplateInput;
+exports.getPromptsForRole = getPromptsForRole;
+exports.moduleIdIdPrompt = moduleIdIdPrompt;
+exports.namePrompt = namePrompt;
+exports.ownerPrompt = ownerPrompt;
+exports.pluginIdPrompt = pluginIdPrompt;
+//# sourceMappingURL=collectPortableTemplateInput.cjs.js.map

package/dist/lib/new/preparation/loadPortableTemplate.cjs.js

@@ -0,0 +1,82 @@
+'use strict';
+
+var z = require('zod');
+var fs = require('fs-extra');
+var recursiveReaddir = require('recursive-readdir');
+var path = require('path');
+var node_path = require('node:path');
+var yaml = require('yaml');
+var paths = require('../../paths.cjs.js');
+var types = require('../types.cjs.js');
+var errors = require('@backstage/errors');
+var zodValidationError = require('zod-validation-error');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+var recursiveReaddir__default = /*#__PURE__*/_interopDefaultCompat(recursiveReaddir);
+
+const templateDefinitionSchema = z.z.object({
+  name: z.z.string(),
+  role: z.z.enum(types.TEMPLATE_ROLES),
+  description: z.z.string().optional(),
+  values: z.z.record(z.z.string()).optional()
+}).strict();
+async function loadPortableTemplate(pointer) {
+  if (pointer.target.match(/https?:\/\//)) {
+    throw new Error("Remote templates are not supported yet");
+  }
+  const templateContent = await fs__default.default.readFile(paths.paths.resolveTargetRoot(pointer.target), "utf-8").catch((error) => {
+    throw new errors.ForwardedError(
+      `Failed to load template definition from '${pointer.target}'`,
+      error
+    );
+  });
+  const rawTemplate = yaml.parse(templateContent);
+  const parsed = templateDefinitionSchema.safeParse(rawTemplate);
+  if (!parsed.success) {
+    throw new errors.ForwardedError(
+      `Invalid template definition at '${pointer.target}'`,
+      zodValidationError.fromZodError(parsed.error)
+    );
+  }
+  const { role, values = {} } = parsed.data;
+  const templatePath = path.resolve(node_path.dirname(pointer.target));
+  const filePaths = await recursiveReaddir__default.default(templatePath).catch((error) => {
+    throw new errors.ForwardedError(
+      `Failed to load template contents from '${templatePath}'`,
+      error
+    );
+  });
+  const loadedFiles = new Array();
+  for (const filePath of filePaths) {
+    const path$1 = path.relative(templatePath, filePath);
+    if (filePath === pointer.target) {
+      continue;
+    }
+    const content = await fs__default.default.readFile(filePath, "utf-8").catch((error) => {
+      throw new errors.ForwardedError(
+        `Failed to load file contents from '${path$1}'`,
+        error
+      );
+    });
+    if (path$1.endsWith(".hbs")) {
+      loadedFiles.push({
+        path: path$1.slice(0, -4),
+        content,
+        syntax: "handlebars"
+      });
+    } else {
+      loadedFiles.push({ path: path$1, content });
+    }
+  }
+  return {
+    name: pointer.name,
+    role,
+    files: loadedFiles,
+    values
+  };
+}
+
+exports.loadPortableTemplate = loadPortableTemplate;
+//# sourceMappingURL=loadPortableTemplate.cjs.js.map

package/dist/lib/new/preparation/loadPortableTemplateConfig.cjs.js

@@ -0,0 +1,121 @@
+'use strict';
+
+var fs = require('fs-extra');
+var node_path = require('node:path');
+var paths = require('../../paths.cjs.js');
+var defaultTemplates = require('../defaultTemplates.cjs.js');
+var types = require('../types.cjs.js');
+var yaml = require('yaml');
+var z = require('zod');
+var zodValidationError = require('zod-validation-error');
+var errors = require('@backstage/errors');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+
+const defaults = {
+  license: "Apache-2.0",
+  version: "0.1.0",
+  private: true,
+  publishRegistry: void 0,
+  packageNamePrefix: "@internal/",
+  packageNamePluginInfix: "plugin-"
+};
+const newConfigSchema = z.z.object({
+  templates: z.z.array(z.z.string()).optional(),
+  globals: z.z.object({
+    license: z.z.string().optional(),
+    version: z.z.string().optional(),
+    private: z.z.boolean().optional(),
+    publishRegistry: z.z.string().optional(),
+    namePrefix: z.z.string().optional(),
+    namePluginInfix: z.z.string().optional()
+  }).optional()
+}).strict();
+const pkgJsonWithNewConfigSchema = z.z.object({
+  backstage: z.z.object({
+    cli: z.z.object({
+      new: newConfigSchema.optional()
+    }).optional()
+  }).optional()
+});
+async function loadPortableTemplateConfig(options = {}) {
+  const { overrides = {} } = options;
+  const pkgPath = options.packagePath ?? paths.paths.resolveTargetRoot("package.json");
+  const pkgJson = await fs__default.default.readJson(pkgPath);
+  const parsed = pkgJsonWithNewConfigSchema.safeParse(pkgJson);
+  if (!parsed.success) {
+    throw new errors.ForwardedError(
+      `Failed to load templating configuration from '${pkgPath}'`,
+      zodValidationError.fromZodError(parsed.error)
+    );
+  }
+  const config = parsed.data.backstage?.cli?.new;
+  const basePath = node_path.dirname(pkgPath);
+  const templatePointerEntries = await Promise.all(
+    (config?.templates ?? defaultTemplates.defaultTemplates).map(async (rawPointer) => {
+      try {
+        const templatePath = resolveLocalTemplatePath(rawPointer, basePath);
+        const pointer = await peekLocalTemplateDefinition(templatePath);
+        return { pointer, rawPointer };
+      } catch (error) {
+        throw new errors.ForwardedError(
+          `Failed to load template definition '${rawPointer}'`,
+          error
+        );
+      }
+    })
+  );
+  const templateNameConflicts = /* @__PURE__ */ new Map();
+  for (const { pointer, rawPointer } of templatePointerEntries) {
+    const conflict = templateNameConflicts.get(pointer.name);
+    if (conflict) {
+      throw new Error(
+        `Invalid template configuration, received conflicting template name '${pointer.name}' from '${conflict}' and '${rawPointer}'`
+      );
+    }
+    templateNameConflicts.set(pointer.name, rawPointer);
+  }
+  return {
+    isUsingDefaultTemplates: !config?.templates,
+    templatePointers: templatePointerEntries.map(({ pointer }) => pointer),
+    license: overrides.license ?? config?.globals?.license ?? defaults.license,
+    version: overrides.version ?? config?.globals?.version ?? defaults.version,
+    private: overrides.private ?? config?.globals?.private ?? defaults.private,
+    publishRegistry: overrides.publishRegistry ?? config?.globals?.publishRegistry ?? defaults.publishRegistry,
+    packageNamePrefix: overrides.packageNamePrefix ?? config?.globals?.namePrefix ?? defaults.packageNamePrefix,
+    packageNamePluginInfix: overrides.packageNamePluginInfix ?? config?.globals?.namePluginInfix ?? defaults.packageNamePluginInfix
+  };
+}
+function resolveLocalTemplatePath(pointer, basePath) {
+  if (node_path.isAbsolute(pointer)) {
+    throw new Error(`Template target may not be an absolute path`);
+  }
+  if (pointer.startsWith(".")) {
+    return node_path.resolve(basePath, pointer, types.TEMPLATE_FILE_NAME);
+  }
+  return require.resolve(`${pointer}/${types.TEMPLATE_FILE_NAME}`, {
+    paths: [basePath]
+  });
+}
+const partialTemplateDefinitionSchema = z.z.object({
+  name: z.z.string(),
+  description: z.z.string().optional()
+});
+async function peekLocalTemplateDefinition(target) {
+  const content = await fs__default.default.readFile(target, "utf8");
+  const rawTemplate = yaml.parse(content);
+  const parsed = partialTemplateDefinitionSchema.safeParse(rawTemplate);
+  if (!parsed.success) {
+    throw zodValidationError.fromZodError(parsed.error);
+  }
+  return {
+    name: parsed.data.name,
+    description: parsed.data.description,
+    target
+  };
+}
+
+exports.loadPortableTemplateConfig = loadPortableTemplateConfig;
+//# sourceMappingURL=loadPortableTemplateConfig.cjs.js.map

package/dist/lib/new/preparation/resolvePackageParams.cjs.js

@@ -0,0 +1,40 @@
+'use strict';
+
+var path = require('path');
+
+function resolvePackageParams(options) {
+  const baseName = getBaseNameForRole(options.roleParams);
+  const isPlugin = options.roleParams.role.includes("plugin");
+  const pluginInfix = isPlugin ? options.pluginInfix : "";
+  return {
+    packageName: `${options.packagePrefix}${pluginInfix}${baseName}`,
+    packagePath: path.join(isPlugin ? "plugins" : "packages", baseName)
+  };
+}
+function getBaseNameForRole(roleParams) {
+  switch (roleParams.role) {
+    case "web-library":
+    case "node-library":
+    case "common-library":
+      return roleParams.name;
+    case "plugin-web-library":
+      return `${roleParams.pluginId}-react`;
+    case "plugin-node-library":
+      return `${roleParams.pluginId}-node`;
+    case "plugin-common-library":
+      return `${roleParams.pluginId}-common`;
+    case "frontend-plugin":
+      return `${roleParams.pluginId}`;
+    case "frontend-plugin-module":
+      return `${roleParams.pluginId}-module-${roleParams.moduleId}`;
+    case "backend-plugin":
+      return `${roleParams.pluginId}-backend`;
+    case "backend-plugin-module":
+      return `${roleParams.pluginId}-backend-module-${roleParams.moduleId}`;
+    default:
+      throw new Error(`Unknown role ${roleParams.role}`);
+  }
+}
+
+exports.resolvePackageParams = resolvePackageParams;
+//# sourceMappingURL=resolvePackageParams.cjs.js.map

package/dist/lib/new/preparation/selectTemplateInteractively.cjs.js

@@ -0,0 +1,38 @@
+'use strict';
+
+var inquirer = require('inquirer');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var inquirer__default = /*#__PURE__*/_interopDefaultCompat(inquirer);
+
+async function selectTemplateInteractively(config, preselectedTemplateName) {
+  let selectedName = preselectedTemplateName;
+  if (config.isUsingDefaultTemplates && selectedName === "plugin") {
+    console.warn(
+      `DEPRECATION WARNING: The 'plugin' template is deprecated, use 'frontend-plugin' instead`
+    );
+    selectedName = "frontend-plugin";
+  }
+  if (!selectedName) {
+    const answers = await inquirer__default.default.prompt([
+      {
+        type: "list",
+        name: "name",
+        message: "What do you want to create?",
+        choices: config.templatePointers.map(
+          (t) => t.description ? { name: `${t.name} - ${t.description}`, value: t.name } : t.name
+        )
+      }
+    ]);
+    selectedName = answers.name;
+  }
+  const template = config.templatePointers.find((t) => t.name === selectedName);
+  if (!template) {
+    throw new Error(`Template '${selectedName}' not found`);
+  }
+  return template;
+}
+
+exports.selectTemplateInteractively = selectTemplateInteractively;
+//# sourceMappingURL=selectTemplateInteractively.cjs.js.map

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

@@ -1,8 +1,19 @@
 'use strict';
 
-function createFactory(config) {
-  return config;
-}
+const TEMPLATE_FILE_NAME = "portable-template.yaml";
+const TEMPLATE_ROLES = [
+  "web-library",
+  "node-library",
+  "common-library",
+  "plugin-web-library",
+  "plugin-node-library",
+  "plugin-common-library",
+  "frontend-plugin",
+  "frontend-plugin-module",
+  "backend-plugin",
+  "backend-plugin-module"
+];
 
-exports.createFactory = createFactory;
+exports.TEMPLATE_FILE_NAME = TEMPLATE_FILE_NAME;
+exports.TEMPLATE_ROLES = TEMPLATE_ROLES;
 //# sourceMappingURL=types.cjs.js.map

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

@@ -3,7 +3,6 @@
 var chalk = require('chalk');
 var fs = require('fs-extra');
 var path = require('path');
-var pLimit = require('p-limit');
 var os = require('os');
 var tar = require('tar');
 var partition = require('lodash/partition');
@@ -21,7 +20,6 @@ function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'defau
 
 var chalk__default = /*#__PURE__*/_interopDefaultCompat(chalk);
 var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
-var pLimit__default = /*#__PURE__*/_interopDefaultCompat(pLimit);
 var tar__default = /*#__PURE__*/_interopDefaultCompat(tar);
 var partition__default = /*#__PURE__*/_interopDefaultCompat(partition);
 
@@ -207,12 +205,12 @@ async function moveToDistWorkspace(workspaceDir, localPackages, alwaysPack, enab
   for (const target of unsafePackages) {
     await pack(target, `temp-package.tgz`);
   }
-  const limit = pLimit__default.default(10);
-  await Promise.all(
-    safePackages.map(
-      (target, index) => limit(() => pack(target, `temp-package-${index}.tgz`))
-    )
-  );
+  await parallel.runParallelWorkers({
+    items: safePackages.map((target, index) => ({ target, index })),
+    worker: async ({ target, index }) => {
+      await pack(target, `temp-package-${index}.tgz`);
+    }
+  });
 }
 
 exports.createDistWorkspace = createDistWorkspace;

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

@@ -120,6 +120,9 @@ async function rewriteEntryPoints(pkg, packageDir, featureDetectionProject) {
       );
       if (defaultFeatureType) {
         exp = { backstage: defaultFeatureType, ...exp };
+        pkg.backstage = pkg.backstage ?? {};
+        pkg.backstage.features = pkg.backstage.features ?? {};
+        pkg.backstage.features[entryPoint.mount] = defaultFeatureType;
       }
     }
     if (entryPoint.mount === ".") {