@backstage/plugin-scaffolder-backend 1.25.0-next.2 → 1.26.0-next.0

package/dist/cjs/{router-B1lzg7oz.cjs.js → router-CC-UhVkG.cjs.js}

@@ -32,6 +32,7 @@ var gitlab = require('@backstage/plugin-scaffolder-backend-module-gitlab');
 var pluginScaffolderBackendModuleGitea = require('@backstage/plugin-scaffolder-backend-module-gitea');
 var uuid = require('uuid');
 var alpha = require('@backstage/plugin-scaffolder-node/alpha');
+var os = require('os');
 var ObservableImpl = require('zen-observable');
 var lodash = require('lodash');
 var PQueue = require('p-queue');
@@ -45,7 +46,6 @@ var pluginPermissionCommon = require('@backstage/plugin-permission-common');
 var Transport = require('winston-transport');
 var tripleBeam = require('triple-beam');
 var url = require('url');
-var os = require('os');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
 
@@ -75,14 +75,14 @@ var path__default = /*#__PURE__*/_interopDefaultCompat(path);
 var fs__default$1 = /*#__PURE__*/_interopDefaultCompat(fs$1);
 var globby__default = /*#__PURE__*/_interopDefaultCompat(globby);
 var get__default = /*#__PURE__*/_interopDefaultCompat(get);
+var os__default = /*#__PURE__*/_interopDefaultCompat(os);
 var ObservableImpl__default = /*#__PURE__*/_interopDefaultCompat(ObservableImpl);
 var PQueue__default = /*#__PURE__*/_interopDefaultCompat(PQueue);
 var winston__namespace = /*#__PURE__*/_interopNamespaceCompat(winston);
 var nunjucks__default = /*#__PURE__*/_interopDefaultCompat(nunjucks);
 var Transport__default = /*#__PURE__*/_interopDefaultCompat(Transport);
-var os__default = /*#__PURE__*/_interopDefaultCompat(os);
 
-const examples$9 = [
+const examples$a = [
   {
     description: "Register with the catalog",
     example: yaml__namespace.default.stringify({
@@ -106,7 +106,7 @@ function createCatalogRegisterAction(options) {
   return pluginScaffolderNode.createTemplateAction({
     id: id$4,
     description: "Registers entities from a catalog descriptor file in the workspace into the software catalog.",
-    examples: examples$9,
+    examples: examples$a,
     schema: {
       input: {
         oneOf: [
@@ -233,7 +233,7 @@ function createCatalogRegisterAction(options) {
   });
 }
 
-const examples$8 = [
+const examples$9 = [
   {
     description: "Write a catalog yaml file",
     example: yaml__namespace.stringify({
@@ -277,7 +277,7 @@ function createCatalogWriteAction() {
         )
       })
     },
-    examples: examples$8,
+    examples: examples$9,
     supportsDryRun: true,
     async handler(ctx) {
       const { filePath, entity } = ctx.input;
@@ -303,7 +303,7 @@ function createCatalogWriteAction() {
   });
 }
 
-const examples$7 = [
+const examples$8 = [
   {
     description: "Fetch entity by reference",
     example: yaml__namespace.default.stringify({
@@ -342,7 +342,7 @@ function createFetchCatalogEntityAction(options) {
   return pluginScaffolderNode.createTemplateAction({
     id: id$2,
     description: "Returns entity or entities from the catalog by entity reference(s)",
-    examples: examples$7,
+    examples: examples$8,
     supportsDryRun: true,
     schema: {
       input: zod.z.object({
@@ -420,7 +420,7 @@ function createFetchCatalogEntityAction(options) {
   });
 }
 
-const examples$6 = [
+const examples$7 = [
   {
     description: "Write a debug message",
     example: yaml__namespace.default.stringify({
@@ -473,7 +473,7 @@ function createDebugLogAction() {
   return pluginScaffolderNode.createTemplateAction({
     id: id$1,
     description: "Writes a message into the log and/or lists all files in the workspace.",
-    examples: examples$6,
+    examples: examples$7,
     schema: {
       input: zod.z.object({
         message: zod.z.string({ description: "Message to output." }).optional(),
@@ -518,7 +518,7 @@ async function recursiveReadDir(dir) {
   return files.reduce((a, f) => a.concat(f), []);
 }
 
-const examples$5 = [
+const examples$6 = [
   {
     description: "Waiting for 50 milliseconds",
     example: yaml__namespace.default.stringify({
@@ -581,7 +581,7 @@ function createWaitAction(options) {
   return pluginScaffolderNode.createTemplateAction({
     id,
     description: "Waits for a certain period of time.",
-    examples: examples$5,
+    examples: examples$6,
     schema: {
       input: {
         type: "object",
@@ -624,7 +624,7 @@ function createWaitAction(options) {
   });
 }
 
-const examples$4 = [
+const examples$5 = [
   {
     description: "Downloads content and places it in the workspace.",
     example: yaml__namespace.default.stringify({
@@ -663,7 +663,7 @@ function createFetchPlainAction(options) {
   const { reader, integrations } = options;
   return pluginScaffolderNode.createTemplateAction({
     id: ACTION_ID,
-    examples: examples$4,
+    examples: examples$5,
     description: "Downloads content and places it in the workspace, or optionally in a subdirectory specified by the `targetPath` input option.",
     schema: {
       input: {
@@ -705,7 +705,7 @@ function createFetchPlainAction(options) {
   });
 }
 
-const examples$3 = [
+const examples$4 = [
   {
     description: "Downloads a file and places it in the workspace.",
     example: yaml__namespace.default.stringify({
@@ -729,7 +729,7 @@ function createFetchPlainFileAction(options) {
   return pluginScaffolderNode.createTemplateAction({
     id: "fetch:plain:file",
     description: "Downloads single file and places it in the workspace.",
-    examples: examples$3,
+    examples: examples$4,
     schema: {
       input: {
         type: "object",
@@ -950,7 +950,7 @@ const createDefaultFilters = ({
   };
 };
 
-const examples$2 = [
+const examples$3 = [
   {
     description: "Downloads a skeleton directory that lives alongside the template file and fill it out with values.",
     example: yaml__namespace.default.stringify({
@@ -986,7 +986,7 @@ function createFetchTemplateAction(options) {
   return pluginScaffolderNode.createTemplateAction({
     id: "fetch:template",
     description: "Downloads a skeleton, templates variables into file and directory names and content, and places the result in the workspace, or optionally in a subdirectory specified by the `targetPath` input option.",
-    examples: examples$2,
+    examples: examples$3,
     schema: {
       input: {
         type: "object",
@@ -1196,6 +1196,132 @@ function containsSkippedContent(localOutputPath) {
   return localOutputPath === "" || localOutputPath.startsWith("/") || localOutputPath.includes("//");
 }
 
+const examples$2 = [
+  {
+    description: "Downloads a template file and fill it out with values.",
+    example: yaml__namespace.default.stringify({
+      steps: [
+        {
+          action: "fetch:template:file",
+          id: "fetch-template-file",
+          name: "Fetch template file",
+          input: {
+            url: "./skeleton.txt",
+            targetPath: "./target/skeleton.txt",
+            values: {
+              name: "test-project",
+              count: 1234,
+              itemList: ["first", "second", "third"]
+            }
+          }
+        }
+      ]
+    })
+  }
+];
+
+function createFetchTemplateFileAction(options) {
+  const {
+    reader,
+    integrations,
+    additionalTemplateFilters,
+    additionalTemplateGlobals
+  } = options;
+  const defaultTemplateFilters = createDefaultFilters({ integrations });
+  return pluginScaffolderNode.createTemplateAction({
+    id: "fetch:template:file",
+    description: "Downloads single file and places it in the workspace.",
+    examples: examples$2,
+    schema: {
+      input: {
+        type: "object",
+        required: ["url", "targetPath"],
+        properties: {
+          url: {
+            title: "Fetch URL",
+            description: "Relative path or absolute URL pointing to the single file to fetch.",
+            type: "string"
+          },
+          targetPath: {
+            title: "Target Path",
+            description: "Target path within the working directory to download the file as.",
+            type: "string"
+          },
+          values: {
+            title: "Template Values",
+            description: "Values to pass on to the templating engine",
+            type: "object"
+          },
+          cookiecutterCompat: {
+            title: "Cookiecutter compatibility mode",
+            description: "Enable features to maximise compatibility with templates built for fetch:cookiecutter",
+            type: "boolean"
+          },
+          replace: {
+            title: "Replace file",
+            description: "If set, replace file in targetPath instead of overwriting existing one.",
+            type: "boolean"
+          },
+          token: {
+            title: "Token",
+            description: "An optional token to use for authentication when reading the resources.",
+            type: "string"
+          }
+        }
+      }
+    },
+    supportsDryRun: true,
+    async handler(ctx) {
+      ctx.logger.info("Fetching template file content from remote URL");
+      const workDir = await ctx.createTemporaryDirectory();
+      const tmpFilePath = path__default.default.join(workDir, "tmp");
+      const outputPath = backendPluginApi.resolveSafeChildPath(
+        ctx.workspacePath,
+        ctx.input.targetPath
+      );
+      if (fs__default.default.existsSync(outputPath) && !ctx.input.replace) {
+        ctx.logger.info(
+          `File ${ctx.input.targetPath} already exists in workspace, not replacing.`
+        );
+        return;
+      }
+      await pluginScaffolderNode.fetchFile({
+        reader,
+        integrations,
+        baseUrl: ctx.templateInfo?.baseUrl,
+        fetchUrl: ctx.input.url,
+        outputPath: tmpFilePath,
+        token: ctx.input.token
+      });
+      const { cookiecutterCompat, values } = ctx.input;
+      const context = {
+        [cookiecutterCompat ? "cookiecutter" : "values"]: values
+      };
+      ctx.logger.info(
+        `Processing template file with input values`,
+        ctx.input.values
+      );
+      const renderTemplate = await SecureTemplater.loadRenderer({
+        cookiecutterCompat,
+        templateFilters: {
+          ...defaultTemplateFilters,
+          ...additionalTemplateFilters
+        },
+        templateGlobals: additionalTemplateGlobals,
+        nunjucksConfigs: {
+          trimBlocks: ctx.input.trimBlocks,
+          lstripBlocks: ctx.input.lstripBlocks
+        }
+      });
+      const contents = await fs__default.default.readFile(tmpFilePath, "utf-8");
+      const result = renderTemplate(contents, context);
+      await fs__default.default.ensureDir(path__default.default.dirname(outputPath));
+      await fs__default.default.outputFile(outputPath, result);
+      ctx.logger.info(`Template file has been written to ${outputPath}`);
+    }
+  });
+}
+
 const examples$1 = [
   {
     description: "Delete specified files",
@@ -1371,6 +1497,12 @@ const createBuiltinActions = (options) => {
       additionalTemplateFilters,
       additionalTemplateGlobals
     }),
+    createFetchTemplateFileAction({
+      integrations,
+      reader,
+      additionalTemplateFilters,
+      additionalTemplateGlobals
+    }),
     gerrit.createPublishGerritAction({
       integrations,
       config
@@ -1453,7 +1585,8 @@ const createBuiltinActions = (options) => {
       githubCredentialsProvider
     }),
     github.createGithubEnvironmentAction({
-      integrations
+      integrations,
+      catalogClient
     }),
     github.createGithubDeployKeyAction({
       integrations
@@ -1523,6 +1656,79 @@ const intervalFromNowTill = (timeoutS, knex) => {
   return heartbeatInterval;
 };
 
+async function getWorkingDirectory(config, logger) {
+  if (!config.has("backend.workingDirectory")) {
+    return os__default.default.tmpdir();
+  }
+  const workingDirectory = config.getString("backend.workingDirectory");
+  try {
+    await fs__default.default.access(workingDirectory, fs__default.default.constants.F_OK | fs__default.default.constants.W_OK);
+    logger.info(`using working directory: ${workingDirectory}`);
+  } catch (err) {
+    errors.assertError(err);
+    logger.error(
+      `working directory ${workingDirectory} ${err.code === "ENOENT" ? "does not exist" : "is not writable"}`
+    );
+    throw err;
+  }
+  return workingDirectory;
+}
+function getEntityBaseUrl(entity) {
+  let location = entity.metadata.annotations?.[catalogModel.ANNOTATION_SOURCE_LOCATION];
+  if (!location) {
+    location = entity.metadata.annotations?.[catalogModel.ANNOTATION_LOCATION];
+  }
+  if (!location) {
+    return void 0;
+  }
+  const { type, target } = catalogModel.parseLocationRef(location);
+  if (type === "url") {
+    return target;
+  } else if (type === "file") {
+    return `file://${target}`;
+  }
+  return void 0;
+}
+async function findTemplate(options) {
+  const { entityRef, token, catalogApi } = options;
+  if (entityRef.kind.toLocaleLowerCase("en-US") !== "template") {
+    throw new errors.InputError(`Invalid kind, only 'Template' kind is supported`);
+  }
+  const template = await catalogApi.getEntityByRef(entityRef, { token });
+  if (!template) {
+    throw new errors.NotFoundError(
+      `Template ${catalogModel.stringifyEntityRef(entityRef)} not found`
+    );
+  }
+  return template;
+}
+function parseStringsParam(param, paramName) {
+  if (param === void 0) {
+    return void 0;
+  }
+  const array = [param].flat();
+  if (array.some((p) => typeof p !== "string")) {
+    throw new errors.InputError(
+      `Invalid ${paramName}, not a string or array of strings`
+    );
+  }
+  return array;
+}
+function parseNumberParam(param, paramName) {
+  return parseStringsParam(param, paramName)?.map((val) => {
+    const ret = Number.parseInt(val, 10);
+    if (isNaN(ret)) {
+      throw new errors.InputError(
+        `Invalid ${paramName} parameter "${val}", expected a number or array of numbers`
+      );
+    }
+    return ret;
+  });
+}
+function flattenParams(...params) {
+  return [...params].flat().filter(Boolean);
+}
+
 const migrationsDir = backendPluginApi.resolvePackagePath(
   "@backstage/plugin-scaffolder-backend",
   "migrations"
@@ -1594,16 +1800,41 @@ class DatabaseTaskStore {
     this.db = client;
   }
   async list(options) {
+    const { createdBy, status, pagination, order, filters } = options ?? {};
     const queryBuilder = this.db("tasks");
-    if (options.createdBy) {
-      queryBuilder.where({
-        created_by: options.createdBy
+    if (createdBy || filters?.createdBy) {
+      const arr = flattenParams(
+        createdBy,
+        filters?.createdBy
+      );
+      queryBuilder.whereIn("created_by", [...new Set(arr)]);
+    }
+    if (status || filters?.status) {
+      const arr = flattenParams(
+        status,
+        filters?.status
+      );
+      queryBuilder.whereIn("status", [...new Set(arr)]);
+    }
+    if (order) {
+      order.forEach((f) => {
+        queryBuilder.orderBy(f.field, f.order);
       });
+    } else {
+      queryBuilder.orderBy("created_at", "desc");
+    }
+    const countQuery = queryBuilder.clone();
+    countQuery.count("tasks.id", { as: "count" });
+    if (pagination?.limit !== void 0) {
+      queryBuilder.limit(pagination.limit);
     }
-    if (options.status) {
-      queryBuilder.where({ status: options.status });
+    if (pagination?.offset !== void 0) {
+      queryBuilder.offset(pagination.offset);
     }
-    const results = await queryBuilder.orderBy("created_at", "desc").select();
+    const [results, [{ count }]] = await Promise.all([
+      queryBuilder.select(),
+      countQuery
+    ]);
     const tasks = results.map((result) => ({
       id: result.id,
       spec: JSON.parse(result.spec),
@@ -1612,7 +1843,7 @@ class DatabaseTaskStore {
       lastHeartbeatAt: parseSqlDateToIsoString(result.last_heartbeat_at),
       createdAt: parseSqlDateToIsoString(result.created_at)
     }));
-    return { tasks };
+    return { tasks, totalTasks: count };
   }
   async getTask(taskId) {
     const [result] = await this.db("tasks").where({ id: taskId }).select();
@@ -1781,7 +2012,7 @@ class DatabaseTaskStore {
     }
   }
   async listEvents(options) {
-    const { taskId, after } = options;
+    const { isTaskRecoverable, taskId, after } = options;
     const rawEvents = await this.db("task_events").where({
       task_id: taskId
     }).andWhere((builder) => {
@@ -1794,6 +2025,7 @@ class DatabaseTaskStore {
         const body = JSON.parse(event.body);
         return {
           id: Number(event.id),
+          isTaskRecoverable,
           taskId,
           body,
           type: event.event_type,
@@ -1864,6 +2096,28 @@ class DatabaseTaskStore {
       body: serializedBody
     });
   }
+  async retryTask(options) {
+    await this.db.transaction(async (tx) => {
+      const result = await tx("tasks").where("id", options.taskId).update(
+        {
+          status: "open",
+          last_heartbeat_at: this.db.fn.now()
+        },
+        ["id", "spec"]
+      );
+      for (const { id, spec } of result) {
+        const taskSpec = JSON.parse(spec);
+        await tx("task_events").where("task_id", id).andWhere((q) => q.whereIn("event_type", ["cancelled", "completion"])).del();
+        await tx("task_events").insert({
+          task_id: id,
+          event_type: "recovered",
+          body: JSON.stringify({
+            recoverStrategy: taskSpec.EXPERIMENTAL_recovery?.EXPERIMENTAL_strategy ?? "none"
+          })
+        });
+      }
+    });
+  }
   async recoverTasks(options) {
     const taskIdsToRecover = [];
     const timeoutS = luxon.Duration.fromObject(options.timeout).as("seconds");
@@ -1975,6 +2229,7 @@ class DefaultWorkspaceService {
   }
   async rehydrateWorkspace(options) {
     if (this.isWorkspaceSerializationEnabled()) {
+      await fs__default.default.mkdirp(options.targetPath);
       await this.workspaceProvider.rehydrateWorkspace(options);
     }
   }
@@ -2126,10 +2381,7 @@ class StorageTaskBroker {
         "TaskStore does not implement the list method. Please implement the list method to be able to list tasks"
       );
     }
-    return await this.storage.list({
-      createdBy: options?.createdBy,
-      status: options?.status
-    });
+    return await this.storage.list(options ?? {});
   }
   deferredDispatch = defer();
   async registerCancellable(taskId, abortController) {
@@ -2144,7 +2396,7 @@ class StorageTaskBroker {
             abortController.abort();
             shouldUnsubscribe = true;
           }
-          if (event.type === "completion") {
+          if (event.type === "completion" && !event.isTaskRecoverable) {
             shouldUnsubscribe = true;
           }
         }
@@ -2226,8 +2478,14 @@ class StorageTaskBroker {
       let after = options.after;
       let cancelled = false;
       (async () => {
+        const task = await this.storage.getTask(taskId);
+        const isTaskRecoverable = task.spec.EXPERIMENTAL_recovery?.EXPERIMENTAL_strategy === "startOver";
         while (!cancelled) {
-          const result = await this.storage.listEvents({ taskId, after });
+          const result = await this.storage.listEvents({
+            isTaskRecoverable,
+            taskId,
+            after
+          });
           const { events } = result;
           if (events.length) {
             after = events[events.length - 1].id;
@@ -2281,6 +2539,10 @@ class StorageTaskBroker {
       }
     });
   }
+  async retry(taskId) {
+    await this.storage.retryTask?.({ taskId });
+    this.signalDispatch();
+  }
 }
 
 function createCounterMetric(config) {
@@ -3219,53 +3481,6 @@ function createDryRunner(options) {
   };
 }
 
-async function getWorkingDirectory(config, logger) {
-  if (!config.has("backend.workingDirectory")) {
-    return os__default.default.tmpdir();
-  }
-  const workingDirectory = config.getString("backend.workingDirectory");
-  try {
-    await fs__default.default.access(workingDirectory, fs__default.default.constants.F_OK | fs__default.default.constants.W_OK);
-    logger.info(`using working directory: ${workingDirectory}`);
-  } catch (err) {
-    errors.assertError(err);
-    logger.error(
-      `working directory ${workingDirectory} ${err.code === "ENOENT" ? "does not exist" : "is not writable"}`
-    );
-    throw err;
-  }
-  return workingDirectory;
-}
-function getEntityBaseUrl(entity) {
-  let location = entity.metadata.annotations?.[catalogModel.ANNOTATION_SOURCE_LOCATION];
-  if (!location) {
-    location = entity.metadata.annotations?.[catalogModel.ANNOTATION_LOCATION];
-  }
-  if (!location) {
-    return void 0;
-  }
-  const { type, target } = catalogModel.parseLocationRef(location);
-  if (type === "url") {
-    return target;
-  } else if (type === "file") {
-    return `file://${target}`;
-  }
-  return void 0;
-}
-async function findTemplate(options) {
-  const { entityRef, token, catalogApi } = options;
-  if (entityRef.kind.toLocaleLowerCase("en-US") !== "template") {
-    throw new errors.InputError(`Invalid kind, only 'Template' kind is supported`);
-  }
-  const template = await catalogApi.getEntityByRef(entityRef, { token });
-  if (!template) {
-    throw new errors.NotFoundError(
-      `Template ${catalogModel.stringifyEntityRef(entityRef)} not found`
-    );
-  }
-  return template;
-}
-
 async function checkPermission(options) {
   const { permissions, permissionService, credentials } = options;
   if (permissionService) {
@@ -3600,22 +3815,37 @@ async function createRouter(options) {
       permissions: [alpha$1.taskReadPermission],
       permissionService: permissions
     });
-    const [userEntityRef] = [req.query.createdBy].flat();
-    if (typeof userEntityRef !== "string" && typeof userEntityRef !== "undefined") {
-      throw new errors.InputError("createdBy query parameter must be a string");
-    }
     if (!taskBroker.list) {
       throw new Error(
         "TaskBroker does not support listing tasks, please implement the list method on the TaskBroker."
       );
     }
-    const [statusQuery] = [req.query.status].flat();
-    if (typeof statusQuery !== "string" && typeof statusQuery !== "undefined") {
-      throw new errors.InputError("status query parameter must be a string");
-    }
+    const createdBy = parseStringsParam(req.query.createdBy, "createdBy");
+    const status = parseStringsParam(req.query.status, "status");
+    const order = parseStringsParam(req.query.order, "order")?.map((item) => {
+      const match = item.match(/^(asc|desc):(.+)$/);
+      if (!match) {
+        throw new errors.InputError(
+          `Invalid order parameter "${item}", expected "<asc or desc>:<field name>"`
+        );
+      }
+      return {
+        order: match[1],
+        field: match[2]
+      };
+    });
+    const limit = parseNumberParam(req.query.limit, "limit");
+    const offset = parseNumberParam(req.query.offset, "offset");
     const tasks = await taskBroker.list({
-      createdBy: userEntityRef,
-      status: statusQuery ? statusQuery : void 0
+      filters: {
+        createdBy,
+        status: status ? status : void 0
+      },
+      order,
+      pagination: {
+        limit: limit ? limit[0] : void 0,
+        offset: offset ? offset[0] : void 0
+      }
     });
     res.status(200).json(tasks);
   }).get("/v2/tasks/:taskId", async (req, res) => {
@@ -3642,6 +3872,16 @@ async function createRouter(options) {
     const { taskId } = req.params;
     await taskBroker.cancel?.(taskId);
     res.status(200).json({ status: "cancelled" });
+  }).post("/v2/tasks/:taskId/retry", async (req, res) => {
+    const credentials = await httpAuth.credentials(req);
+    await checkPermission({
+      credentials,
+      permissions: [alpha$1.taskCreatePermission, alpha$1.taskReadPermission],
+      permissionService: permissions
+    });
+    const { taskId } = req.params;
+    await taskBroker.retry?.(taskId);
+    res.status(201).json({ id: taskId });
   }).get("/v2/tasks/:taskId/eventstream", async (req, res) => {
     const credentials = await httpAuth.credentials(req);
     await checkPermission({
@@ -3673,7 +3913,7 @@ data: ${JSON.stringify(event)}
 
 `
           );
-          if (event.type === "completion") {
+          if (event.type === "completion" && !event.isTaskRecoverable) {
             shouldUnsubscribe = true;
           }
         }
@@ -3851,10 +4091,11 @@ exports.createFetchCatalogEntityAction = createFetchCatalogEntityAction;
 exports.createFetchPlainAction = createFetchPlainAction;
 exports.createFetchPlainFileAction = createFetchPlainFileAction;
 exports.createFetchTemplateAction = createFetchTemplateAction;
+exports.createFetchTemplateFileAction = createFetchTemplateFileAction;
 exports.createFilesystemDeleteAction = createFilesystemDeleteAction;
 exports.createFilesystemRenameAction = createFilesystemRenameAction;
 exports.createRouter = createRouter;
 exports.createWaitAction = createWaitAction;
 exports.scaffolderActionRules = scaffolderActionRules;
 exports.scaffolderTemplateRules = scaffolderTemplateRules;
-//# sourceMappingURL=router-B1lzg7oz.cjs.js.map
+//# sourceMappingURL=router-CC-UhVkG.cjs.js.map