@backstage/plugin-scaffolder-backend 1.2.0-next.1 → 1.3.0-next.1

package/dist/index.cjs.js

@@ -16,9 +16,10 @@ var child_process = require('child_process');
 var stream = require('stream');
 var azureDevopsNodeApi = require('azure-devops-node-api');
 var fetch = require('node-fetch');
+var crypto = require('crypto');
 var octokit = require('octokit');
-var lodash = require('lodash');
 var octokitPluginCreatePullRequest = require('octokit-plugin-create-pull-request');
+var limiterFactory = require('p-limit');
 var node = require('@gitbeaker/node');
 var webhooks = require('@octokit/webhooks');
 var uuid = require('uuid');
@@ -26,12 +27,15 @@ var luxon = require('luxon');
 var ObservableImpl = require('zen-observable');
 var winston = require('winston');
 var nunjucks = require('nunjucks');
+var lodash = require('lodash');
 var jsonschema = require('jsonschema');
+var pluginScaffolderCommon = require('@backstage/plugin-scaffolder-common');
 var express = require('express');
 var Router = require('express-promise-router');
+var zod = require('zod');
+var url = require('url');
 var os = require('os');
 var pluginCatalogBackend = require('@backstage/plugin-catalog-backend');
-var pluginScaffolderCommon = require('@backstage/plugin-scaffolder-common');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -58,6 +62,8 @@ var yaml__namespace = /*#__PURE__*/_interopNamespace(yaml);
 var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
 var globby__default = /*#__PURE__*/_interopDefaultLegacy(globby);
 var fetch__default = /*#__PURE__*/_interopDefaultLegacy(fetch);
+var crypto__default = /*#__PURE__*/_interopDefaultLegacy(crypto);
+var limiterFactory__default = /*#__PURE__*/_interopDefaultLegacy(limiterFactory);
 var ObservableImpl__default = /*#__PURE__*/_interopDefaultLegacy(ObservableImpl);
 var winston__namespace = /*#__PURE__*/_interopNamespace(winston);
 var nunjucks__default = /*#__PURE__*/_interopDefaultLegacy(nunjucks);
@@ -115,6 +121,18 @@ function createCatalogRegisterAction(options) {
             }
           }
         ]
+      },
+      output: {
+        type: "object",
+        required: ["catalogInfoUrl"],
+        properties: {
+          entityRef: {
+            type: "string"
+          },
+          catalogInfoUrl: {
+            type: "string"
+          }
+        }
       }
     },
     async handler(ctx) {
@@ -188,6 +206,7 @@ function createCatalogWriteAction() {
         }
       }
     },
+    supportsDryRun: true,
     async handler(ctx) {
       ctx.logStream.write(`Writing catalog-info.yaml`);
       const { filePath, entity } = ctx.input;
@@ -219,6 +238,7 @@ function createDebugLogAction() {
         }
       }
     },
+    supportsDryRun: true,
     async handler(ctx) {
       var _a, _b;
       ctx.logger.info(JSON.stringify(ctx.input, null, 2));
@@ -304,6 +324,7 @@ function createFetchPlainAction(options) {
         }
       }
     },
+    supportsDryRun: true,
     async handler(ctx) {
       var _a, _b;
       ctx.logger.info("Fetching plain content from remote URL");
@@ -470,6 +491,7 @@ function createFetchTemplateAction(options) {
         }
       }
     },
+    supportsDryRun: true,
     async handler(ctx) {
       var _a, _b;
       ctx.logger.info("Fetching template content from remote URL");
@@ -502,13 +524,15 @@ function createFetchTemplateAction(options) {
         cwd: templateDir,
         dot: true,
         onlyFiles: false,
-        markDirectories: true
+        markDirectories: true,
+        followSymbolicLinks: false
       });
       const nonTemplatedEntries = new Set((await Promise.all((ctx.input.copyWithoutRender || []).map((pattern) => globby__default["default"](pattern, {
         cwd: templateDir,
         dot: true,
         onlyFiles: false,
-        markDirectories: true
+        markDirectories: true,
+        followSymbolicLinks: false
       })))).flat());
       const { cookiecutterCompat, values } = ctx.input;
       const context = {
@@ -583,6 +607,7 @@ const createFilesystemDeleteAction = () => {
         }
       }
     },
+    supportsDryRun: true,
     async handler(ctx) {
       var _a;
       if (!Array.isArray((_a = ctx.input) == null ? void 0 : _a.files)) {
@@ -637,6 +662,7 @@ const createFilesystemRenameAction = () => {
         }
       }
     },
+    supportsDryRun: true,
     async handler(ctx) {
       var _a, _b;
       if (!Array.isArray((_a = ctx.input) == null ? void 0 : _a.files)) {
@@ -825,11 +851,6 @@ const parseRepoUrl = (repoUrl, integrations) => {
   }
   return { host, owner, repo, organization, workspace, project };
 };
-const isExecutable = (fileMode) => {
-  const executeBitMask = 73;
-  const res = fileMode & executeBitMask;
-  return res > 0;
-};
 
 function createPublishAzureAction(options) {
   const { integrations, config } = options;
@@ -1578,6 +1599,138 @@ function createPublishFileAction() {
   });
 }
 
+const createGerritProject = async (config, options) => {
+  const { projectName, parent, owner, description } = options;
+  const fetchOptions = {
+    method: "PUT",
+    body: JSON.stringify({
+      parent,
+      description,
+      owners: [owner],
+      create_empty_commit: false
+    }),
+    headers: {
+      ...integration.getGerritRequestOptions(config).headers,
+      "Content-Type": "application/json"
+    }
+  };
+  const response = await fetch__default["default"](`${config.baseUrl}/a/projects/${encodeURIComponent(projectName)}`, fetchOptions);
+  if (response.status !== 201) {
+    throw new Error(`Unable to create repository, ${response.status} ${response.statusText}, ${await response.text()}`);
+  }
+};
+const generateCommitMessage = (config, commitSubject) => {
+  const changeId = crypto__default["default"].randomBytes(20).toString("hex");
+  const msg = `${config.getOptionalString("scaffolder.defaultCommitMessage") || commitSubject}
+
+Change-Id: I${changeId}`;
+  return msg;
+};
+function createPublishGerritAction(options) {
+  const { integrations, config } = options;
+  return createTemplateAction({
+    id: "publish:gerrit",
+    description: "Initializes a git repository of the content in the workspace, and publishes it to Gerrit.",
+    schema: {
+      input: {
+        type: "object",
+        required: ["repoUrl"],
+        properties: {
+          repoUrl: {
+            title: "Repository Location",
+            type: "string"
+          },
+          description: {
+            title: "Repository Description",
+            type: "string"
+          },
+          defaultBranch: {
+            title: "Default Branch",
+            type: "string",
+            description: `Sets the default branch on the repository. The default value is 'master'`
+          },
+          gitCommitMessage: {
+            title: "Git Commit Message",
+            type: "string",
+            description: `Sets the commit message on the repository. The default value is 'initial commit'`
+          },
+          gitAuthorName: {
+            title: "Default Author Name",
+            type: "string",
+            description: `Sets the default author name for the commit. The default value is 'Scaffolder'`
+          },
+          gitAuthorEmail: {
+            title: "Default Author Email",
+            type: "string",
+            description: `Sets the default author email for the commit.`
+          }
+        }
+      },
+      output: {
+        type: "object",
+        properties: {
+          remoteUrl: {
+            title: "A URL to the repository with the provider",
+            type: "string"
+          },
+          repoContentsUrl: {
+            title: "A URL to the root of the repository",
+            type: "string"
+          }
+        }
+      }
+    },
+    async handler(ctx) {
+      const {
+        repoUrl,
+        description,
+        defaultBranch = "master",
+        gitAuthorName,
+        gitAuthorEmail,
+        gitCommitMessage = "initial commit"
+      } = ctx.input;
+      const { repo, host, owner, workspace } = parseRepoUrl(repoUrl, integrations);
+      const integrationConfig = integrations.gerrit.byHost(host);
+      if (!integrationConfig) {
+        throw new errors.InputError(`No matching integration configuration for host ${host}, please check your integrations config`);
+      }
+      if (!owner) {
+        throw new errors.InputError(`Invalid URL provider was included in the repo URL to create ${ctx.input.repoUrl}, missing owner`);
+      }
+      if (!workspace) {
+        throw new errors.InputError(`Invalid URL provider was included in the repo URL to create ${ctx.input.repoUrl}, missing workspace`);
+      }
+      await createGerritProject(integrationConfig.config, {
+        description,
+        owner,
+        projectName: repo,
+        parent: workspace
+      });
+      const auth = {
+        username: integrationConfig.config.username,
+        password: integrationConfig.config.password
+      };
+      const gitAuthorInfo = {
+        name: gitAuthorName ? gitAuthorName : config.getOptionalString("scaffolder.defaultAuthor.name"),
+        email: gitAuthorEmail ? gitAuthorEmail : config.getOptionalString("scaffolder.defaultAuthor.email")
+      };
+      const remoteUrl = `${integrationConfig.config.cloneUrl}/a/${repo}`;
+      await initRepoAndPush({
+        dir: getRepoSourceDirectory(ctx.workspacePath, void 0),
+        remoteUrl,
+        auth,
+        defaultBranch,
+        logger: ctx.logger,
+        commitMessage: generateCommitMessage(config, gitCommitMessage),
+        gitAuthorInfo
+      });
+      const repoContentsUrl = `${integrationConfig.config.gitilesBaseUrl}/${repo}/+/refs/heads/${defaultBranch}`;
+      ctx.output("remoteUrl", remoteUrl);
+      ctx.output("repoContentsUrl", repoContentsUrl);
+    }
+  });
+}
+
 const DEFAULT_TIMEOUT_MS = 6e4;
 async function getOctokitOptions(options) {
   var _a;
@@ -1662,6 +1815,11 @@ function createPublishGithubAction(options) {
             type: "string",
             description: `Sets the default branch on the repository. The default value is 'master'`
           },
+          protectDefaultBranch: {
+            title: "Protect Default Branch",
+            type: "boolean",
+            description: `Protect the default branch after creating the repository. The default value is 'true'`
+          },
           deleteBranchOnMerge: {
             title: "Delete Branch On Merge",
             type: "boolean",
@@ -1759,6 +1917,7 @@ function createPublishGithubAction(options) {
         requiredStatusCheckContexts = [],
         repoVisibility = "private",
         defaultBranch = "master",
+        protectDefaultBranch = true,
         deleteBranchOnMerge = false,
         gitCommitMessage = "initial commit",
         gitAuthorName,
@@ -1803,7 +1962,16 @@ function createPublishGithubAction(options) {
         allow_squash_merge: allowSquashMerge,
         allow_rebase_merge: allowRebaseMerge
       });
-      const { data: newRepo } = await repoCreationPromise;
+      let newRepo;
+      try {
+        newRepo = (await repoCreationPromise).data;
+      } catch (e) {
+        errors.assertError(e);
+        if (e.message === "Resource not accessible by integration") {
+          ctx.logger.warn(`The GitHub app or token provided may not have the required permissions to create the ${user.data.type} repository ${owner}/${repo}.`);
+        }
+        throw new Error(`Failed to create the ${user.data.type} repository ${owner}/${repo}, ${e.message}`);
+      }
       if (access == null ? void 0 : access.startsWith(`${owner}/`)) {
         const [, team] = access.split("/");
         await client.rest.teams.addOrUpdateRepoPermissionsInOrg({
@@ -1870,19 +2038,21 @@ function createPublishGithubAction(options) {
         commitMessage: gitCommitMessage ? gitCommitMessage : config.getOptionalString("scaffolder.defaultCommitMessage"),
         gitAuthorInfo
       });
-      try {
-        await enableBranchProtectionOnDefaultRepoBranch({
-          owner,
-          client,
-          repoName: newRepo.name,
-          logger: ctx.logger,
-          defaultBranch,
-          requireCodeOwnerReviews,
-          requiredStatusCheckContexts
-        });
-      } catch (e) {
-        errors.assertError(e);
-        ctx.logger.warn(`Skipping: default branch protection on '${newRepo.name}', ${e.message}`);
+      if (protectDefaultBranch) {
+        try {
+          await enableBranchProtectionOnDefaultRepoBranch({
+            owner,
+            client,
+            repoName: newRepo.name,
+            logger: ctx.logger,
+            defaultBranch,
+            requireCodeOwnerReviews,
+            requiredStatusCheckContexts
+          });
+        } catch (e) {
+          errors.assertError(e);
+          ctx.logger.warn(`Skipping: default branch protection on '${newRepo.name}', ${e.message}`);
+        }
       }
       ctx.output("remoteUrl", remoteUrl);
       ctx.output("repoContentsUrl", repoContentsUrl);
@@ -1890,6 +2060,41 @@ function createPublishGithubAction(options) {
   });
 }
 
+const DEFAULT_GLOB_PATTERNS = ["./**", "!.git"];
+const isExecutable = (fileMode) => {
+  if (!fileMode) {
+    return false;
+  }
+  const executeBitMask = 73;
+  const res = fileMode & executeBitMask;
+  return res > 0;
+};
+async function serializeDirectoryContents(sourcePath, options) {
+  var _a;
+  const paths = await globby__default["default"]((_a = options == null ? void 0 : options.globPatterns) != null ? _a : DEFAULT_GLOB_PATTERNS, {
+    cwd: sourcePath,
+    dot: true,
+    gitignore: options == null ? void 0 : options.gitignore,
+    followSymbolicLinks: false,
+    objectMode: true,
+    stats: true
+  });
+  const limiter = limiterFactory__default["default"](10);
+  return Promise.all(paths.map(async ({ path: path$1, stats }) => ({
+    path: path$1,
+    content: await limiter(async () => fs__default["default"].readFile(path.join(sourcePath, path$1))),
+    executable: isExecutable(stats == null ? void 0 : stats.mode)
+  })));
+}
+
+async function deserializeDirectoryContents(targetPath, files) {
+  for (const file of files) {
+    const filePath = backendCommon.resolveSafeChildPath(targetPath, file.path);
+    await fs__default["default"].ensureDir(path.dirname(filePath));
+    await fs__default["default"].writeFile(filePath, file.content);
+  }
+}
+
 class GithubResponseError extends errors.CustomErrorBase {
 }
 const defaultClientFactory = async ({
@@ -2005,38 +2210,28 @@ const createPublishGithubPullRequestAction = ({
         token: providedToken
       });
       const fileRoot = sourcePath ? backendCommon.resolveSafeChildPath(ctx.workspacePath, sourcePath) : ctx.workspacePath;
-      const localFilePaths = await globby__default["default"](["./**", "./**/.*", "!.git"], {
-        cwd: fileRoot,
-        gitignore: true,
-        dot: true
-      });
-      const fileContents = await Promise.all(localFilePaths.map((filePath) => {
-        const absPath = backendCommon.resolveSafeChildPath(fileRoot, filePath);
-        const base64EncodedContent = fs__default["default"].readFileSync(absPath).toString("base64");
-        const fileStat = fs__default["default"].statSync(absPath);
-        const githubTreeItemMode = isExecutable(fileStat.mode) ? "100755" : "100644";
-        const encoding = "base64";
-        return {
-          encoding,
-          content: base64EncodedContent,
-          mode: githubTreeItemMode
-        };
-      }));
-      const repoFilePaths = localFilePaths.map((repoFilePath) => {
-        return targetPath ? `${targetPath}/${repoFilePath}` : repoFilePath;
+      const directoryContents = await serializeDirectoryContents(fileRoot, {
+        gitignore: true
       });
-      const changes = [
+      const files = Object.fromEntries(directoryContents.map((file) => [
+        targetPath ? path__default["default"].posix.join(targetPath, file.path) : file.path,
         {
-          files: lodash.zipObject(repoFilePaths, fileContents),
-          commit: title
+          mode: file.executable ? "100755" : "100644",
+          encoding: "base64",
+          content: file.content.toString("base64")
         }
-      ];
+      ]));
       try {
         const response = await client.createPullRequest({
           owner,
           repo,
           title,
-          changes,
+          changes: [
+            {
+              files,
+              commit: title
+            }
+          ],
           body: description,
           head: branchName,
           draft
@@ -2244,7 +2439,6 @@ const createPublishGitlabMergeRequestAction = (options) => {
       const repoUrl = ctx.input.repoUrl;
       const { host } = parseRepoUrl(repoUrl, integrations);
       const integrationConfig = integrations.gitlab.byHost(host);
-      const actions = [];
       const destinationBranch = ctx.input.branchName;
       if (!integrationConfig) {
         throw new errors.InputError(`No matching integration configuration for host ${host}, please check your integrations config`);
@@ -2258,23 +2452,17 @@ const createPublishGitlabMergeRequestAction = (options) => {
         host: integrationConfig.config.baseUrl,
         [tokenType]: token
       });
-      const fileRoot = ctx.workspacePath;
-      const localFilePaths = await globby__default["default"]([`${ctx.input.targetPath}/**`], {
-        cwd: fileRoot,
-        gitignore: true,
-        dot: true
+      const targetPath = backendCommon.resolveSafeChildPath(ctx.workspacePath, ctx.input.targetPath);
+      const fileContents = await serializeDirectoryContents(targetPath, {
+        gitignore: true
       });
-      const fileContents = await Promise.all(localFilePaths.map((p) => fs.readFile(backendCommon.resolveSafeChildPath(fileRoot, p))));
-      const repoFilePaths = localFilePaths.map((repoFilePath) => {
-        return repoFilePath;
-      });
-      for (let i = 0; i < repoFilePaths.length; i++) {
-        actions.push({
-          action: "create",
-          filePath: repoFilePaths[i],
-          content: fileContents[i].toString()
-        });
-      }
+      const actions = fileContents.map((file) => ({
+        action: "create",
+        filePath: path__default["default"].posix.join(ctx.input.targetPath, file.path),
+        encoding: "base64",
+        content: file.content.toString("base64"),
+        execute_filemode: file.executable
+      }));
       const projects = await api.Projects.show(ctx.input.projectid);
       const { default_branch: defaultBranch } = projects;
       try {
@@ -2566,6 +2754,10 @@ const createBuiltinActions = (options) => {
       reader,
       additionalTemplateFilters
     }),
+    createPublishGerritAction({
+      integrations,
+      config
+    }),
     createPublishGithubAction({
       integrations,
       config,
@@ -2959,6 +3151,32 @@ class StorageTaskBroker {
 function isTruthy(value) {
   return lodash.isArray(value) ? value.length > 0 : !!value;
 }
+function generateExampleOutput(schema) {
+  var _a, _b;
+  const { examples } = schema;
+  if (examples && Array.isArray(examples)) {
+    return examples[0];
+  }
+  if (schema.type === "object") {
+    return Object.fromEntries(Object.entries((_a = schema.properties) != null ? _a : {}).map(([key, value]) => [
+      key,
+      generateExampleOutput(value)
+    ]));
+  } else if (schema.type === "array") {
+    const [firstSchema] = (_b = [schema.items]) == null ? void 0 : _b.flat();
+    if (firstSchema) {
+      return [generateExampleOutput(firstSchema)];
+    }
+    return [];
+  } else if (schema.type === "string") {
+    return "<example>";
+  } else if (schema.type === "number") {
+    return 0;
+  } else if (schema.type === "boolean") {
+    return false;
+  }
+  return "<unknown>";
+}
 
 const isValidTaskSpec = (taskSpec) => {
   return taskSpec.apiVersion === "scaffolder.backstage.io/v1beta3";
@@ -3028,7 +3246,7 @@ class NunjucksWorkflowRunner {
     });
   }
   async execute(task) {
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e;
     if (!isValidTaskSpec(task.spec)) {
       throw new errors.InputError("Wrong template version executed with the workflow engine");
     }
@@ -3063,8 +3281,23 @@ class NunjucksWorkflowRunner {
           });
           const action = this.options.actionRegistry.get(step.action);
           const { taskLogger, streamLogger } = createStepLogger({ task, step });
-          const input = (_b = step.input && this.render(step.input, { ...context, secrets: (_a = task.secrets) != null ? _a : {} }, renderTemplate)) != null ? _b : {};
-          if ((_c = action.schema) == null ? void 0 : _c.input) {
+          if (task.isDryRun && !action.supportsDryRun) {
+            task.emitLog(`Skipping because ${action.id} does not support dry-run`, {
+              stepId: step.id,
+              status: "skipped"
+            });
+            const outputSchema = (_a = action.schema) == null ? void 0 : _a.output;
+            if (outputSchema) {
+              context.steps[step.id] = {
+                output: generateExampleOutput(outputSchema)
+              };
+            } else {
+              context.steps[step.id] = { output: {} };
+            }
+            continue;
+          }
+          const input = (_c = step.input && this.render(step.input, { ...context, secrets: (_b = task.secrets) != null ? _b : {} }, renderTemplate)) != null ? _c : {};
+          if ((_d = action.schema) == null ? void 0 : _d.input) {
             const validateResult = jsonschema.validate(input, action.schema.input);
             if (!validateResult.valid) {
               const errors$1 = validateResult.errors.join(", ");
@@ -3075,7 +3308,7 @@ class NunjucksWorkflowRunner {
           const stepOutput = {};
           await action.handler({
             input,
-            secrets: (_d = task.secrets) != null ? _d : {},
+            secrets: (_e = task.secrets) != null ? _e : {},
             logger: taskLogger,
             logStream: streamLogger,
             workspacePath,
@@ -3164,6 +3397,95 @@ class TaskWorker {
   }
 }
 
+class DecoratedActionsRegistry extends TemplateActionRegistry {
+  constructor(innerRegistry, extraActions) {
+    super();
+    this.innerRegistry = innerRegistry;
+    for (const action of extraActions) {
+      this.register(action);
+    }
+  }
+  get(actionId) {
+    try {
+      return super.get(actionId);
+    } catch {
+      return this.innerRegistry.get(actionId);
+    }
+  }
+}
+
+function createDryRunner(options) {
+  return async function dryRun(input) {
+    let contentPromise;
+    const workflowRunner = new NunjucksWorkflowRunner({
+      ...options,
+      actionRegistry: new DecoratedActionsRegistry(options.actionRegistry, [
+        createTemplateAction({
+          id: "dry-run:extract",
+          supportsDryRun: true,
+          async handler(ctx) {
+            contentPromise = serializeDirectoryContents(ctx.workspacePath);
+            await contentPromise.catch(() => {
+            });
+          }
+        })
+      ])
+    });
+    const dryRunId = uuid.v4();
+    const log = new Array();
+    const contentsPath = backendCommon.resolveSafeChildPath(options.workingDirectory, `dry-run-content-${dryRunId}`);
+    try {
+      await deserializeDirectoryContents(contentsPath, input.directoryContents);
+      const result = await workflowRunner.execute({
+        spec: {
+          ...input.spec,
+          steps: [
+            ...input.spec.steps,
+            {
+              id: dryRunId,
+              name: "dry-run:extract",
+              action: "dry-run:extract"
+            }
+          ],
+          templateInfo: {
+            entityRef: "template:default/dry-run",
+            baseUrl: url.pathToFileURL(backendCommon.resolveSafeChildPath(contentsPath, "template.yaml")).toString()
+          }
+        },
+        secrets: input.secrets,
+        done: false,
+        isDryRun: true,
+        getWorkspaceName: async () => `dry-run-${dryRunId}`,
+        async emitLog(message, logMetadata) {
+          if ((logMetadata == null ? void 0 : logMetadata.stepId) === dryRunId) {
+            return;
+          }
+          log.push({
+            body: {
+              ...logMetadata,
+              message
+            }
+          });
+        },
+        async complete() {
+          throw new Error("Not implemented");
+        }
+      });
+      if (!contentPromise) {
+        throw new Error("Content extraction step was skipped");
+      }
+      const directoryContents = await contentPromise;
+      return {
+        log,
+        directoryContents,
+        output: result.output
+      };
+    } finally {
+      await fs__default["default"].remove(contentsPath);
+    }
+  };
+}
+
 async function getWorkingDirectory(config, logger) {
   if (!config.has("backend.workingDirectory")) {
     return os__default["default"].tmpdir();
@@ -3261,6 +3583,13 @@ async function createRouter(options) {
   });
   actionsToRegister.forEach((action) => actionRegistry.register(action));
   workers.forEach((worker) => worker.start());
+  const dryRunner = createDryRunner({
+    actionRegistry,
+    integrations,
+    logger,
+    workingDirectory,
+    additionalTemplateFilters
+  });
   router.get("/v2/templates/:namespace/:kind/:name/parameter-schema", async (req, res) => {
     var _a, _b;
     const { namespace, kind, name } = req.params;
@@ -3415,6 +3744,62 @@ data: ${JSON.stringify(event)}
       subscription.unsubscribe();
       clearTimeout(timeout);
     });
+  }).post("/v2/dry-run", async (req, res) => {
+    var _a, _b, _c;
+    const bodySchema = zod.z.object({
+      template: zod.z.unknown(),
+      values: zod.z.record(zod.z.unknown()),
+      secrets: zod.z.record(zod.z.string()).optional(),
+      directoryContents: zod.z.array(zod.z.object({ path: zod.z.string(), base64Content: zod.z.string() }))
+    });
+    const body = await bodySchema.parseAsync(req.body).catch((e) => {
+      throw new errors.InputError(`Malformed request: ${e}`);
+    });
+    const template = body.template;
+    if (!await pluginScaffolderCommon.templateEntityV1beta3Validator.check(template)) {
+      throw new errors.InputError("Input template is not a template");
+    }
+    const { token } = parseBearerToken(req.headers.authorization);
+    for (const parameters of [(_a = template.spec.parameters) != null ? _a : []].flat()) {
+      const result2 = jsonschema.validate(body.values, parameters);
+      if (!result2.valid) {
+        res.status(400).json({ errors: result2.errors });
+        return;
+      }
+    }
+    const steps = template.spec.steps.map((step, index) => {
+      var _a2, _b2;
+      return {
+        ...step,
+        id: (_a2 = step.id) != null ? _a2 : `step-${index + 1}`,
+        name: (_b2 = step.name) != null ? _b2 : step.action
+      };
+    });
+    const result = await dryRunner({
+      spec: {
+        apiVersion: template.apiVersion,
+        steps,
+        output: (_b = template.spec.output) != null ? _b : {},
+        parameters: body.values
+      },
+      directoryContents: ((_c = body.directoryContents) != null ? _c : []).map((file) => ({
+        path: file.path,
+        content: Buffer.from(file.base64Content, "base64")
+      })),
+      secrets: {
+        ...body.secrets,
+        ...token && { backstageToken: token }
+      }
+    });
+    res.status(200).json({
+      ...result,
+      steps,
+      directoryContents: result.directoryContents.map((file) => ({
+        path: file.path,
+        executable: file.executable,
+        base64Content: file.content.toString("base64")
+      }))
+    });
   });
   const app = express__default["default"]();
   app.set("logger", logger);
@@ -3504,6 +3889,7 @@ exports.createPublishBitbucketAction = createPublishBitbucketAction;
 exports.createPublishBitbucketCloudAction = createPublishBitbucketCloudAction;
 exports.createPublishBitbucketServerAction = createPublishBitbucketServerAction;
 exports.createPublishFileAction = createPublishFileAction;
+exports.createPublishGerritAction = createPublishGerritAction;
 exports.createPublishGithubAction = createPublishGithubAction;
 exports.createPublishGithubPullRequestAction = createPublishGithubPullRequestAction;
 exports.createPublishGitlabAction = createPublishGitlabAction;