@pagopa/dx-cli 0.15.2 → 0.15.4

package/dist/adapters/plop/actions/semver.js

@@ -0,0 +1,27 @@
+import { errAsync, okAsync } from "neverthrow";
+/**
+ * Fetches the latest semantic version using the provided fetch function and writes
+ * a formatted version string into the given `answers` object under `answerKey`.
+ *
+ * @param fetchSemverFn - A zero-arg function that returns a `ResultAsync` resolving
+ *   to a `SemVer` (or `null`) or rejecting with an `Error`. Typically wraps an
+ *   Octokit call to fetch a release or tag and parse its semver.
+ * @param answers - Mutable answers object (plop prompts) where the resulting
+ *   formatted version will be stored.
+ * @param answerKey - Key name to assign the formatted version into `answers`.
+ * @param semverFormatFn - Optional formatter that converts the `SemVer` into
+ *   the desired string representation (defaults to `semver.toString()`).
+ * @returns A human-readable message indicating the fetched version. Throws an
+ *   `Error` if the fetch fails or yields an invalid version.
+ */
+export const fetchLatestSemver = async (fetchSemverFn, answers, answerKey, semverFormatFn = (semver) => semver.toString()) => {
+    const version = await fetchSemverFn()
+        .andThen((semver) => semver ? okAsync(semver) : errAsync(new Error("Invalid version found")))
+        .map(semverFormatFn);
+    if (version.isErr()) {
+        console.warn(`Could not fetch latest version`);
+        throw new Error("Could not fetch latest version", { cause: version.error });
+    }
+    answers[answerKey] = version.value;
+    return `Fetched latest version: ${answers[answerKey]}`;
+};

package/dist/adapters/plop/actions/setup-pnpm.d.ts

@@ -0,0 +1,2 @@
+import { type NodePlopAPI } from "node-plop";
+export default function (plop: NodePlopAPI): void;

package/dist/adapters/plop/actions/setup-pnpm.js

@@ -0,0 +1,26 @@
+import { $ } from "execa";
+import path from "node:path";
+import { payloadSchema } from "../generators/monorepo/prompts.js";
+export default function (plop) {
+    plop.setActionType("setupPnpm", async (data) => {
+        const payload = payloadSchema.parse(data);
+        const cwd = path.resolve(payload.repoName);
+        // If this generator is started by a npm script, it will inherit some
+        // config variables that will interfere with pnpm commands.
+        // We filter them out here.
+        const env = Object.fromEntries(Object.entries(process.env)
+            .filter(([key]) => !key.startsWith("npm_config_"))
+            // Disable corepack download prompt
+            .concat([["COREPACK_ENABLE_DOWNLOAD_PROMPT", "0"]]));
+        const pnpm$ = $({
+            cwd,
+            env,
+            extendEnv: false, // Don't include process.env variables
+        });
+        await pnpm$ `corepack use pnpm@latest`;
+        await pnpm$ `pnpm -w add -D turbo @changesets/cli @devcontainers/cli`;
+        await pnpm$ `pnpm changeset init`;
+        await pnpm$ `pnpm devcontainer templates apply -t ghcr.io/pagopa/devcontainer-templates/node:1`;
+        return "Monorepo bootstrapped";
+    });
+}

package/dist/adapters/plop/generators/environment/__tests__/actions.test.d.ts

@@ -0,0 +1,2 @@
+import { Payload } from "../prompts.js";
+export declare const getPayload: (includeInit?: boolean) => Payload;

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

@@ -0,0 +1,55 @@
+import { describe, expect, test } from "vitest";
+import getActions from "../actions.js";
+export const getPayload = (includeInit = false) => {
+    const cloudAccount = {
+        csp: "azure",
+        defaultLocation: "westeurope",
+        displayName: "Test-Account",
+        id: "test-subscription-id",
+    };
+    const payload = {
+        env: {
+            cloudAccounts: [cloudAccount],
+            name: "dev",
+            prefix: "dx",
+        },
+        github: {
+            owner: "pagopa",
+            repo: "dx",
+        },
+        tags: {},
+        workspace: {
+            domain: "mytest",
+        },
+    };
+    if (includeInit) {
+        payload.init = {
+            cloudAccountsToInitialize: [cloudAccount],
+            terraformBackend: {
+                cloudAccount,
+            },
+        };
+    }
+    return payload;
+};
+describe("actions", () => {
+    test.each([
+        {
+            payload: getPayload(true),
+        },
+        {
+            payload: getPayload(false),
+        },
+    ])("correct order of actions", ({ payload }) => {
+        const actionsOrder = ["getTerraformBackend", "addMany", "addMany"];
+        if (payload.init) {
+            actionsOrder.unshift("initCloudAccounts", "provisionTerraformBackend");
+            actionsOrder.push("addMany", "addMany");
+        }
+        const actions = getActions("/templates/path")(payload);
+        const actionTypes = actions
+            .filter((action) => typeof action === "object" && Object.hasOwn(action, "type"))
+            .map((action) => action.type);
+        expect(actionTypes).toEqual(actionsOrder);
+    });
+});

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

@@ -0,0 +1,2 @@
+import type { DynamicActionsFunction } from "node-plop";
+export default function getActions(templatesPath: string): DynamicActionsFunction;

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

@@ -0,0 +1,54 @@
+import { getLogger } from "@logtape/logtape";
+import * as path from "node:path";
+import { formatTerraformCode } from "../../../terraform/fmt.js";
+import { payloadSchema } from "./prompts.js";
+const addModule = (env, templatesPath) => {
+    const cloudAccountsByCsp = Object.groupBy(env.cloudAccounts, (account) => account.csp);
+    return (name, terraformBackendKey) => [
+        {
+            base: templatesPath,
+            data: { cloudAccountsByCsp },
+            destination: "infra",
+            force: true,
+            templateFiles: path.join(templatesPath, name),
+            transform: formatTerraformCode,
+            type: "addMany",
+            verbose: true,
+        },
+        {
+            base: path.join(templatesPath, "shared"),
+            data: { cloudAccountsByCsp, terraformBackendKey },
+            destination: `infra/${name}/{{env.name}}`,
+            force: true,
+            templateFiles: path.join(templatesPath, "shared"),
+            transform: formatTerraformCode,
+            type: "addMany",
+            verbose: true,
+        },
+    ];
+};
+export default function getActions(templatesPath) {
+    return (payload) => {
+        const logger = getLogger(["gen", "env"]);
+        logger.debug("payload {payload}", { payload });
+        const { env, github, init } = payloadSchema.parse(payload);
+        const addEnvironmentModule = addModule(env, templatesPath);
+        const actions = [
+            {
+                type: "getTerraformBackend",
+            },
+            ...addEnvironmentModule("bootstrapper", `${github.repo}.bootstrapper.${env.name}.tfstate`),
+        ];
+        if (init) {
+            actions.unshift({
+                type: "initCloudAccounts",
+            }, {
+                type: init.terraformBackend
+                    ? "provisionTerraformBackend"
+                    : "getTerraformBackend",
+            });
+            actions.push(...addEnvironmentModule("core", `${env.prefix}.core.${env.name}.tfstate`));
+        }
+        return actions;
+    };
+}

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

@@ -0,0 +1,3 @@
+import { type NodePlopAPI } from "node-plop";
+import { CloudAccountRepository, CloudAccountService } from "../../../../domain/cloud-account.js";
+export default function (plop: NodePlopAPI, templatesPath: string, cloudAccountRepository: CloudAccountRepository, cloudAccountService: CloudAccountService): void;

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

@@ -0,0 +1,19 @@
+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 setResourcePrefixHelper from "../../helpers/resource-prefix.js";
+import getActions from "./actions.js";
+import getPrompts from "./prompts.js";
+export default function (plop, templatesPath, cloudAccountRepository, cloudAccountService) {
+    setEnvShortHelper(plop);
+    setResourcePrefixHelper(plop);
+    setGetTerraformBackend(plop, cloudAccountService);
+    setProvisionTerraformBackendAction(plop, cloudAccountService);
+    setInitCloudAccountsAction(plop, cloudAccountService);
+    plop.setGenerator("DX_DeploymentEnvironment", {
+        actions: getActions(templatesPath),
+        description: "Generate a new deployment environment",
+        prompts: getPrompts({ cloudAccountRepository, cloudAccountService }),
+    });
+}

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

@@ -0,0 +1,66 @@
+import inquirer from "inquirer";
+import { type DynamicPromptsFunction } from "node-plop";
+import { CloudAccount, CloudAccountRepository, CloudAccountService, CloudRegion } from "../../../../domain/cloud-account.js";
+type InquirerChoice<T> = inquirer.Separator | {
+    name: string;
+    value: T;
+};
+import { z } from "zod/v4";
+export declare const workspaceSchema: z.ZodObject<{
+    domain: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+export declare const payloadSchema: z.ZodObject<{
+    env: z.ZodObject<{
+        cloudAccounts: z.ZodArray<z.ZodObject<{
+            csp: z.ZodDefault<z.ZodEnum<{
+                azure: "azure";
+            }>>;
+            defaultLocation: z.ZodString;
+            displayName: z.ZodString;
+            id: z.ZodString;
+        }, z.core.$strip>>;
+        name: z.ZodEnum<{
+            dev: "dev";
+            prod: "prod";
+            uat: "uat";
+        }>;
+        prefix: z.ZodString;
+    }, z.core.$strip>;
+    github: z.ZodObject<{
+        owner: z.ZodString;
+        repo: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    }, z.core.$strip>;
+    init: z.ZodOptional<z.ZodObject<{
+        cloudAccountsToInitialize: z.ZodArray<z.ZodObject<{
+            csp: z.ZodDefault<z.ZodEnum<{
+                azure: "azure";
+            }>>;
+            defaultLocation: z.ZodString;
+            displayName: z.ZodString;
+            id: z.ZodString;
+        }, z.core.$strip>>;
+        terraformBackend: z.ZodOptional<z.ZodObject<{
+            cloudAccount: z.ZodObject<{
+                csp: z.ZodDefault<z.ZodEnum<{
+                    azure: "azure";
+                }>>;
+                defaultLocation: z.ZodString;
+                displayName: z.ZodString;
+                id: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    tags: z.ZodRecord<z.ZodString, z.ZodString>;
+    workspace: z.ZodObject<{
+        domain: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type Payload = z.infer<typeof payloadSchema>;
+export type PromptsDependencies = {
+    cloudAccountRepository: CloudAccountRepository;
+    cloudAccountService: CloudAccountService;
+};
+declare const prompts: (deps: PromptsDependencies) => DynamicPromptsFunction;
+export declare const getCloudAccountChoices: (cloudAccounts: CloudAccount[]) => InquirerChoice<CloudAccount>[];
+export declare const getCloudLocationChoices: (regions: CloudRegion[]) => InquirerChoice<CloudRegion["name"]>[];
+export default prompts;

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

@@ -0,0 +1,166 @@
+import * as assert from "node:assert/strict";
+import { cloudAccountSchema, } from "../../../../domain/cloud-account.js";
+import { environmentSchema, getInitializationStatus, hasUserPermissionToInitialize, } from "../../../../domain/environment.js";
+import * as azure from "../../../azure/locations.js";
+import { getLogger } from "@logtape/logtape";
+import { z } from "zod/v4";
+import { githubRepoSchema } from "../../../../domain/github-repo.js";
+import { getGithubRepo } from "../../../github/github-repo.js";
+const initSchema = z.object({
+    cloudAccountsToInitialize: z.array(cloudAccountSchema),
+    terraformBackend: z
+        .object({
+        cloudAccount: cloudAccountSchema,
+    })
+        .optional(),
+});
+const tagsSchema = z.record(z.string(), z.string().min(1));
+export const workspaceSchema = z.object({
+    domain: z.string().default(""),
+});
+export const payloadSchema = z.object({
+    env: environmentSchema,
+    github: githubRepoSchema,
+    init: initSchema.optional(),
+    tags: tagsSchema,
+    workspace: workspaceSchema,
+});
+const prompts = (deps) => async (inquirer) => {
+    const logger = getLogger(["gen", "env"]);
+    const github = await getGithubRepo();
+    assert.ok(github, "This generator only works inside a GitHub repository.");
+    logger.debug("github repo {github}", { github });
+    const answers = await inquirer.prompt([
+        {
+            choices: [
+                { name: "PROD", value: "prod" },
+                { name: "UAT", value: "uat" },
+                { name: "DEV", value: "dev" },
+            ],
+            default: "prod",
+            message: "Environment name",
+            name: "env.name",
+            type: "list",
+        },
+        {
+            choices: [{ name: "Microsoft Azure", value: "azure" }],
+            default: ["azure"],
+            message: "Cloud provider(s)",
+            name: "csp",
+            type: "checkbox",
+            validate: (value) => Array.isArray(value) && value.length > 0
+                ? true
+                : "Please select at least one cloud provider.",
+        },
+        {
+            choices: async () => getCloudAccountChoices(await deps.cloudAccountRepository.list()),
+            loop: false,
+            message: "Account(s)",
+            name: "env.cloudAccounts",
+            type: "checkbox",
+            validate: (value) => Array.isArray(value) && value.length > 0
+                ? true
+                : "Please select a cloud account.",
+        },
+        {
+            message: "Prefix (2-4 characters)",
+            name: "env.prefix",
+            transformer: (value) => value.trim().toLowerCase(),
+            type: "input",
+            validate: (value) => value.length >= 2 && value.length <= 4
+                ? true
+                : "Please enter a valid prefix.",
+        },
+        {
+            message: "Domain (optional)",
+            name: "workspace.domain",
+            transformer: (value) => value.trim().toLowerCase(),
+            type: "input",
+        },
+        {
+            choices: [
+                {
+                    name: "TECNOLOGIA E SERVIZI",
+                    value: "TS000",
+                },
+            ],
+            default: "TS000 - Tecnologia e Servizi",
+            message: "Cost center",
+            name: "tags.CostCenter",
+            type: "list",
+            validate: (value) => Array.isArray(value) && value.length > 0
+                ? true
+                : "Please select a Cost Center.",
+        },
+        {
+            message: "Business unit",
+            name: "tags.BusinessUnit",
+            transformer: (value) => value.trim(),
+            validate: (value) => value.trim().length > 0 ? true : "Business Unit cannot be empty.",
+        },
+        {
+            message: "Management team",
+            name: "tags.ManagementTeam",
+            transformer: (value) => value.trim(),
+            validate: (value) => value.trim().length > 0 ? true : "Management Team cannot be empty.",
+        },
+    ]);
+    const payload = payloadSchema.parse({ ...answers, github });
+    const locations = await inquirer.prompt(payload.env.cloudAccounts.map((account) => ({
+        choices: getCloudLocationChoices(azure.cloudRegions),
+        default: azure.defaultLocation,
+        message: `Default location for ${account.displayName}`,
+        name: account.id,
+        type: "list",
+    })));
+    payload.env.cloudAccounts.forEach((account) => {
+        const location = locations[account.id];
+        if (location) {
+            account.defaultLocation = location;
+        }
+    });
+    const initStatus = await getInitializationStatus(deps.cloudAccountService, payload.env);
+    logger.debug("initialization status {initStatus}", { initStatus });
+    if (initStatus.initialized) {
+        return payload;
+    }
+    assert.ok(await hasUserPermissionToInitialize(deps.cloudAccountService, payload.env), "You don't have permission to initialize this environment. Ask your Engineering Leader to initialize it for you.");
+    const missingRemoteBackend = initStatus.issues.some((issue) => issue.type === "MISSING_REMOTE_BACKEND");
+    const initInput = await inquirer.prompt([
+        {
+            default: true,
+            message: "The environment is not initialized. Do you want to initialize it now?",
+            name: "init",
+            type: "confirm",
+        },
+        {
+            choices: getCloudAccountChoices(payload.env.cloudAccounts),
+            message: "Cloud Account to use for the remote Terraform backend",
+            name: "terraformBackend.cloudAccount",
+            type: "list",
+            when: (answers) => answers.init &&
+                missingRemoteBackend &&
+                payload.env.cloudAccounts.length > 1,
+        },
+    ]);
+    assert.ok(initInput.init, "Can't proceed without initialization");
+    payload.init = payloadSchema.shape.init.parse({
+        cloudAccountsToInitialize: initStatus.issues
+            .filter((issue) => issue.type === "CLOUD_ACCOUNT_NOT_INITIALIZED")
+            .map((issue) => issue.cloudAccount),
+        terraformBackend: missingRemoteBackend
+            ? {
+                cloudAccount: initInput.terraformBackend?.cloudAccount ||
+                    payload.env.cloudAccounts[0],
+            }
+            : undefined,
+    });
+    return payload;
+};
+// Creates Inquirer choices, prioritizing those that match the env prefix
+export const getCloudAccountChoices = (cloudAccounts) => cloudAccounts.map((account) => ({
+    name: `${account.displayName}`,
+    value: account,
+}));
+export const getCloudLocationChoices = (regions) => regions.map((r) => ({ name: r.displayName, value: r.name }));
+export default prompts;

package/dist/adapters/plop/generators/monorepo/actions.d.ts

@@ -0,0 +1,51 @@
+declare const getActions: (templatesPath: string) => ({
+    type: string;
+    repository?: undefined;
+    resultKey?: undefined;
+    abortOnFail?: undefined;
+    base?: undefined;
+    destination?: undefined;
+    globOptions?: undefined;
+    templateFiles?: undefined;
+    path?: undefined;
+    transform?: undefined;
+} | {
+    repository: {
+        name: string;
+        owner: string;
+    };
+    resultKey: string;
+    type: string;
+    abortOnFail?: undefined;
+    base?: undefined;
+    destination?: undefined;
+    globOptions?: undefined;
+    templateFiles?: undefined;
+    path?: undefined;
+    transform?: undefined;
+} | {
+    abortOnFail: boolean;
+    base: string;
+    destination: string;
+    globOptions: {
+        dot: boolean;
+    };
+    templateFiles: string;
+    type: string;
+    repository?: undefined;
+    resultKey?: undefined;
+    path?: undefined;
+    transform?: undefined;
+} | {
+    path: string;
+    transform: (content: string) => string;
+    type: string;
+    repository?: undefined;
+    resultKey?: undefined;
+    abortOnFail?: undefined;
+    base?: undefined;
+    destination?: undefined;
+    globOptions?: undefined;
+    templateFiles?: undefined;
+})[];
+export default getActions;

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

@@ -0,0 +1,35 @@
+import path from "node:path";
+const getActions = (templatesPath) => [
+    {
+        type: "getNodeVersion",
+    },
+    {
+        repository: { name: "terraform", owner: "hashicorp" },
+        resultKey: "terraformVersion",
+        type: "fetchGithubRelease",
+    },
+    {
+        repository: { name: "pre-commit-terraform", owner: "antonbabenko" },
+        resultKey: "preCommitTerraformVersion",
+        type: "fetchGithubRelease",
+    },
+    {
+        abortOnFail: true,
+        base: templatesPath,
+        destination: "{{repoName}}",
+        globOptions: { dot: true },
+        templateFiles: path.join(templatesPath),
+        type: "addMany",
+    },
+    {
+        path: "{{repoName}}/.gitignore",
+        transform: (content) => content
+            .trimEnd()
+            .concat("\n# Terraform lock files for modules\n**/modules/**/.terraform.lock.hcl\n**/_modules/**/.terraform.lock.hcl\n"),
+        type: "modify",
+    },
+    {
+        type: "setupPnpm",
+    },
+];
+export default getActions;

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

@@ -0,0 +1,6 @@
+import { type NodePlopAPI } from "node-plop";
+import { Octokit } from "octokit";
+import { Payload, payloadSchema } from "./prompts.js";
+export declare const PLOP_MONOREPO_GENERATOR_NAME = "DX_Monorepo";
+export { Payload, payloadSchema };
+export default function (plop: NodePlopAPI, templatesPath: string, octokit: Octokit): void;

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

@@ -0,0 +1,17 @@
+import setFetchGitHubRelease from "../../actions/fetch-github-release.js";
+import setGetNodeVersionAction from "../../actions/get-node-version.js";
+import setSetupPnpmAction from "../../actions/setup-pnpm.js";
+import getActions from "./actions.js";
+import getPrompts, { payloadSchema } from "./prompts.js";
+export const PLOP_MONOREPO_GENERATOR_NAME = "DX_Monorepo";
+export { payloadSchema };
+export default function (plop, templatesPath, octokit) {
+    setSetupPnpmAction(plop);
+    setGetNodeVersionAction(plop);
+    setFetchGitHubRelease(plop, octokit);
+    plop.setGenerator(PLOP_MONOREPO_GENERATOR_NAME, {
+        actions: getActions(templatesPath),
+        description: "A scaffold for a monorepo repository",
+        prompts: getPrompts(),
+    });
+}

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

@@ -0,0 +1,10 @@
+import { type PlopGeneratorConfig } from "node-plop";
+import { z } from "zod/v4";
+export declare const payloadSchema: z.ZodObject<{
+    repoDescription: z.ZodOptional<z.ZodString>;
+    repoName: z.ZodString;
+    repoOwner: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+export type Payload = z.infer<typeof payloadSchema>;
+declare const getPrompts: () => PlopGeneratorConfig["prompts"];
+export default getPrompts;

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

@@ -0,0 +1,31 @@
+import { z } from "zod/v4";
+export const payloadSchema = z.object({
+    repoDescription: z.string().optional(),
+    repoName: z.string().trim().min(1, "Repository name cannot be empty"),
+    repoOwner: z.string().trim().default("pagopa"),
+});
+const validatePrompt = (schema) => (input) => {
+    const error = schema.safeParse(input).error;
+    return error
+        ? // Return the error message defined in the Zod schema
+            z.prettifyError(error)
+        : true;
+};
+const getPrompts = () => [
+    {
+        message: "Repository name",
+        name: "repoName",
+        validate: validatePrompt(payloadSchema.shape.repoName),
+    },
+    {
+        default: payloadSchema.shape.repoOwner.def.defaultValue,
+        message: "GitHub repository owner (User or Organization)",
+        name: "repoOwner",
+        validate: validatePrompt(payloadSchema.shape.repoOwner),
+    },
+    {
+        message: "Repository description",
+        name: "repoDescription",
+    },
+];
+export default getPrompts;

package/dist/adapters/plop/helpers/__tests__/resource-prefix.test.d.ts

@@ -0,0 +1 @@
+export {};