@pagopa/dx-cli 0.15.5 → 0.16.1

package/bin/index.js

@@ -23,4 +23,4 @@ await configure({
   },
 });
 
-runCli(packageJson.version);
+runCli(packageJson.version).catch((error) => console.error(error.message));

package/dist/adapters/commander/commands/init.js

@@ -1,36 +1,20 @@
+import { getLogger } from "@logtape/logtape";
 import chalk from "chalk";
 import { Command } from "commander";
-import { $ } from "execa";
-import { errAsync, okAsync, ResultAsync } from "neverthrow";
+import { $, ExecaError } from "execa";
+import { okAsync, ResultAsync } from "neverthrow";
 import * as path from "node:path";
 import { oraPromise } from "ora";
-import { Repository, RepositoryNotFoundError, } from "../../../domain/github.js";
+import { z } from "zod";
+import { Repository, } from "../../../domain/github.js";
 import { tf$ } from "../../execa/terraform.js";
-import { payloadSchema as answersSchema, PLOP_MONOREPO_GENERATOR_NAME, } from "../../plop/generators/monorepo/index.js";
-import { setMonorepoGenerator } from "../../plop/index.js";
-import { getGenerator, getPrompts, initPlop } from "../../plop/index.js";
-import { decode } from "../../zod/index.js";
+import { getPlopInstance, runDeploymentEnvironmentGenerator, runMonorepoGenerator, } from "../../plop/index.js";
 import { exitWithError } from "../index.js";
 const withSpinner = (text, successText, failText, promise) => ResultAsync.fromPromise(oraPromise(promise, {
     failText,
     successText,
     text,
-}), (cause) => {
-    console.error(`Something went wrong: ${JSON.stringify(cause, null, 2)}`);
-    return new Error(failText, { cause });
-});
-// TODO: Check Cloud Environment exists
-// TODO: Check CSP CLI is installed
-// TODO: Check user has permissions to handle Terraform state
-const validateAnswers = (githubService) => (answers) => ResultAsync.fromPromise(githubService.getRepository(answers.repoOwner, answers.repoName), (error) => error)
-    .andThen(({ fullName }) => errAsync(new Error(`Repository ${fullName} already exists.`)))
-    .orElse((error) => error instanceof RepositoryNotFoundError
-    ? // If repository is not found, it's safe to proceed
-        okAsync(answers)
-    : // Otherwise, propagate the error
-        errAsync(error))
-    .map(() => answers);
-const runGeneratorActions = (generator) => (answers) => withSpinner("Creating workspace files...", "Workspace files created successfully!", "Failed to create workspace files.", generator.runActions(answers)).map(() => answers);
+}), (cause) => new Error(failText, { cause }));
 const displaySummary = (initResult) => {
     const { pr, repository } = initResult;
     console.log(chalk.green.bold("\nWorkspace created successfully!"));
@@ -51,21 +35,41 @@ const displaySummary = (initResult) => {
         console.log(`Please, manually create a Pull Request in the GitHub repository to review the scaffolded code.\n`);
     }
 };
-const checkTerraformCliIsInstalled = (text, successText, failText) => withSpinner(text, successText, failText, tf$ `terraform -version`);
-const checkPreconditions = () => checkTerraformCliIsInstalled("Checking Terraform CLI is installed...", "Terraform CLI is installed!", "Terraform CLI is not installed.");
+const checkTerraformCliIsInstalled = () => withSpinner("Checking Terraform installation...", "Terraform is installed!", "Please install terraform CLI before running this command. If you use tfenv, run: tfenv install latest && tfenv use latest", tf$ `terraform -version`);
+const azureAccountSchema = z.object({
+    user: z.object({
+        name: z.string().min(1),
+    }),
+});
+const ensureAzLogin = async () => {
+    const { stdout } = await tf$ `az account show`;
+    await tf$ `az group list`;
+    const parsed = JSON.parse(stdout);
+    const { user } = azureAccountSchema.parse(parsed);
+    return user.name;
+};
+const checkAzLogin = () => withSpinner("Check Azure login status...", (userName) => `You are logged in to Azure (${userName})`, "Please log in to Azure CLI using `az login` before running this command.", ensureAzLogin());
+const checkPreconditions = () => checkTerraformCliIsInstalled().andThen(() => checkAzLogin());
 const createRemoteRepository = ({ repoName, repoOwner, }) => {
-    const cwd = path.resolve(repoName, "infra", "repository");
+    const logger = getLogger(["dx-cli", "init"]);
+    const repo$ = tf$({ cwd: path.resolve("infra", "repository") });
     const applyTerraform = async () => {
-        await tf$({ cwd }) `terraform init`;
-        await tf$({ cwd }) `terraform apply -auto-approve`;
+        try {
+            await repo$ `terraform init`;
+            await repo$ `terraform apply -auto-approve`;
+        }
+        catch (error) {
+            if (error instanceof ExecaError) {
+                logger.error(error.shortMessage);
+            }
+            throw error;
+        }
     };
     return withSpinner("Creating GitHub repository...", "GitHub repository created successfully!", "Failed to create GitHub repository.", applyTerraform()).map(() => new Repository(repoName, repoOwner));
 };
 const initializeGitRepository = (repository) => {
-    const cwd = path.resolve(repository.name);
     const branchName = "features/scaffold-workspace";
     const git$ = $({
-        cwd,
         shell: true,
     });
     const pushToOrigin = async () => {
@@ -73,7 +77,7 @@ const initializeGitRepository = (repository) => {
         await git$ `git add README.md`;
         await git$ `git commit --no-gpg-sign -m "Create README.md"`;
         await git$ `git branch -M main`;
-        await git$ `git remote add origin ${repository.ssh}`;
+        await git$ `git remote add origin ${repository.origin}`;
         await git$ `git push -u origin main`;
         await git$ `git switch -c ${branchName}`;
         await git$ `git add .`;
@@ -82,16 +86,12 @@ const initializeGitRepository = (repository) => {
     };
     return withSpinner("Pushing code to GitHub...", "Code pushed to GitHub successfully!", "Failed to push code to GitHub.", pushToOrigin()).map(() => ({ branchName, repository }));
 };
-const handleNewGitHubRepository = (githubService) => (answers) => createRemoteRepository(answers)
+const handleNewGitHubRepository = (githubService) => (payload) => createRemoteRepository(payload)
     .andThen(initializeGitRepository)
     .andThen((localWorkspace) => createPullRequest(githubService)(localWorkspace).map((pr) => ({
     pr,
     repository: localWorkspace.repository,
 })));
-const makeInitResult = (answers, { pr, repository }) => ({
-    pr,
-    repository,
-});
 const createPullRequest = (githubService) => ({ branchName, repository, }) => withSpinner("Creating Pull Request...", "Pull Request created successfully!", "Failed to create Pull Request.", githubService.createPullRequest({
     base: "main",
     body: "This PR contains the scaffolded monorepo structure.",
@@ -102,25 +102,29 @@ const createPullRequest = (githubService) => ({ branchName, repository, }) => wi
 }))
     // If PR creation fails, don't block the workflow
     .orElse(() => okAsync(undefined));
+const handleGeneratorError = (err) => {
+    const logger = getLogger(["dx-cli", "init"]);
+    if (err instanceof Error) {
+        logger.error(err.message);
+    }
+    return new Error("Failed to run the generator");
+};
 export const makeInitCommand = ({ gitHubService, }) => new Command()
     .name("init")
-    .description("Command to initialize resources (like projects, subscriptions, ...)")
-    .addCommand(new Command("project")
-    .description("Initialize a new monorepo project")
+    .description("Initialize a new DX workspace")
     .action(async function () {
     await checkPreconditions()
-        .andThen(initPlop)
-        .andTee(setMonorepoGenerator)
-        .andThen((plop) => getGenerator(plop)(PLOP_MONOREPO_GENERATOR_NAME))
-        .andThen((generator) => 
-    // Ask the user the questions defined in the plop generator
-    getPrompts(generator)
-        // Decode the answers to match the Answers schema
-        .andThen(decode(answersSchema))
-        // Validate the answers (like checking permissions, checking GitHub user or org existence, etc.)
-        .andThen(validateAnswers(gitHubService))
-        // Run the generator with the provided answers (this will create the files locally)
-        .andThen(runGeneratorActions(generator)))
-        .andThen((answers) => handleNewGitHubRepository(gitHubService)(answers).map((repoPr) => makeInitResult(answers, repoPr)))
+        .andTee(() => {
+        console.log(chalk.blue.bold("\nWorkspace Info"));
+    })
+        .andThen(() => ResultAsync.fromPromise(getPlopInstance(), () => new Error("Failed to initialize plop")))
+        .andThen((plop) => ResultAsync.fromPromise(runMonorepoGenerator(plop, gitHubService), handleGeneratorError)
+        .andTee((payload) => {
+        process.chdir(payload.repoName);
+        console.log(chalk.blue.bold("\nCloud Environment"));
+    })
+        .andThen((payload) => ResultAsync.fromPromise(runDeploymentEnvironmentGenerator(plop), handleGeneratorError).map(() => payload)))
+        .andTee(() => console.log()) // Print a new line before the gh repo creation logs
+        .andThen((payload) => handleNewGitHubRepository(gitHubService)(payload))
         .match(displaySummary, exitWithError(this));
-}));
+});

package/dist/adapters/node/__tests__/data.d.ts

@@ -9,7 +9,7 @@ export declare const makeMockPackageJson: (overrides?: Partial<PackageJson>) =>
         typescript: string;
     };
     name: string;
-    scripts: Map<string & import("zod/v4").$brand<"ScriptName">, string> | {
+    scripts: Map<string & import("zod").$brand<"ScriptName">, string> | {
         build: string;
         "code-review": string;
     };

package/dist/adapters/octokit/index.d.ts

@@ -19,6 +19,7 @@ export declare class OctokitGitHubService implements GitHubService {
     }): Promise<PullRequest>;
     getRepository(owner: string, name: string): Promise<Repository>;
 }
+export declare const getGitHubPAT: () => Promise<string | undefined>;
 export declare const fetchLatestTag: ({ client, owner, repo }: GitHubReleaseParam) => ResultAsync<import("semver").SemVer | null, Error>;
 export declare const fetchLatestRelease: ({ client, owner, repo, }: GitHubReleaseParam) => ResultAsync<import("semver").SemVer | null, Error>;
 export {};

package/dist/adapters/octokit/index.js

@@ -1,3 +1,4 @@
+import { $ } from "execa";
 import { ResultAsync } from "neverthrow";
 import { RequestError } from "octokit";
 import semverParse from "semver/functions/parse.js";
@@ -44,6 +45,21 @@ export class OctokitGitHubService {
         }
     }
 }
+// Follow the same order of precedence of gh cli
+// https://cli.github.com/manual/gh_help_environment
+export const getGitHubPAT = async () => {
+    if (process.env.GH_TOKEN) {
+        return process.env.GH_TOKEN;
+    }
+    if (process.env.GITHUB_TOKEN) {
+        return process.env.GITHUB_TOKEN;
+    }
+    const result = await $({ reject: false }) `gh auth token`;
+    if (!result.failed && result.exitCode === 0) {
+        return result.stdout.trim();
+    }
+    return undefined;
+};
 export const fetchLatestTag = ({ client, owner, repo }) => ResultAsync.fromPromise(
 // Get repository tags
 client.request("GET /repos/{owner}/{repo}/tags", {

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

@@ -4,11 +4,13 @@ import { formatTerraformCode } from "../../../terraform/fmt.js";
 import { payloadSchema } from "./prompts.js";
 const addModule = (env, templatesPath) => {
     const cloudAccountsByCsp = Object.groupBy(env.cloudAccounts, (account) => account.csp);
+    const includesProdIO = env.cloudAccounts.some((account) => account.displayName === "PROD-IO");
+    const cwd = process.cwd();
     return (name, terraformBackendKey) => [
         {
             base: templatesPath,
-            data: { cloudAccountsByCsp },
-            destination: "infra",
+            data: { cloudAccountsByCsp, includesProdIO },
+            destination: path.join(cwd, "infra"),
             force: true,
             templateFiles: path.join(templatesPath, name),
             transform: formatTerraformCode,
@@ -18,7 +20,7 @@ const addModule = (env, templatesPath) => {
         {
             base: path.join(templatesPath, "shared"),
             data: { cloudAccountsByCsp, terraformBackendKey },
-            destination: `infra/${name}/{{env.name}}`,
+            destination: path.join(cwd, "infra", name, "{{env.name}}"),
             force: true,
             templateFiles: path.join(templatesPath, "shared"),
             transform: formatTerraformCode,

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

@@ -1,3 +1,6 @@
 import { type NodePlopAPI } from "node-plop";
 import { CloudAccountRepository, CloudAccountService } from "../../../../domain/cloud-account.js";
+import { 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): void;

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

@@ -2,16 +2,20 @@ 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 setEnvShortHelper from "../../helpers/env-short.js";
+import setEqHelper from "../../helpers/eq.js";
 import setResourcePrefixHelper from "../../helpers/resource-prefix.js";
 import getActions from "./actions.js";
-import getPrompts 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) {
     setEnvShortHelper(plop);
     setResourcePrefixHelper(plop);
+    setEqHelper(plop);
     setGetTerraformBackend(plop, cloudAccountService);
     setProvisionTerraformBackendAction(plop, cloudAccountService);
     setInitCloudAccountsAction(plop, cloudAccountService);
-    plop.setGenerator("DX_DeploymentEnvironment", {
+    plop.setGenerator(PLOP_ENVIRONMENT_GENERATOR_NAME, {
         actions: getActions(templatesPath),
         description: "Generate a new deployment environment",
         prompts: getPrompts({ cloudAccountRepository, cloudAccountService }),

package/dist/adapters/plop/generators/monorepo/prompts.js

@@ -13,18 +13,18 @@ const validatePrompt = (schema) => (input) => {
 };
 const getPrompts = () => [
     {
-        message: "Repository name",
+        message: "Name",
         name: "repoName",
         validate: validatePrompt(payloadSchema.shape.repoName),
     },
     {
         default: payloadSchema.shape.repoOwner.def.defaultValue,
-        message: "GitHub repository owner (User or Organization)",
+        message: "GitHub Organization",
         name: "repoOwner",
         validate: validatePrompt(payloadSchema.shape.repoOwner),
     },
     {
-        message: "Repository description",
+        message: "Description",
         name: "repoDescription",
     },
 ];

package/dist/adapters/plop/helpers/eq.d.ts

@@ -0,0 +1,3 @@
+import { type NodePlopAPI } from "node-plop";
+declare const _default: (plop: NodePlopAPI) => void;
+export default _default;

package/dist/adapters/plop/helpers/eq.js

@@ -0,0 +1,3 @@
+export default (plop) => {
+    plop.setHelper("eq", (a, b) => a === b);
+};

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

@@ -1,8 +1,8 @@
 import type { NodePlopAPI } from "plop";
-import { Result, ResultAsync } from "neverthrow";
-import { PlopGenerator } from "node-plop";
-export declare const initPlop: () => ResultAsync<NodePlopAPI, Error>;
-export declare const getGenerator: (plopAPI: NodePlopAPI) => (name: string) => Result<PlopGenerator, Error>;
-export declare const getPrompts: (generator: PlopGenerator) => ResultAsync<any, Error>;
+import { GitHubService } from "../../domain/github.js";
+import { Payload as MonorepoPayload } from "../plop/generators/monorepo/index.js";
 export declare const setMonorepoGenerator: (plop: NodePlopAPI) => void;
+export declare const getPlopInstance: () => Promise<NodePlopAPI>;
+export declare const runMonorepoGenerator: (plop: NodePlopAPI, githubService: GitHubService) => Promise<MonorepoPayload>;
+export declare const runDeploymentEnvironmentGenerator: (plop: NodePlopAPI) => Promise<void>;
 export declare const setDeploymentEnvironmentGenerator: (plop: NodePlopAPI) => void;

package/dist/adapters/plop/index.js

@@ -1,22 +1,69 @@
-import { DefaultAzureCredential } from "@azure/identity";
-import { Result, ResultAsync } from "neverthrow";
+import { AzureCliCredential } from "@azure/identity";
+import { getLogger } from "@logtape/logtape";
 import nodePlop from "node-plop";
 import path from "node:path";
 import { Octokit } from "octokit";
+import { oraPromise } from "ora";
+import { RepositoryNotFoundError } from "../../domain/github.js";
 import { AzureSubscriptionRepository } from "../azure/cloud-account-repository.js";
 import { AzureCloudAccountService } from "../azure/cloud-account-service.js";
-import createDeploymentEnvironmentGenerator from "../plop/generators/environment/index.js";
-import createMonorepoGenerator from "../plop/generators/monorepo/index.js";
-export const initPlop = () => ResultAsync.fromPromise(nodePlop(), () => new Error("Failed to initialize plop"));
-export const getGenerator = (plopAPI) => Result.fromThrowable(plopAPI.getGenerator, () => new Error("Generator not found"));
-export const getPrompts = (generator) => ResultAsync.fromPromise(generator.runPrompts(), (cause) => new Error("Failed to run the generator prompts", { cause }));
+import createDeploymentEnvironmentGenerator, { PLOP_ENVIRONMENT_GENERATOR_NAME, } from "../plop/generators/environment/index.js";
+import createMonorepoGenerator, { payloadSchema as monorepoPayloadSchema, PLOP_MONOREPO_GENERATOR_NAME, } from "../plop/generators/monorepo/index.js";
 export const setMonorepoGenerator = (plop) => {
     const octokit = new Octokit({ auth: process.env.GITHUB_TOKEN });
     const templatesPath = path.join(import.meta.dirname, "../../../templates/monorepo");
     createMonorepoGenerator(plop, templatesPath, octokit);
 };
+const validatePayload = async (payload, github) => {
+    try {
+        const repo = await github.getRepository(payload.repoOwner, payload.repoName);
+        throw new Error(`Repository ${repo.fullName} already exists.`);
+    }
+    catch (error) {
+        if (!(error instanceof RepositoryNotFoundError)) {
+            throw error;
+        }
+    }
+};
+export const getPlopInstance = async () => {
+    const plop = await nodePlop();
+    setMonorepoGenerator(plop);
+    setDeploymentEnvironmentGenerator(plop);
+    return plop;
+};
+const runActions = async (generator, payload) => {
+    const logger = getLogger(["dx-cli", "init"]);
+    const result = await generator.runActions(payload);
+    if (result.failures.length > 0) {
+        for (const failure of result.failures) {
+            logger.error(failure.message);
+        }
+        throw new Error("One or more actions failed during generation.");
+    }
+};
+export const runMonorepoGenerator = async (plop, githubService) => {
+    const generator = plop.getGenerator(PLOP_MONOREPO_GENERATOR_NAME);
+    const answers = await generator.runPrompts();
+    const payload = monorepoPayloadSchema.parse(answers);
+    await validatePayload(payload, githubService);
+    await oraPromise(runActions(generator, payload), {
+        failText: "Failed to create workspace files.",
+        successText: "Workspace files created successfully!",
+        text: "Creating workspace files...",
+    });
+    return payload;
+};
+export const runDeploymentEnvironmentGenerator = async (plop) => {
+    const generator = plop.getGenerator(PLOP_ENVIRONMENT_GENERATOR_NAME);
+    const payload = await generator.runPrompts();
+    await oraPromise(runActions(generator, payload), {
+        failText: "Failed to create deployment environment",
+        successText: "Environment created successfully!",
+        text: "Creating environment...",
+    });
+};
 export const setDeploymentEnvironmentGenerator = (plop) => {
-    const credential = new DefaultAzureCredential();
+    const credential = new AzureCliCredential();
     const cloudAccountRepository = new AzureSubscriptionRepository(credential);
     const cloudAccountService = new AzureCloudAccountService(credential);
     const templatesPath = path.join(import.meta.dirname, "../../../templates/environment");

package/dist/domain/github.d.ts

@@ -27,6 +27,7 @@ export declare class Repository {
     readonly name: string;
     readonly owner: string;
     get fullName(): string;
+    get origin(): string;
     get ssh(): string;
     get url(): string;
     constructor(name: string, owner: string);

package/dist/domain/github.js

@@ -10,6 +10,9 @@ export class Repository {
     get fullName() {
         return `${this.owner}/${this.name}`;
     }
+    get origin() {
+        return `https://github.com/${this.owner}/${this.name}.git`;
+    }
     get ssh() {
         return `git@github.com:${this.owner}/${this.name}.git`;
     }

package/dist/index.d.ts

@@ -1,2 +1,2 @@
 import "core-js/actual/set/index.js";
-export declare const runCli: (version: string) => void;
+export declare const runCli: (version: string) => Promise<void>;

package/dist/index.js

@@ -1,22 +1,25 @@
 import "core-js/actual/set/index.js";
+import * as assert from "node:assert/strict";
 import { Octokit } from "octokit";
 import codemodRegistry from "./adapters/codemods/index.js";
 import { makeCli } from "./adapters/commander/index.js";
 import { makeValidationReporter } from "./adapters/logtape/validation-reporter.js";
 import { makePackageJsonReader } from "./adapters/node/package-json.js";
 import { makeRepositoryReader } from "./adapters/node/repository.js";
-import { OctokitGitHubService } from "./adapters/octokit/index.js";
+import { getGitHubPAT, OctokitGitHubService, } from "./adapters/octokit/index.js";
 import { getConfig } from "./config.js";
 import { getInfo } from "./domain/info.js";
 import { applyCodemodById } from "./use-cases/apply-codemod.js";
 import { listCodemods } from "./use-cases/list-codemods.js";
-export const runCli = (version) => {
+export const runCli = async (version) => {
     // Creating the adapters
     const repositoryReader = makeRepositoryReader();
     const packageJsonReader = makePackageJsonReader();
     const validationReporter = makeValidationReporter();
+    const auth = await getGitHubPAT();
+    assert.ok(auth, "GitHub PAT is required. Please set the GH_TOKEN environment variable or login using GitHub CLI.");
     const octokit = new Octokit({
-        auth: process.env.GITHUB_TOKEN,
+        auth,
     });
     const gitHubService = new OctokitGitHubService(octokit);
     const deps = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pagopa/dx-cli",
-  "version": "0.15.5",
+  "version": "0.16.1",
   "type": "module",
   "description": "A CLI useful to manage DX tools.",
   "repository": {

package/templates/environment/bootstrapper/{{env.name}}/data.tf.hbs

@@ -11,3 +11,48 @@ data "azuread_group" "externals" {
   display_name = "{{resourcePrefix @root}}-adgroup-externals"
 }
 {{/with}}
+
+{{#with includesProdIO}}
+data "azurerm_subscription" "PROD_IO" {
+  provider = azurerm.PROD-IO
+}
+
+data "azurerm_resource_group" "common_itn_01" {
+  provider = azurerm.PROD-IO
+  name     = "io-p-itn-common-rg-01"
+}
+
+data "azurerm_resource_group" "common_weu" {
+  provider = azurerm.PROD-IO
+  name     = "io-p-rg-common"
+}
+
+data "azurerm_resource_group" "dashboards" {
+  provider = azurerm.PROD-IO
+  name     = "dashboards"
+}
+
+data "azurerm_container_app_environment" "runner" {
+  provider            = azurerm.PROD-IO
+  name                = "io-p-itn-github-runner-cae-01"
+  resource_group_name = "io-p-itn-github-runner-rg-01"
+}
+
+data "azurerm_api_management" "apim" {
+  provider            = azurerm.PROD-IO
+  name                = "io-p-itn-apim-01"
+  resource_group_name = data.azurerm_resource_group.common_itn_01.name
+}
+
+data "azurerm_key_vault" "common" {
+  provider            = azurerm.PROD-IO
+  name                = "io-p-kv-common"
+  resource_group_name = data.azurerm_resource_group.common_weu.name
+}
+
+data "azurerm_virtual_network" "common" {
+  provider            = azurerm.PROD-IO
+  name                = "io-p-itn-common-vnet-01"
+  resource_group_name = data.azurerm_resource_group.common_itn_01.name
+}
+{{/with}}

package/templates/environment/bootstrapper/{{env.name}}/main.tf.hbs

@@ -1,5 +1,52 @@
-{{#with cloudAccountsByCsp.azure}}
-{{#each this}}
+{{#each cloudAccountsByCsp.azure}}
+{{#if (eq displayName "PROD-IO")}}
+module "azure-{{displayName}}_bootstrap" {
+  source  = "pagopa-dx/azure-github-environment-bootstrap/azurerm"
+  version = "~> 3.0"
+
+  providers = {
+    azurerm = azurerm.{{displayName}}
+  }
+
+  environment = merge(local.environment, local.azure_accounts.{{displayName}})
+
+  subscription_id = data.azurerm_subscription.PROD_IO.id
+  tenant_id       = data.azurerm_subscription.PROD_IO.tenant_id
+
+  entraid_groups = {
+    admins_object_id    = data.azuread_group.admins.object_id
+    devs_object_id      = data.azuread_group.developers.object_id
+    externals_object_id = data.azuread_group.externals.object_id
+  }
+
+  terraform_storage_account = {
+    name                = "{{@root.terraform.backend.storageAccountName}}"
+    resource_group_name = "{{@root.terraform.backend.resourceGroupName}}"
+  }
+
+  repository = {
+    owner = "{{@root.github.owner}}"
+    name  = "{{@root.github.repo}}"
+  }
+
+  github_private_runner = {
+    container_app_environment_id       = data.azurerm_container_app_environment.runner.id
+    container_app_environment_location = data.azurerm_container_app_environment.runner.location
+    key_vault = {
+      name                = data.azurerm_key_vault.common.name
+      resource_group_name = data.azurerm_key_vault.common.resource_group_name
+    }
+  }
+
+  apim_id                            = data.azurerm_api_management.apim.id
+  pep_vnet_id                        = data.azurerm_virtual_network.common.id
+  private_dns_zone_resource_group_id = data.azurerm_resource_group.common_weu.id
+  nat_gateway_resource_group_id      = data.azurerm_resource_group.common_itn_01.id
+  opex_resource_group_id             = data.azurerm_resource_group.dashboards.id
+
+  tags = local.tags
+}
+{{else}}
 module "azure-{{displayName}}_core_values" {
   source  = "pagopa-dx/azure-core-values-exporter/azurerm"
   version = "~> 0.0"
@@ -64,7 +111,7 @@ module "azure-{{displayName}}_bootstrap" {
 
   tags = local.tags
 }
+{{/if}}
 {{/each}}
-{{/with}}