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

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

@@ -0,0 +1,219 @@
+'use strict';
+
+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');
+var paths = require('../paths.cjs.js');
+var run = require('../run.cjs.js');
+var _package = require('../../packages/cli/package.json.cjs.js');
+var packager = require('../builder/packager.cjs.js');
+var types = require('../builder/types.cjs.js');
+var productionPack = require('./productionPack.cjs.js');
+var cliNode = require('@backstage/cli-node');
+var parallel = require('../parallel.cjs.js');
+var typeDistProject = require('../typeDistProject.cjs.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+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);
+
+const UNSAFE_PACKAGES = [
+  ...Object.keys(_package.dependencies),
+  ...Object.keys(_package.devDependencies)
+];
+function prefixLogFunc(prefix, out) {
+  return (data) => {
+    for (const line of data.toString("utf8").split(/\r?\n/)) {
+      process[out].write(`${prefix} ${line}
+`);
+    }
+  };
+}
+async function createDistWorkspace(packageNames, options = {}) {
+  const targetDir = options.targetDir ?? await fs__default.default.mkdtemp(path.resolve(os.tmpdir(), "dist-workspace"));
+  const packages = await cliNode.PackageGraph.listTargetPackages();
+  const packageGraph = cliNode.PackageGraph.fromPackages(packages);
+  const targetNames = packageGraph.collectPackageNames(packageNames, (node) => {
+    if (node.packageJson.bundled) {
+      return void 0;
+    }
+    return node.publishedLocalDependencies.keys();
+  });
+  const targets = Array.from(targetNames).map((name) => packageGraph.get(name));
+  if (options.buildDependencies) {
+    const exclude = options.buildExcludes ?? [];
+    const configPaths = options.configPaths ?? [];
+    const toBuild = new Set(
+      targets.map((_) => _.name).filter((name) => !exclude.includes(name))
+    );
+    const standardBuilds = new Array();
+    const customBuild = new Array();
+    for (const pkg of packages) {
+      if (!toBuild.has(pkg.packageJson.name)) {
+        continue;
+      }
+      const role = pkg.packageJson.backstage?.role;
+      if (!role) {
+        console.warn(
+          `Building ${pkg.packageJson.name} separately because it has no role`
+        );
+        customBuild.push({ dir: pkg.dir, name: pkg.packageJson.name });
+        continue;
+      }
+      const buildScript = pkg.packageJson.scripts?.build;
+      if (!buildScript) {
+        customBuild.push({ dir: pkg.dir, name: pkg.packageJson.name });
+        continue;
+      }
+      if (!buildScript.startsWith("backstage-cli package build")) {
+        console.warn(
+          `Building ${pkg.packageJson.name} separately because it has a custom build script, '${buildScript}'`
+        );
+        customBuild.push({ dir: pkg.dir, name: pkg.packageJson.name });
+        continue;
+      }
+      if (cliNode.PackageRoles.getRoleInfo(role).output.includes("bundle")) {
+        console.warn(
+          `Building ${pkg.packageJson.name} separately because it is a bundled package`
+        );
+        const args = buildScript.includes("--config") ? [] : configPaths.map((p) => ["--config", p]).flat();
+        customBuild.push({ dir: pkg.dir, name: pkg.packageJson.name, args });
+        continue;
+      }
+      const outputs = packager.getOutputsForRole(role);
+      outputs.delete(types.Output.types);
+      if (outputs.size > 0) {
+        standardBuilds.push({
+          targetDir: pkg.dir,
+          packageJson: pkg.packageJson,
+          outputs,
+          logPrefix: `${chalk__default.default.cyan(path.relative(paths.paths.targetRoot, pkg.dir))}: `,
+          minify: options.minify,
+          workspacePackages: packages
+        });
+      }
+    }
+    await packager.buildPackages(standardBuilds);
+    if (customBuild.length > 0) {
+      await parallel.runParallelWorkers({
+        items: customBuild,
+        worker: async ({ name, dir, args }) => {
+          await run.run("yarn", ["run", "build", ...args || []], {
+            cwd: dir,
+            stdoutLogFunc: prefixLogFunc(`${name}: `, "stdout"),
+            stderrLogFunc: prefixLogFunc(`${name}: `, "stderr")
+          });
+        }
+      });
+    }
+  }
+  await moveToDistWorkspace(
+    targetDir,
+    targets,
+    Boolean(options.alwaysYarnPack),
+    Boolean(options.enableFeatureDetection)
+  );
+  const files = options.files ?? ["yarn.lock", "package.json"];
+  for (const file of files) {
+    const src = typeof file === "string" ? file : file.src;
+    const dest = typeof file === "string" ? file : file.dest;
+    await fs__default.default.copy(paths.paths.resolveTargetRoot(src), path.resolve(targetDir, dest));
+  }
+  if (options.skeleton) {
+    const skeletonFiles = targets.map((target) => {
+      const dir = path.relative(paths.paths.targetRoot, target.dir);
+      return path.join(dir, "package.json");
+    }).sort();
+    await tar__default.default.create(
+      {
+        file: path.resolve(targetDir, options.skeleton),
+        cwd: targetDir,
+        portable: true,
+        noMtime: true,
+        gzip: options.skeleton.endsWith(".gz")
+      },
+      skeletonFiles
+    );
+  }
+  return targetDir;
+}
+const FAST_PACK_SCRIPTS = [
+  void 0,
+  "backstage-cli prepack",
+  "backstage-cli package prepack"
+];
+async function moveToDistWorkspace(workspaceDir, localPackages, alwaysYarnPack, enableFeatureDetection) {
+  const [fastPackPackages, slowPackPackages] = partition__default.default(
+    localPackages,
+    (pkg) => !alwaysYarnPack && FAST_PACK_SCRIPTS.includes(pkg.packageJson.scripts?.prepack)
+  );
+  const featureDetectionProject = fastPackPackages.length > 0 && enableFeatureDetection ? await typeDistProject.createTypeDistProject() : void 0;
+  await Promise.all(
+    fastPackPackages.map(async (target) => {
+      console.log(`Moving ${target.name} into dist workspace`);
+      const outputDir = path.relative(paths.paths.targetRoot, target.dir);
+      const absoluteOutputPath = path.resolve(workspaceDir, outputDir);
+      await productionPack.productionPack({
+        packageDir: target.dir,
+        targetDir: absoluteOutputPath,
+        featureDetectionProject
+      });
+    })
+  );
+  async function pack(target, archive) {
+    console.log(`Repacking ${target.name} into dist workspace`);
+    const archivePath = path.resolve(workspaceDir, archive);
+    await run.run("yarn", ["pack", "--filename", archivePath], {
+      cwd: target.dir
+    });
+    const outputDir = path.relative(paths.paths.targetRoot, target.dir);
+    const absoluteOutputPath = path.resolve(workspaceDir, outputDir);
+    await fs__default.default.ensureDir(absoluteOutputPath);
+    await tar__default.default.extract({
+      file: archivePath,
+      cwd: absoluteOutputPath,
+      strip: 1
+    });
+    await fs__default.default.remove(archivePath);
+    if (target.packageJson.bundled) {
+      const pkgJson = await fs__default.default.readJson(
+        path.resolve(absoluteOutputPath, "package.json")
+      );
+      delete pkgJson.dependencies;
+      delete pkgJson.devDependencies;
+      delete pkgJson.peerDependencies;
+      delete pkgJson.optionalDependencies;
+      await fs__default.default.writeJson(
+        path.resolve(absoluteOutputPath, "package.json"),
+        pkgJson,
+        {
+          spaces: 2
+        }
+      );
+    }
+  }
+  const [unsafePackages, safePackages] = partition__default.default(
+    slowPackPackages,
+    (p) => UNSAFE_PACKAGES.includes(p.name)
+  );
+  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`))
+    )
+  );
+}
+
+exports.createDistWorkspace = createDistWorkspace;
+//# sourceMappingURL=createDistWorkspace.cjs.js.map

package/dist/{cjs/productionPack-BxoMbBkH.cjs.js → lib/packager/productionPack.cjs.js}

@@ -3,100 +3,14 @@
 var fs = require('fs-extra');
 var npmPackList = require('npm-packlist');
 var path = require('path');
-var entryPoints = require('./entryPoints-coip0t-x.cjs.js');
-var tsMorph = require('ts-morph');
-var index = require('./index-b1ouG3q6.cjs.js');
+var entryPoints = require('../entryPoints.cjs.js');
+var typeDistProject = require('../typeDistProject.cjs.js');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
 
 var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
 var npmPackList__default = /*#__PURE__*/_interopDefaultCompat(npmPackList);
 
-const createTypeDistProject = async () => {
-  return new tsMorph.Project({
-    tsConfigFilePath: index.paths.resolveTargetRoot("tsconfig.json"),
-    skipAddingFilesFromTsConfig: true
-  });
-};
-const targetPackageRoles = [
-  "backend-plugin",
-  "backend-plugin-module",
-  "frontend-plugin",
-  "frontend-plugin-module",
-  "web-library",
-  "node-library"
-];
-const targetFeatureTypes = [
-  "@backstage/BackendFeature",
-  "@backstage/BackstagePlugin",
-  "@backstage/FrontendPlugin",
-  "@backstage/FrontendModule"
-];
-const getEntryPointDefaultFeatureType = (role, packageDir, project, entryPoint) => {
-  if (isTargetPackageRole(role)) {
-    const distPath = path.resolve(packageDir, entryPoint);
-    try {
-      const defaultFeatureType = getSourceFileDefaultFeatureType(
-        project.addSourceFileAtPath(distPath)
-      );
-      if (defaultFeatureType) {
-        return defaultFeatureType;
-      }
-    } catch (error) {
-      console.error(
-        `Failed to extract default feature type from ${distPath}, ${error}. Your package will publish fine but it may be missing metadata about its default feature.`
-      );
-    }
-  }
-  return null;
-};
-function getSourceFileDefaultFeatureType(sourceFile) {
-  for (const exportSymbol of sourceFile.getExportSymbols()) {
-    const declaration = exportSymbol.getDeclarations()[0];
-    const exportName = declaration.getSymbol()?.getName();
-    if (exportName !== "default") {
-      continue;
-    }
-    let exportType;
-    if (declaration) {
-      if (declaration.isKind(tsMorph.SyntaxKind.ExportAssignment)) {
-        exportType = declaration.getExpression().getType();
-      } else if (declaration.isKind(tsMorph.SyntaxKind.ExportSpecifier)) {
-        if (!declaration.isTypeOnly()) {
-          exportType = declaration.getType();
-        }
-      } else if (declaration.isKind(tsMorph.SyntaxKind.VariableDeclaration)) {
-        exportType = declaration.getType();
-      }
-    }
-    if (exportName && exportType) {
-      const $$type = getBackstagePackageFeature$$TypeFromType(exportType);
-      if ($$type) {
-        return $$type;
-      }
-    }
-  }
-  return null;
-}
-function getBackstagePackageFeature$$TypeFromType(type) {
-  const exportType = type.getTargetType() ?? type;
-  for (const property of exportType.getProperties()) {
-    if (property.getName() === "$$type") {
-      const $$type = property.getValueDeclaration()?.getText().match(/(\$\$type: '(?<type>.+)')/)?.groups?.type;
-      if ($$type && isTargetFeatureType($$type)) {
-        return $$type;
-      }
-    }
-  }
-  return null;
-}
-function isTargetPackageRole(role) {
-  return !!role && targetPackageRoles.includes(role);
-}
-function isTargetFeatureType(type) {
-  return !!type && targetFeatureTypes.includes(type);
-}
-
 const PKG_PATH = "package.json";
 const PKG_BACKUP_PATH = "package.json-prepack";
 const SKIPPED_KEYS = ["access", "registry", "tag"];
@@ -112,7 +26,7 @@ async function productionPack(options) {
   const writeCompatibilityEntryPoints = await prepareExportsEntryPoints(
     pkg,
     packageDir,
-    options.project
+    options.featureDetectionProject
   );
   const publishConfig = pkg.publishConfig ?? {};
   for (const key of Object.keys(publishConfig)) {
@@ -173,7 +87,7 @@ const EXPORT_MAP = {
   require: ".cjs.js",
   types: ".d.ts"
 };
-async function prepareExportsEntryPoints(pkg, packageDir, commonProject) {
+async function prepareExportsEntryPoints(pkg, packageDir, featureDetectionProject) {
   const distPath = path.resolve(packageDir, "dist");
   if (!await fs__default.default.pathExists(distPath)) {
     return void 0;
@@ -182,7 +96,6 @@ async function prepareExportsEntryPoints(pkg, packageDir, commonProject) {
   const outputExports = {};
   const compatibilityWriters = new Array();
   const entryPoints$1 = entryPoints.readEntryPoints(pkg);
-  const project = commonProject || await createTypeDistProject();
   for (const entryPoint of entryPoints$1) {
     if (!SCRIPT_EXTS.includes(entryPoint.ext)) {
       outputExports[entryPoint.mount] = entryPoint.path;
@@ -196,11 +109,11 @@ async function prepareExportsEntryPoints(pkg, packageDir, commonProject) {
       }
     }
     exp.default = exp.require ?? exp.import;
-    if (exp.types) {
-      const defaultFeatureType = pkg.backstage?.role && getEntryPointDefaultFeatureType(
+    if (exp.types && featureDetectionProject) {
+      const defaultFeatureType = pkg.backstage?.role && typeDistProject.getEntryPointDefaultFeatureType(
         pkg.backstage?.role,
         packageDir,
-        project,
+        featureDetectionProject,
         exp.types
       );
       if (defaultFeatureType) {
@@ -255,7 +168,6 @@ async function prepareExportsEntryPoints(pkg, packageDir, commonProject) {
   return void 0;
 }
 
-exports.createTypeDistProject = createTypeDistProject;
 exports.productionPack = productionPack;
 exports.revertProductionPack = revertProductionPack;
-//# sourceMappingURL=productionPack-BxoMbBkH.cjs.js.map
+//# sourceMappingURL=productionPack.cjs.js.map

package/dist/{cjs/parallel-BszNaKyc.cjs.js → lib/parallel.cjs.js}

@@ -135,6 +135,7 @@ function workerQueueThread(workerFuncFactory) {
 }
 
 exports.getEnvironmentParallelism = getEnvironmentParallelism;
+exports.parseParallelismOption = parseParallelismOption;
 exports.runParallelWorkers = runParallelWorkers;
 exports.runWorkerQueueThreads = runWorkerQueueThreads;
-//# sourceMappingURL=parallel-BszNaKyc.cjs.js.map
+//# sourceMappingURL=parallel.cjs.js.map

package/dist/lib/paths.cjs.js

@@ -0,0 +1,8 @@
+'use strict';
+
+var cliCommon = require('@backstage/cli-common');
+
+const paths = cliCommon.findPaths(__dirname);
+
+exports.paths = paths;
+//# sourceMappingURL=paths.cjs.js.map

package/dist/{cjs/publishing-DQtsKTbc.cjs.js → lib/publishing.cjs.js}

@@ -37,4 +37,4 @@ function publishPreflightCheck(pkg) {
 }
 
 exports.publishPreflightCheck = publishPreflightCheck;
-//# sourceMappingURL=publishing-DQtsKTbc.cjs.js.map
+//# sourceMappingURL=publishing.cjs.js.map

package/dist/{cjs/role-BjiBExhi.cjs.js → lib/role.cjs.js}

@@ -1,7 +1,7 @@
 'use strict';
 
 var fs = require('fs-extra');
-var index = require('./index-b1ouG3q6.cjs.js');
+var paths = require('./paths.cjs.js');
 var cliNode = require('@backstage/cli-node');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
@@ -12,7 +12,7 @@ async function findRoleFromCommand(opts) {
   if (opts.role) {
     return cliNode.PackageRoles.getRoleInfo(opts.role)?.role;
   }
-  const pkg = await fs__default.default.readJson(index.paths.resolveTarget("package.json"));
+  const pkg = await fs__default.default.readJson(paths.paths.resolveTarget("package.json"));
   const info = cliNode.PackageRoles.getRoleFromPackage(pkg);
   if (!info) {
     throw new Error(`Target package must have 'backstage.role' set`);
@@ -21,4 +21,4 @@ async function findRoleFromCommand(opts) {
 }
 
 exports.findRoleFromCommand = findRoleFromCommand;
-//# sourceMappingURL=role-BjiBExhi.cjs.js.map
+//# sourceMappingURL=role.cjs.js.map

package/dist/{cjs/run-CpZGNJQr.cjs.js → lib/run.cjs.js}

@@ -1,7 +1,7 @@
 'use strict';
 
 var child_process = require('child_process');
-var index = require('./index-b1ouG3q6.cjs.js');
+var errors$1 = require('./errors.cjs.js');
 var util = require('util');
 var errors = require('@backstage/errors');
 
@@ -42,7 +42,7 @@ async function runPlain(cmd, ...args) {
       process.stderr.write(error.stderr);
     }
     if (typeof error.code === "number") {
-      throw new index.ExitCodeError(error.code, [cmd, ...args].join(" "));
+      throw new errors$1.ExitCodeError(error.code, [cmd, ...args].join(" "));
     }
     throw new errors.ForwardedError("Unknown execution error", error);
   }
@@ -58,7 +58,7 @@ async function runCheck(cmd, ...args) {
 async function waitForExit(child, name) {
   if (typeof child.exitCode === "number") {
     if (child.exitCode) {
-      throw new index.ExitCodeError(child.exitCode, name);
+      throw new errors$1.ExitCodeError(child.exitCode, name);
     }
     return;
   }
@@ -66,7 +66,7 @@ async function waitForExit(child, name) {
     child.once("error", (error) => reject(error));
     child.once("exit", (code) => {
       if (code) {
-        reject(new index.ExitCodeError(code, name));
+        reject(new errors$1.ExitCodeError(code, name));
       } else {
         resolve();
       }
@@ -78,4 +78,5 @@ exports.execFile = execFile;
 exports.run = run;
 exports.runCheck = runCheck;
 exports.runPlain = runPlain;
-//# sourceMappingURL=run-CpZGNJQr.cjs.js.map
+exports.waitForExit = waitForExit;
+//# sourceMappingURL=run.cjs.js.map

package/dist/{cjs/svgrTemplate-BTjBQ3by.cjs.js → lib/svgrTemplate.cjs.js}

@@ -20,4 +20,4 @@ ${defaultExport}`;
 }
 
 exports.svgrTemplate = svgrTemplate;
-//# sourceMappingURL=svgrTemplate-BTjBQ3by.cjs.js.map
+//# sourceMappingURL=svgrTemplate.cjs.js.map

package/dist/lib/tasks.cjs.js

@@ -0,0 +1,188 @@
+'use strict';
+
+var chalk = require('chalk');
+var fs = require('fs-extra');
+var handlebars = require('handlebars');
+var ora = require('ora');
+var util = require('util');
+var path = require('path');
+var recursive = require('recursive-readdir');
+var child_process = require('child_process');
+var errors = require('@backstage/errors');
+var paths = require('./paths.cjs.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var chalk__default = /*#__PURE__*/_interopDefaultCompat(chalk);
+var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+var handlebars__default = /*#__PURE__*/_interopDefaultCompat(handlebars);
+var ora__default = /*#__PURE__*/_interopDefaultCompat(ora);
+var recursive__default = /*#__PURE__*/_interopDefaultCompat(recursive);
+
+const exec = util.promisify(child_process.exec);
+const TASK_NAME_MAX_LENGTH = 14;
+class Task {
+  static log(name = "") {
+    process.stderr.write(`${chalk__default.default.green(name)}
+`);
+  }
+  static error(message = "") {
+    process.stderr.write(`
+${chalk__default.default.red(message)}
+
+`);
+  }
+  static section(name) {
+    const title = chalk__default.default.green(`${name}:`);
+    process.stderr.write(`
+ ${title}
+`);
+  }
+  static exit(code = 0) {
+    process.exit(code);
+  }
+  static async forItem(task, item, taskFunc) {
+    const paddedTask = chalk__default.default.green(task.padEnd(TASK_NAME_MAX_LENGTH));
+    const spinner = ora__default.default({
+      prefixText: chalk__default.default.green(`  ${paddedTask}${chalk__default.default.cyan(item)}`),
+      spinner: "arc",
+      color: "green"
+    }).start();
+    try {
+      const result = await taskFunc();
+      spinner.succeed();
+      return result;
+    } catch (error) {
+      spinner.fail();
+      throw error;
+    }
+  }
+  static async forCommand(command, options) {
+    try {
+      await Task.forItem("executing", command, async () => {
+        await exec(command, { cwd: options?.cwd });
+      });
+    } catch (error) {
+      errors.assertError(error);
+      if (error.stderr) {
+        process.stderr.write(error.stderr);
+      }
+      if (error.stdout) {
+        process.stdout.write(error.stdout);
+      }
+      if (options?.optional) {
+        Task.error(`Warning: Failed to execute command ${chalk__default.default.cyan(command)}`);
+      } else {
+        throw new Error(
+          `Failed to execute command '${chalk__default.default.cyan(command)}', ${error}`
+        );
+      }
+    }
+  }
+}
+async function templatingTask(templateDir, destinationDir, context, versionProvider, isMonoRepo) {
+  const files = await recursive__default.default(templateDir).catch((error) => {
+    throw new Error(`Failed to read template directory: ${error.message}`);
+  });
+  for (const file of files) {
+    const destinationFile = file.replace(templateDir, destinationDir);
+    await fs__default.default.ensureDir(path.dirname(destinationFile));
+    if (file.endsWith(".hbs")) {
+      await Task.forItem("templating", path.basename(file), async () => {
+        const destination = destinationFile.replace(/\.hbs$/, "");
+        const template = await fs__default.default.readFile(file);
+        const compiled = handlebars__default.default.compile(template.toString(), {
+          strict: true
+        });
+        const contents = compiled(
+          { name: path.basename(destination), ...context },
+          {
+            helpers: {
+              versionQuery(name, versionHint) {
+                return versionProvider(
+                  name,
+                  typeof versionHint === "string" ? versionHint : void 0
+                );
+              }
+            }
+          }
+        );
+        await fs__default.default.writeFile(destination, contents).catch((error) => {
+          throw new Error(
+            `Failed to create file: ${destination}: ${error.message}`
+          );
+        });
+      });
+    } else {
+      if (isMonoRepo && file.match("tsconfig.json")) {
+        continue;
+      }
+      await Task.forItem("copying", path.basename(file), async () => {
+        await fs__default.default.copyFile(file, destinationFile).catch((error) => {
+          const destination = destinationFile;
+          throw new Error(
+            `Failed to copy file to ${destination} : ${error.message}`
+          );
+        });
+      });
+    }
+  }
+}
+async function addPackageDependency(path, options) {
+  try {
+    const pkgJson = await fs__default.default.readJson(path);
+    const normalize = (obj) => {
+      if (Object.keys(obj).length === 0) {
+        return void 0;
+      }
+      return Object.fromEntries(
+        Object.keys(obj).sort().map((key) => [key, obj[key]])
+      );
+    };
+    pkgJson.dependencies = normalize({
+      ...pkgJson.dependencies,
+      ...options.dependencies
+    });
+    pkgJson.devDependencies = normalize({
+      ...pkgJson.devDependencies,
+      ...options.devDependencies
+    });
+    pkgJson.peerDependencies = normalize({
+      ...pkgJson.peerDependencies,
+      ...options.peerDependencies
+    });
+    await fs__default.default.writeJson(path, pkgJson, { spaces: 2 });
+  } catch (error) {
+    throw new Error(`Failed to add package dependencies, ${error}`);
+  }
+}
+async function addToBackend(name, options) {
+  if (await fs__default.default.pathExists(paths.paths.resolveTargetRoot("packages/backend"))) {
+    await Task.forItem("backend", `adding ${options.type}`, async () => {
+      const backendFilePath = paths.paths.resolveTargetRoot(
+        "packages/backend/src/index.ts"
+      );
+      if (!await fs__default.default.pathExists(backendFilePath)) {
+        return;
+      }
+      const content = await fs__default.default.readFile(backendFilePath, "utf8");
+      const lines = content.split("\n");
+      const backendAddLine = `backend.add(import('${name}'));`;
+      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(backendFilePath, newContent, "utf8");
+      }
+    });
+  }
+}
+
+exports.Task = Task;
+exports.addPackageDependency = addPackageDependency;
+exports.addToBackend = addToBackend;
+exports.templatingTask = templatingTask;
+//# sourceMappingURL=tasks.cjs.js.map