@pagopa/dx-cli 0.24.0 → 0.25.1

package/dist/adapters/plop/actions/sync-repository-environments.js

@@ -0,0 +1,98 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { tf$ } from "../../execa/terraform.js";
+import { payloadSchema, } from "../generators/environment/prompts.js";
+const KNOWN_ENVIRONMENTS = ["dev", "uat", "prod"];
+const KNOWN_ENVIRONMENT_NAMES = KNOWN_ENVIRONMENTS;
+const environmentList = (environments) => `[${[
+    ...KNOWN_ENVIRONMENTS.filter((environment) => environments.has(environment)),
+    ...Array.from(environments).filter((environment) => !KNOWN_ENVIRONMENT_NAMES.includes(environment)),
+]
+    .map((environment) => `"${environment}"`)
+    .join(", ")}]`;
+/**
+ * Returns the inner body of the `repository = { ... }` object.
+ *
+ * Example input:
+ * repository = {
+ *   name = "repo"
+ * }
+ *
+ * Example output:
+ *   name = "repo"
+ */
+const findRepositoryBlock = (content) => {
+    const match = /(?:^|\n)(?<indent>[^\S\r\n]*)repository[^\S\r\n]*=[^\S\r\n]*\{\n/.exec(content);
+    if (!match) {
+        throw new Error("Cannot find the repository configuration in infra/repository/main.tf");
+    }
+    const blockStart = match.index + match[0].length;
+    const closingMatch = new RegExp(`\\n${match.groups?.indent ?? ""}\\}`).exec(content.slice(blockStart));
+    if (!closingMatch) {
+        throw new Error("Cannot find the end of the repository configuration in infra/repository/main.tf");
+    }
+    const end = blockStart + closingMatch.index;
+    return { block: content.slice(blockStart, end), end, start: blockStart };
+};
+const repositoryPropertyIndent = (block) => {
+    const propertyMatch = /^(?<indent>\s*)\w+\s*=/m.exec(block);
+    return propertyMatch?.groups?.indent ?? "    ";
+};
+const readRepositoryConfig = async (repositoryMainPath) => {
+    try {
+        return await fs.readFile(repositoryMainPath, "utf8");
+    }
+    catch (cause) {
+        throw new Error(`Cannot synchronize GitHub repository environments because ${path.relative(process.cwd(), repositoryMainPath)} does not exist or is not readable.`, { cause });
+    }
+};
+export const syncRepositoryTerraformEnvironments = (content, environmentName) => {
+    const repositoryBlock = findRepositoryBlock(content);
+    const environmentsMatch = /^(?<indent>\s*)environments\s*=\s*\[(?<values>[\s\S]*?)\]\s*$/m.exec(repositoryBlock.block);
+    if (!environmentsMatch) {
+        if (environmentName === "prod") {
+            return content;
+        }
+        // Without an explicit list, the Terraform module manages prod by default.
+        // Adding a non-prod environment must also keep prod explicit.
+        const environments = new Set([environmentName, "prod"]);
+        const propertyIndent = repositoryPropertyIndent(repositoryBlock.block);
+        const separator = repositoryBlock.block.endsWith("\n") ? "" : "\n";
+        const updatedBlock = `${repositoryBlock.block}${separator}${propertyIndent}environments           = ${environmentList(environments)}`;
+        return `${content.slice(0, repositoryBlock.start)}${updatedBlock}${content.slice(repositoryBlock.end)}`;
+    }
+    const existingEnvironments = new Set(Array.from((environmentsMatch.groups?.values ?? "").matchAll(/"([^"]+)"/g))
+        .map((match) => match[1])
+        .filter((environment) => environment.length > 0));
+    const hasSelectedEnvironment = existingEnvironments.has(environmentName);
+    const hasProdEnvironment = existingEnvironments.has("prod");
+    if (hasSelectedEnvironment && hasProdEnvironment) {
+        return content;
+    }
+    existingEnvironments.add(environmentName);
+    existingEnvironments.add("prod");
+    const indent = environmentsMatch.groups?.indent ?? "    ";
+    const updatedLine = `${indent}environments           = ${environmentList(existingEnvironments)}`;
+    const updatedBlock = repositoryBlock.block.replace(environmentsMatch[0], updatedLine);
+    return `${content.slice(0, repositoryBlock.start)}${updatedBlock}${content.slice(repositoryBlock.end)}`;
+};
+export const syncRepositoryEnvironments = async (payload) => {
+    const repositoryPath = path.join(process.cwd(), "infra", "repository");
+    const repositoryMainPath = path.join(repositoryPath, "main.tf");
+    const currentRepositoryConfig = await readRepositoryConfig(repositoryMainPath);
+    const updatedRepositoryConfig = syncRepositoryTerraformEnvironments(currentRepositoryConfig, payload.env.name);
+    if (updatedRepositoryConfig !== currentRepositoryConfig) {
+        await fs.writeFile(repositoryMainPath, updatedRepositoryConfig, "utf8");
+    }
+    const repositoryTerraform = tf$({ cwd: repositoryPath });
+    await repositoryTerraform `terraform init`;
+    await repositoryTerraform `terraform apply -auto-approve`;
+};
+export default function (plop) {
+    plop.setActionType("syncRepositoryEnvironments", async (data) => {
+        const payload = payloadSchema.parse(data);
+        await syncRepositoryEnvironments(payload);
+        return "GitHub repository environments updated from Terraform";
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sync-repository-environments.js","sourceRoot":"","sources":["../../../../src/adapters/plop/actions/sync-repository-environments.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Updates infra/repository/main.tf and applies it so GitHub.com repository\n * environments exist before deployment scaffolding continues.\n *\n * The repository Terraform module remains the source of truth for GitHub\n * environments, including protection rules and reviewers. This action only\n * changes the module's `repository.environments` input, then runs Terraform from\n * infra/repository to create or update the environments on GitHub.\n */\nimport { type NodePlopAPI } from \"node-plop\";\nimport fs from \"node:fs/promises\";\nimport path from \"node:path\";\n\nimport type { Environment } from \"../../../domain/environment.js\";\n\nimport { tf$ } from \"../../execa/terraform.js\";\nimport {\n  type Payload,\n  payloadSchema,\n} from \"../generators/environment/prompts.js\";\n\nconst KNOWN_ENVIRONMENTS: Environment[\"name\"][] = [\"dev\", \"uat\", \"prod\"];\nconst KNOWN_ENVIRONMENT_NAMES: readonly string[] = KNOWN_ENVIRONMENTS;\n\nconst environmentList = (environments: Set<string>): string =>\n  `[${[\n    ...KNOWN_ENVIRONMENTS.filter((environment) =>\n      environments.has(environment),\n    ),\n    ...Array.from(environments).filter(\n      (environment) => !KNOWN_ENVIRONMENT_NAMES.includes(environment),\n    ),\n  ]\n    .map((environment) => `\"${environment}\"`)\n    .join(\", \")}]`;\n\n/**\n * Returns the inner body of the `repository = { ... }` object.\n *\n * Example input:\n * repository = {\n *   name = \"repo\"\n * }\n *\n * Example output:\n *   name = \"repo\"\n */\nconst findRepositoryBlock = (\n  content: string,\n): { block: string; end: number; start: number } => {\n  const match =\n    /(?:^|\\n)(?<indent>[^\\S\\r\\n]*)repository[^\\S\\r\\n]*=[^\\S\\r\\n]*\\{\\n/.exec(\n      content,\n    );\n  if (!match) {\n    throw new Error(\n      \"Cannot find the repository configuration in infra/repository/main.tf\",\n    );\n  }\n\n  const blockStart = match.index + match[0].length;\n  const closingMatch = new RegExp(`\\\\n${match.groups?.indent ?? \"\"}\\\\}`).exec(\n    content.slice(blockStart),\n  );\n  if (!closingMatch) {\n    throw new Error(\n      \"Cannot find the end of the repository configuration in infra/repository/main.tf\",\n    );\n  }\n\n  const end = blockStart + closingMatch.index;\n  return { block: content.slice(blockStart, end), end, start: blockStart };\n};\n\nconst repositoryPropertyIndent = (block: string): string => {\n  const propertyMatch = /^(?<indent>\\s*)\\w+\\s*=/m.exec(block);\n  return propertyMatch?.groups?.indent ?? \"    \";\n};\n\nconst readRepositoryConfig = async (repositoryMainPath: string) => {\n  try {\n    return await fs.readFile(repositoryMainPath, \"utf8\");\n  } catch (cause) {\n    throw new Error(\n      `Cannot synchronize GitHub repository environments because ${path.relative(process.cwd(), repositoryMainPath)} does not exist or is not readable.`,\n      { cause },\n    );\n  }\n};\n\nexport const syncRepositoryTerraformEnvironments = (\n  content: string,\n  environmentName: Environment[\"name\"],\n): string => {\n  const repositoryBlock = findRepositoryBlock(content);\n  const environmentsMatch =\n    /^(?<indent>\\s*)environments\\s*=\\s*\\[(?<values>[\\s\\S]*?)\\]\\s*$/m.exec(\n      repositoryBlock.block,\n    );\n\n  if (!environmentsMatch) {\n    if (environmentName === \"prod\") {\n      return content;\n    }\n\n    // Without an explicit list, the Terraform module manages prod by default.\n    // Adding a non-prod environment must also keep prod explicit.\n    const environments = new Set<string>([environmentName, \"prod\"]);\n    const propertyIndent = repositoryPropertyIndent(repositoryBlock.block);\n    const separator = repositoryBlock.block.endsWith(\"\\n\") ? \"\" : \"\\n\";\n    const updatedBlock = `${repositoryBlock.block}${separator}${propertyIndent}environments           = ${environmentList(environments)}`;\n    return `${content.slice(0, repositoryBlock.start)}${updatedBlock}${content.slice(repositoryBlock.end)}`;\n  }\n\n  const existingEnvironments = new Set(\n    Array.from((environmentsMatch.groups?.values ?? \"\").matchAll(/\"([^\"]+)\"/g))\n      .map((match) => match[1])\n      .filter((environment) => environment.length > 0),\n  );\n  const hasSelectedEnvironment = existingEnvironments.has(environmentName);\n  const hasProdEnvironment = existingEnvironments.has(\"prod\");\n  if (hasSelectedEnvironment && hasProdEnvironment) {\n    return content;\n  }\n\n  existingEnvironments.add(environmentName);\n  existingEnvironments.add(\"prod\");\n  const indent = environmentsMatch.groups?.indent ?? \"    \";\n  const updatedLine = `${indent}environments           = ${environmentList(existingEnvironments)}`;\n  const updatedBlock = repositoryBlock.block.replace(\n    environmentsMatch[0],\n    updatedLine,\n  );\n\n  return `${content.slice(0, repositoryBlock.start)}${updatedBlock}${content.slice(repositoryBlock.end)}`;\n};\n\nexport const syncRepositoryEnvironments = async (\n  payload: Payload,\n): Promise<void> => {\n  const repositoryPath = path.join(process.cwd(), \"infra\", \"repository\");\n  const repositoryMainPath = path.join(repositoryPath, \"main.tf\");\n\n  const currentRepositoryConfig =\n    await readRepositoryConfig(repositoryMainPath);\n  const updatedRepositoryConfig = syncRepositoryTerraformEnvironments(\n    currentRepositoryConfig,\n    payload.env.name,\n  );\n\n  if (updatedRepositoryConfig !== currentRepositoryConfig) {\n    await fs.writeFile(repositoryMainPath, updatedRepositoryConfig, \"utf8\");\n  }\n\n  const repositoryTerraform = tf$({ cwd: repositoryPath });\n  await repositoryTerraform`terraform init`;\n  await repositoryTerraform`terraform apply -auto-approve`;\n};\n\nexport default function (plop: NodePlopAPI): void {\n  plop.setActionType(\"syncRepositoryEnvironments\", async (data) => {\n    const payload = payloadSchema.parse(data);\n    await syncRepositoryEnvironments(payload);\n    return \"GitHub repository environments updated from Terraform\";\n  });\n}\n"]}

package/dist/adapters/plop/generators/environment/actions.js

@@ -56,6 +56,9 @@ export default function getActions(templatesPath) {
             {
                 type: "getTerraformBackend",
             },
+            {
+                type: "syncRepositoryEnvironments",
+            },
             addWorkflowModule(templatesPath),
             ...addEnvironmentModule("bootstrapper"),
         ];
@@ -72,4 +75,4 @@ export default function getActions(templatesPath) {
         return actions;
     };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWN0aW9ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9hZGFwdGVycy9wbG9wL2dlbmVyYXRvcnMvZW52aXJvbm1lbnQvYWN0aW9ucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDN0MsT0FBTyxJQUFJLE1BQU0sV0FBVyxDQUFDO0FBRTdCLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBQ2hFLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLHNDQUFzQyxDQUFDO0FBRXpFLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxjQUFjLENBQUM7QUFFN0MsTUFBTSxTQUFTLEdBQUcsQ0FDaEIsT0FBMkMsRUFDM0MsYUFBcUIsRUFDckIsSUFBSSxHQUFHLEtBQUssRUFDWixFQUFFO0lBQ0YsTUFBTSxFQUFFLEdBQUcsRUFBRSxHQUFHLE9BQU8sQ0FBQztJQUN4QixNQUFNLGtCQUFrQixHQUFHLE1BQU0sQ0FBQyxPQUFPLENBQ3ZDLEdBQUcsQ0FBQyxhQUFhLEVBQ2pCLENBQUMsT0FBTyxFQUFFLEVBQUUsQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUN6QixDQUFDO0lBQ0YsTUFBTSxjQUFjLEdBQUcsR0FBRyxDQUFDLGFBQWEsQ0FBQyxJQUFJLENBQzNDLENBQUMsT0FBTyxFQUFFLEVBQUUsQ0FBQyxPQUFPLENBQUMsV0FBVyxLQUFLLFNBQVMsQ0FDL0MsQ0FBQztJQUNGLE1BQU0sR0FBRyxHQUFHLE9BQU8sQ0FBQyxHQUFHLEVBQUUsQ0FBQztJQUMxQixPQUFPLENBQUMsSUFBWSxFQUFFLEVBQUUsQ0FBQztRQUN2QjtZQUNFLElBQUksRUFBRSxhQUFhO1lBQ25CLElBQUksRUFBRSxFQUFFLGtCQUFrQixFQUFFLGNBQWMsRUFBRSxJQUFJLEVBQUUsSUFBSSxJQUFJLFNBQVMsRUFBRTtZQUNyRSxXQUFXLEVBQUUsSUFBSSxDQUFDLElBQUksQ0FBQyxHQUFHLEVBQUUsT0FBTyxDQUFDO1lBQ3BDLEtBQUssRUFBRSxJQUFJO1lBQ1gsYUFBYSxFQUFFLElBQUksQ0FBQyxJQUFJLENBQUMsYUFBYSxFQUFFLElBQUksQ0FBQztZQUM3QyxTQUFTLEVBQUUsbUJBQW1CO1lBQzlCLElBQUksRUFBRSxTQUFTO1lBQ2YsT0FBTyxFQUFFLElBQUk7U0FDZDtRQUNEO1lBQ0UsSUFBSSxFQUFFLElBQUksQ0FBQyxJQUFJLENBQUMsYUFBYSxFQUFFLFFBQVEsQ0FBQztZQUN4QyxJQUFJLEVBQUU7Z0JBQ0osa0JBQWtCO2dCQUNsQixJQUFJLEVBQUUsSUFBSSxJQUFJLFNBQVM7Z0JBQ3ZCLG1CQUFtQixFQUFFLGlCQUFpQixDQUFDLE9BQU8sRUFBRSxJQUFJLENBQUM7YUFDdEQ7WUFDRCxXQUFXLEVBQUUsSUFBSSxDQUFDLElBQUksQ0FBQyxHQUFHLEVBQUUsT0FBTyxFQUFFLElBQUksRUFBRSxjQUFjLENBQUM7WUFDMUQsS0FBSyxFQUFFLElBQUk7WUFDWCxhQUFhLEVBQUUsSUFBSSxDQUFDLElBQUksQ0FBQyxhQUFhLEVBQUUsUUFBUSxDQUFDO1lBQ2pELFNBQVMsRUFBRSxtQkFBbUI7WUFDOUIsSUFBSSxFQUFFLFNBQVM7WUFDZixPQUFPLEVBQUUsSUFBSTtTQUNkO0tBQ0YsQ0FBQztBQUNKLENBQUMsQ0FBQztBQUVGLE1BQU0saUJBQWlCLEdBQUcsQ0FBQyxhQUFxQixFQUFjLEVBQUU7SUFDOUQsTUFBTSxHQUFHLEdBQUcsT0FBTyxDQUFDLEdBQUcsRUFBRSxDQUFDO0lBQzFCLE9BQU87UUFDTCxJQUFJLEVBQUUsSUFBSSxDQUFDLElBQUksQ0FBQyxhQUFhLEVBQUUsVUFBVSxDQUFDO1FBQzFDLFdBQVcsRUFBRSxJQUFJLENBQUMsSUFBSSxDQUFDLEdBQUcsRUFBRSxTQUFTLEVBQUUsV0FBVyxDQUFDO1FBQ25ELEtBQUssRUFBRSxJQUFJO1FBQ1gsYUFBYSxFQUFFLElBQUksQ0FBQyxJQUFJLENBQUMsYUFBYSxFQUFFLFVBQVUsQ0FBQztRQUNuRCxJQUFJLEVBQUUsU0FBUztRQUNmLE9BQU8sRUFBRSxJQUFJO0tBQ2QsQ0FBQztBQUNKLENBQUMsQ0FBQztBQUVGLE1BQU0sQ0FBQyxPQUFPLFVBQVUsVUFBVSxDQUNoQyxhQUFxQjtJQUVyQixPQUFPLENBQUMsS0FBYyxFQUFFLEVBQUU7UUFDeEIsTUFBTSxNQUFNLEdBQUcsU0FBUyxDQUFDLENBQUMsS0FBSyxFQUFFLEtBQUssQ0FBQyxDQUFDLENBQUM7UUFFekMsTUFBTSxDQUFDLEtBQUssQ0FBQyxxQ0FBcUMsRUFBRSxFQUFFLEtBQUssRUFBRSxDQUFDLENBQUM7UUFFL0QsTUFBTSxFQUFFLEdBQUcsRUFBRSxJQUFJLEVBQUUsU0FBUyxFQUFFLEdBQUcsYUFBYSxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUU1RCxNQUFNLG9CQUFvQixHQUFHLFNBQVMsQ0FDcEMsRUFBRSxHQUFHLEVBQUUsU0FBUyxFQUFFLEVBQ2xCLGFBQWEsRUFDYixDQUFDLENBQUMsSUFBSSxDQUNQLENBQUM7UUFFRixNQUFNLE9BQU8sR0FBaUI7WUFDNUI7Z0JBQ0UsSUFBSSxFQUFFLHFCQUFxQjthQUM1QjtZQUNEO2dCQUNFLElBQUksRUFBRSw0QkFBNEI7YUFDbkM7WUFDRCxpQkFBaUIsQ0FBQyxhQUFhLENBQUM7WUFDaEMsR0FBRyxvQkFBb0IsQ0FBQyxjQUFjLENBQUM7U0FDeEMsQ0FBQztRQUVGLElBQUksSUFBSSxFQUFFLENBQUM7WUFDVCxPQUFPLENBQUMsT0FBTyxDQUNiO2dCQUNFLElBQUksRUFBRSxtQkFBbUI7YUFDMUIsRUFDRDtnQkFDRSxJQUFJLEVBQUUsSUFBSSxDQUFDLGdCQUFnQjtvQkFDekIsQ0FBQyxDQUFDLDJCQUEyQjtvQkFDN0IsQ0FBQyxDQUFDLHFCQUFxQjthQUMxQixDQUNGLENBQUM7WUFDRixPQUFPLENBQUMsSUFBSSxDQUFDLEdBQUcsb0JBQW9CLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQztRQUNoRCxDQUFDO1FBRUQsT0FBTyxPQUFPLENBQUM7SUFDakIsQ0FBQyxDQUFDO0FBQ0osQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgQWN0aW9uVHlwZSwgRHluYW1pY0FjdGlvbnNGdW5jdGlvbiB9IGZyb20gXCJub2RlLXBsb3BcIjtcblxuaW1wb3J0IHsgZ2V0TG9nZ2VyIH0gZnJvbSBcIkBsb2d0YXBlL2xvZ3RhcGVcIjtcbmltcG9ydCBwYXRoIGZyb20gXCJub2RlOnBhdGhcIjtcblxuaW1wb3J0IHsgZm9ybWF0VGVycmFmb3JtQ29kZSB9IGZyb20gXCIuLi8uLi8uLi90ZXJyYWZvcm0vZm10LmpzXCI7XG5pbXBvcnQgeyB0ZXJyYWZvcm1TdGF0ZUtleSB9IGZyb20gXCIuLi8uLi9oZWxwZXJzL3RlcnJhZm9ybS1zdGF0ZS1rZXkuanNcIjtcbmltcG9ydCB7IFBheWxvYWQgfSBmcm9tIFwiLi9wcm9tcHRzLmpzXCI7XG5pbXBvcnQgeyBwYXlsb2FkU2NoZW1hIH0gZnJvbSBcIi4vcHJvbXB0cy5qc1wiO1xuXG5jb25zdCBhZGRNb2R1bGUgPSAoXG4gIGNvbnRleHQ6IFBpY2s8UGF5bG9hZCwgXCJlbnZcIiB8IFwid29ya3NwYWNlXCI+LFxuICB0ZW1wbGF0ZXNQYXRoOiBzdHJpbmcsXG4gIGluaXQgPSBmYWxzZSxcbikgPT4ge1xuICBjb25zdCB7IGVudiB9ID0gY29udGV4dDtcbiAgY29uc3QgY2xvdWRBY2NvdW50c0J5Q3NwID0gT2JqZWN0Lmdyb3VwQnkoXG4gICAgZW52LmNsb3VkQWNjb3VudHMsXG4gICAgKGFjY291bnQpID0+IGFjY291bnQuY3NwLFxuICApO1xuICBjb25zdCBpbmNsdWRlc1Byb2RJTyA9IGVudi5jbG91ZEFjY291bnRzLnNvbWUoXG4gICAgKGFjY291bnQpID0+IGFjY291bnQuZGlzcGxheU5hbWUgPT09IFwiUFJPRC1JT1wiLFxuICApO1xuICBjb25zdCBjd2QgPSBwcm9jZXNzLmN3ZCgpO1xuICByZXR1cm4gKG5hbWU6IHN0cmluZykgPT4gW1xuICAgIHtcbiAgICAgIGJhc2U6IHRlbXBsYXRlc1BhdGgsXG4gICAgICBkYXRhOiB7IGNsb3VkQWNjb3VudHNCeUNzcCwgaW5jbHVkZXNQcm9kSU8sIGluaXQ6IGluaXQgfHwgdW5kZWZpbmVkIH0sXG4gICAgICBkZXN0aW5hdGlvbjogcGF0aC5qb2luKGN3ZCwgXCJpbmZyYVwiKSxcbiAgICAgIGZvcmNlOiB0cnVlLFxuICAgICAgdGVtcGxhdGVGaWxlczogcGF0aC5qb2luKHRlbXBsYXRlc1BhdGgsIG5hbWUpLFxuICAgICAgdHJhbnNmb3JtOiBmb3JtYXRUZXJyYWZvcm1Db2RlLFxuICAgICAgdHlwZTogXCJhZGRNYW55XCIsXG4gICAgICB2ZXJib3NlOiB0cnVlLFxuICAgIH0sXG4gICAge1xuICAgICAgYmFzZTogcGF0aC5qb2luKHRlbXBsYXRlc1BhdGgsIFwic2hhcmVkXCIpLFxuICAgICAgZGF0YToge1xuICAgICAgICBjbG91ZEFjY291bnRzQnlDc3AsXG4gICAgICAgIGluaXQ6IGluaXQgfHwgdW5kZWZpbmVkLFxuICAgICAgICB0ZXJyYWZvcm1CYWNrZW5kS2V5OiB0ZXJyYWZvcm1TdGF0ZUtleShjb250ZXh0LCBuYW1lKSxcbiAgICAgIH0sXG4gICAgICBkZXN0aW5hdGlvbjogcGF0aC5qb2luKGN3ZCwgXCJpbmZyYVwiLCBuYW1lLCBcInt7ZW52Lm5hbWV9fVwiKSxcbiAgICAgIGZvcmNlOiB0cnVlLFxuICAgICAgdGVtcGxhdGVGaWxlczogcGF0aC5qb2luKHRlbXBsYXRlc1BhdGgsIFwic2hhcmVkXCIpLFxuICAgICAgdHJhbnNmb3JtOiBmb3JtYXRUZXJyYWZvcm1Db2RlLFxuICAgICAgdHlwZTogXCJhZGRNYW55XCIsXG4gICAgICB2ZXJib3NlOiB0cnVlLFxuICAgIH0sXG4gIF07XG59O1xuXG5jb25zdCBhZGRXb3JrZmxvd01vZHVsZSA9ICh0ZW1wbGF0ZXNQYXRoOiBzdHJpbmcpOiBBY3Rpb25UeXBlID0+IHtcbiAgY29uc3QgY3dkID0gcHJvY2Vzcy5jd2QoKTtcbiAgcmV0dXJuIHtcbiAgICBiYXNlOiBwYXRoLmpvaW4odGVtcGxhdGVzUGF0aCwgXCJ3b3JrZmxvd1wiKSxcbiAgICBkZXN0aW5hdGlvbjogcGF0aC5qb2luKGN3ZCwgXCIuZ2l0aHViXCIsIFwid29ya2Zsb3dzXCIpLFxuICAgIGZvcmNlOiB0cnVlLFxuICAgIHRlbXBsYXRlRmlsZXM6IHBhdGguam9pbih0ZW1wbGF0ZXNQYXRoLCBcIndvcmtmbG93XCIpLFxuICAgIHR5cGU6IFwiYWRkTWFueVwiLFxuICAgIHZlcmJvc2U6IHRydWUsXG4gIH07XG59O1xuXG5leHBvcnQgZGVmYXVsdCBmdW5jdGlvbiBnZXRBY3Rpb25zKFxuICB0ZW1wbGF0ZXNQYXRoOiBzdHJpbmcsXG4pOiBEeW5hbWljQWN0aW9uc0Z1bmN0aW9uIHtcbiAgcmV0dXJuIChpbnB1dDogdW5rbm93bikgPT4ge1xuICAgIGNvbnN0IGxvZ2dlciA9IGdldExvZ2dlcihbXCJnZW5cIiwgXCJlbnZcIl0pO1xuXG4gICAgbG9nZ2VyLmRlYnVnKFwiZW52aXJvbm1lbnQgZ2VuZXJhdG9yIGlucHV0IHtpbnB1dH1cIiwgeyBpbnB1dCB9KTtcblxuICAgIGNvbnN0IHsgZW52LCBpbml0LCB3b3Jrc3BhY2UgfSA9IHBheWxvYWRTY2hlbWEucGFyc2UoaW5wdXQpO1xuXG4gICAgY29uc3QgYWRkRW52aXJvbm1lbnRNb2R1bGUgPSBhZGRNb2R1bGUoXG4gICAgICB7IGVudiwgd29ya3NwYWNlIH0sXG4gICAgICB0ZW1wbGF0ZXNQYXRoLFxuICAgICAgISFpbml0LFxuICAgICk7XG5cbiAgICBjb25zdCBhY3Rpb25zOiBBY3Rpb25UeXBlW10gPSBbXG4gICAgICB7XG4gICAgICAgIHR5cGU6IFwiZ2V0VGVycmFmb3JtQmFja2VuZFwiLFxuICAgICAgfSxcbiAgICAgIHtcbiAgICAgICAgdHlwZTogXCJzeW5jUmVwb3NpdG9yeUVudmlyb25tZW50c1wiLFxuICAgICAgfSxcbiAgICAgIGFkZFdvcmtmbG93TW9kdWxlKHRlbXBsYXRlc1BhdGgpLFxuICAgICAgLi4uYWRkRW52aXJvbm1lbnRNb2R1bGUoXCJib290c3RyYXBwZXJcIiksXG4gICAgXTtcblxuICAgIGlmIChpbml0KSB7XG4gICAgICBhY3Rpb25zLnVuc2hpZnQoXG4gICAgICAgIHtcbiAgICAgICAgICB0eXBlOiBcImluaXRDbG91ZEFjY291bnRzXCIsXG4gICAgICAgIH0sXG4gICAgICAgIHtcbiAgICAgICAgICB0eXBlOiBpbml0LnRlcnJhZm9ybUJhY2tlbmRcbiAgICAgICAgICAgID8gXCJwcm92aXNpb25UZXJyYWZvcm1CYWNrZW5kXCJcbiAgICAgICAgICAgIDogXCJnZXRUZXJyYWZvcm1CYWNrZW5kXCIsXG4gICAgICAgIH0sXG4gICAgICApO1xuICAgICAgYWN0aW9ucy5wdXNoKC4uLmFkZEVudmlyb25tZW50TW9kdWxlKFwiY29yZVwiKSk7XG4gICAgfVxuXG4gICAgcmV0dXJuIGFjdGlvbnM7XG4gIH07XG59XG4iXX0=

package/dist/adapters/plop/generators/environment/index.d.ts

@@ -2,7 +2,7 @@ import { type NodePlopAPI } from "node-plop";
 import { CloudAccountRepository, CloudAccountService } from "../../../../domain/cloud-account.js";
 import { GitHubRepo } from "../../../../domain/github-repo.js";
 import { type GitHubService } from "../../../../domain/github.js";
-import { Payload, payloadSchema } from "./prompts.js";
+import { InitialAnswers, Payload, payloadSchema } from "./prompts.js";
 export declare const PLOP_ENVIRONMENT_GENERATOR_NAME = "DX_DeploymentEnvironment";
-export { Payload, payloadSchema };
-export default function (plop: NodePlopAPI, templatesPath: string, cloudAccountRepository: CloudAccountRepository, cloudAccountService: CloudAccountService, gitHubService: GitHubService, github?: GitHubRepo): void;
+export { type InitialAnswers, Payload, payloadSchema };
+export default function (plop: NodePlopAPI, templatesPath: string, cloudAccountRepository: CloudAccountRepository, cloudAccountService: CloudAccountService, gitHubService: GitHubService, github?: GitHubRepo, initialAnswers?: InitialAnswers): void;

package/dist/adapters/plop/generators/environment/index.js

@@ -1,15 +1,16 @@
 import setGetTerraformBackend from "../../actions/get-terraform-backend.js";
 import setInitCloudAccountsAction from "../../actions/init-cloud-accounts.js";
 import setProvisionTerraformBackendAction from "../../actions/provision-terraform-backend.js";
+import setSyncRepositoryEnvironmentsAction from "../../actions/sync-repository-environments.js";
 import setEnvShortHelper from "../../helpers/env-short.js";
 import setEqHelper from "../../helpers/eq.js";
 import setResourcePrefixHelper from "../../helpers/resource-prefix.js";
 import setTerraformStateKeyHelper from "../../helpers/terraform-state-key.js";
 import getActions from "./actions.js";
-import getPrompts, { payloadSchema } from "./prompts.js";
+import getPrompts, { payloadSchema, } from "./prompts.js";
 export const PLOP_ENVIRONMENT_GENERATOR_NAME = "DX_DeploymentEnvironment";
 export { payloadSchema };
-export default function (plop, templatesPath, cloudAccountRepository, cloudAccountService, gitHubService, github) {
+export default function (plop, templatesPath, cloudAccountRepository, cloudAccountService, gitHubService, github, initialAnswers = {}) {
     setEnvShortHelper(plop);
     setResourcePrefixHelper(plop);
     setEqHelper(plop);
@@ -17,6 +18,7 @@ export default function (plop, templatesPath, cloudAccountRepository, cloudAccou
     setGetTerraformBackend(plop, cloudAccountService);
     setProvisionTerraformBackendAction(plop, cloudAccountService);
     setInitCloudAccountsAction(plop, cloudAccountService, gitHubService);
+    setSyncRepositoryEnvironmentsAction(plop);
     plop.setGenerator(PLOP_ENVIRONMENT_GENERATOR_NAME, {
         actions: getActions(templatesPath),
         description: "Generate a new deployment environment",
@@ -24,7 +26,8 @@ export default function (plop, templatesPath, cloudAccountRepository, cloudAccou
             cloudAccountRepository,
             cloudAccountService,
             github,
+            initialAnswers,
         }),
     });
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/adapters/plop/generators/environment/prompts.d.ts

@@ -64,10 +64,48 @@ export declare const payloadSchema: z.ZodObject<{
     }, z.core.$strip>;
 }, z.core.$strip>;
 export type Payload = z.infer<typeof payloadSchema>;
+/**
+ * Prefilled answers supplied up-front by the caller (e.g. CLI flags), used to
+ * skip the matching prompts. Identifies cloud accounts by id and locations by
+ * account id, since the full domain objects aren't available before resolving.
+ */
+export declare const initialAnswersSchema: z.ZodObject<{
+    env: z.ZodOptional<z.ZodObject<{
+        cloudAccountIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        locations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+            italynorth: "italynorth";
+            westeurope: "westeurope";
+        }>>>;
+        name: z.ZodOptional<z.ZodEnum<{
+            dev: "dev";
+            prod: "prod";
+            uat: "uat";
+        }>>;
+        prefix: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    init: z.ZodOptional<z.ZodObject<{
+        confirm: z.ZodOptional<z.ZodBoolean>;
+        runnerAppCredentials: z.ZodOptional<z.ZodObject<{
+            clientId: z.ZodOptional<z.ZodString>;
+            id: z.ZodOptional<z.ZodString>;
+            installationId: z.ZodOptional<z.ZodString>;
+            key: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    tags: z.ZodOptional<z.ZodObject<{
+        BusinessUnit: z.ZodOptional<z.ZodString>;
+        ManagementTeam: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    workspace: z.ZodOptional<z.ZodObject<{
+        domain: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type InitialAnswers = z.infer<typeof initialAnswersSchema>;
 export type PromptsDependencies = {
     cloudAccountRepository: CloudAccountRepository;
     cloudAccountService: CloudAccountService;
     github?: GitHubRepo;
+    initialAnswers?: InitialAnswers;
 };
 declare const prompts: (deps: PromptsDependencies) => DynamicPromptsFunction;
 export declare const getCloudAccountChoices: (cloudAccounts: CloudAccount[]) => InquirerChoice<CloudAccount>[];