@pagopa/dx-cli 0.22.2 → 0.22.4

package/dist/adapters/commander/presenters/__tests__/index.test.d.ts

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

package/dist/adapters/commander/presenters/__tests__/index.test.js

@@ -0,0 +1,23 @@
+/**
+ * Tests for isNonInteractive and createCommandPresenter factory.
+ */
+import { describe, expect, it } from "vitest";
+import { createCommandPresenter, isNonInteractive } from "../index.js";
+import { JsonCommandPresenter } from "../json-command-presenter.js";
+import { TextCommandPresenter } from "../text-command-presenter.js";
+describe("isNonInteractive", () => {
+    it("returns true when CI is true", () => {
+        expect(isNonInteractive({ CI: true })).toBe(true);
+    });
+    it("returns false when CI is false", () => {
+        expect(isNonInteractive({ CI: false })).toBe(false);
+    });
+});
+describe("createCommandPresenter", () => {
+    it("returns a TextCommandPresenter when output is 'text'", () => {
+        expect(createCommandPresenter("text")).toBeInstanceOf(TextCommandPresenter);
+    });
+    it("returns a JsonCommandPresenter when output is 'json'", () => {
+        expect(createCommandPresenter("json")).toBeInstanceOf(JsonCommandPresenter);
+    });
+});

package/dist/adapters/commander/presenters/__tests__/json.test.d.ts

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

package/dist/adapters/commander/presenters/__tests__/json.test.js

@@ -0,0 +1,108 @@
+/**
+ * Tests for JsonCommandPresenter.
+ *
+ * JsonCommandPresenter uses a split-stream convention:
+ *   - stdout for the final result/error envelope
+ *   - stderr for step lifecycle (progress) events
+ *
+ * Tests verify the wire format, correct stream usage, and that values
+ * flow through correctly.
+ */
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { JsonCommandPresenter } from "../json-command-presenter.js";
+const captureStdout = () => {
+    const written = [];
+    vi.spyOn(process.stdout, "write").mockImplementation((data) => {
+        written.push(String(data));
+        return true;
+    });
+    return { written };
+};
+const captureStderr = () => {
+    const written = [];
+    vi.spyOn(process.stderr, "write").mockImplementation((data) => {
+        written.push(String(data));
+        return true;
+    });
+    return { written };
+};
+describe("JsonCommandPresenter", () => {
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    describe("trackStep", () => {
+        it("executes the task and returns its resolved value", async () => {
+            captureStderr();
+            const logger = new JsonCommandPresenter();
+            const result = await logger.trackStep("check terraform", () => Promise.resolve(42));
+            expect(result).toBe(42);
+        });
+        it("emits start then success events to stderr", async () => {
+            const stderr = captureStderr();
+            const logger = new JsonCommandPresenter();
+            await logger.trackStep("check terraform", () => Promise.resolve("done"));
+            expect(stderr.written).toHaveLength(2);
+            expect(JSON.parse(stderr.written[0])).toMatchObject({
+                name: "check terraform",
+                status: "start",
+                type: "step",
+            });
+            expect(JSON.parse(stderr.written[1])).toMatchObject({
+                name: "check terraform",
+                status: "success",
+                type: "step",
+            });
+        });
+        it("emits error event to stderr and rethrows on task failure", async () => {
+            const stderr = captureStderr();
+            const logger = new JsonCommandPresenter();
+            const error = new Error("terraform not found");
+            await expect(logger.trackStep("check terraform", () => Promise.reject(error))).rejects.toThrow("terraform not found");
+            expect(JSON.parse(stderr.written[1])).toMatchObject({
+                error: "terraform not found",
+                name: "check terraform",
+                status: "error",
+                type: "step",
+            });
+        });
+        it("can run multiple sequential steps", async () => {
+            captureStderr();
+            const logger = new JsonCommandPresenter();
+            const order = [];
+            await logger.trackStep("step A", async () => {
+                order.push("A");
+            });
+            await logger.trackStep("step B", async () => {
+                order.push("B");
+            });
+            expect(order).toEqual(["A", "B"]);
+        });
+    });
+    describe("reportResult", () => {
+        it("emits an ok:true JSON envelope to stdout", () => {
+            const stdout = captureStdout();
+            const logger = new JsonCommandPresenter();
+            logger.reportResult({ repository: { name: "my-repo" } });
+            expect(JSON.parse(stdout.written[0])).toEqual({
+                data: { repository: { name: "my-repo" } },
+                ok: true,
+            });
+        });
+    });
+    describe("reportError", () => {
+        it("emits an ok:false JSON envelope to stdout", () => {
+            const stdout = captureStdout();
+            const logger = new JsonCommandPresenter();
+            logger.reportError(new Error("something failed"));
+            expect(JSON.parse(stdout.written[0])).toMatchObject({
+                error: "something failed",
+                ok: false,
+            });
+        });
+        it("handles non-Error values without throwing", () => {
+            captureStdout();
+            const logger = new JsonCommandPresenter();
+            expect(() => logger.reportError("plain string error")).not.toThrow();
+        });
+    });
+});

package/dist/adapters/commander/presenters/__tests__/text.test.d.ts

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

package/dist/adapters/commander/presenters/__tests__/text.test.js

@@ -0,0 +1,60 @@
+/**
+ * Tests for TextCommandPresenter.
+ *
+ * The TextCommandPresenter wraps oraPromise for step feedback and chalk for
+ * final output. Tests verify the observable behavior: tasks are executed,
+ * values flow through, and errors surface correctly.
+ */
+import { afterEach, describe, expect, it, vi } from "vitest";
+// Mock oraPromise so tests don't spin up a real TTY spinner
+vi.mock("ora", () => ({
+    oraPromise: (_promise) => _promise,
+}));
+import { TextCommandPresenter } from "../text-command-presenter.js";
+describe("TextCommandPresenter", () => {
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    describe("trackStep", () => {
+        it("executes the task and returns its resolved value", async () => {
+            const logger = new TextCommandPresenter();
+            const result = await logger.trackStep("check terraform", () => Promise.resolve(42));
+            expect(result).toBe(42);
+        });
+        it("propagates task rejection as a thrown error", async () => {
+            const logger = new TextCommandPresenter();
+            const error = new Error("terraform not found");
+            await expect(logger.trackStep("check terraform", () => Promise.reject(error))).rejects.toThrow("terraform not found");
+        });
+        it("can run multiple sequential steps", async () => {
+            const logger = new TextCommandPresenter();
+            const order = [];
+            await logger.trackStep("step A", async () => {
+                order.push("A");
+            });
+            await logger.trackStep("step B", async () => {
+                order.push("B");
+            });
+            expect(order).toEqual(["A", "B"]);
+        });
+    });
+    describe("reportResult", () => {
+        it("calls console.log without throwing", () => {
+            vi.spyOn(console, "log").mockImplementation(() => undefined);
+            const logger = new TextCommandPresenter();
+            expect(() => logger.reportResult({ repository: { name: "my-repo" } })).not.toThrow();
+        });
+    });
+    describe("reportError", () => {
+        it("calls console.error without throwing", () => {
+            vi.spyOn(console, "error").mockImplementation(() => undefined);
+            const logger = new TextCommandPresenter();
+            expect(() => logger.reportError(new Error("something failed"))).not.toThrow();
+        });
+        it("handles non-Error values without throwing", () => {
+            vi.spyOn(console, "error").mockImplementation(() => undefined);
+            const logger = new TextCommandPresenter();
+            expect(() => logger.reportError("plain string error")).not.toThrow();
+        });
+    });
+});

package/dist/adapters/commander/presenters/index.d.ts

@@ -0,0 +1,27 @@
+import type { CommandPresenter } from "../../../domain/command-presenter.js";
+/**
+ * Output logger factory.
+ *
+ * isNonInteractive determines whether the CLI should suppress interactive
+ * prompts (e.g. when running in a CI pipeline). This is independent of the
+ * output format: a user can request JSON output while still answering prompts,
+ * and a CI system can set CI=true with text output.
+ *
+ * createCommandPresenter selects the appropriate CommandPresenter adapter based solely
+ * on the requested output format.
+ */
+import type { CliEnv } from "../env.js";
+/**
+ * Returns true when the CLI should suppress interactive prompts.
+ *
+ * Checks the parsed CI boolean from CliEnv (coerced by zod's stringbool),
+ * following the same convention used by `is-interactive` and `ora`.
+ */
+export declare const isNonInteractive: (env: CliEnv) => boolean;
+/**
+ * Returns the appropriate CommandPresenter adapter for the requested output mode.
+ *
+ * - "text" → TextCommandPresenter (chalk + ora, for human terminal sessions)
+ * - "json" → JsonCommandPresenter (NDJSON on stderr, JSON envelope on stdout)
+ */
+export declare const createCommandPresenter: (output: "json" | "text") => CommandPresenter;

package/dist/adapters/commander/presenters/index.js

@@ -0,0 +1,16 @@
+import { JsonCommandPresenter } from "./json-command-presenter.js";
+import { TextCommandPresenter } from "./text-command-presenter.js";
+/**
+ * Returns true when the CLI should suppress interactive prompts.
+ *
+ * Checks the parsed CI boolean from CliEnv (coerced by zod's stringbool),
+ * following the same convention used by `is-interactive` and `ora`.
+ */
+export const isNonInteractive = (env) => env.CI;
+/**
+ * Returns the appropriate CommandPresenter adapter for the requested output mode.
+ *
+ * - "text" → TextCommandPresenter (chalk + ora, for human terminal sessions)
+ * - "json" → JsonCommandPresenter (NDJSON on stderr, JSON envelope on stdout)
+ */
+export const createCommandPresenter = (output) => output === "json" ? new JsonCommandPresenter() : new TextCommandPresenter();

package/dist/adapters/commander/presenters/json-command-presenter.d.ts

@@ -0,0 +1,19 @@
+/**
+ * JsonCommandPresenter — structured adapter for the CommandPresenter domain port.
+ *
+ * Uses a split-stream convention for machine-readable output:
+ *   - stdout: final result/error envelope (JSON, one line)
+ *   - stderr: step lifecycle events (NDJSON progress stream)
+ *
+ * Each line is a self-describing JSON object discriminated by its fields:
+ *
+ *   stderr: {"type":"step","status":"start"|"success"|"error","name":"...","error":"...?"}
+ *   stdout: {"ok":true,"data":{...}}
+ *   stdout: {"ok":false,"error":"..."}
+ */
+import type { CommandPresenter } from "../../../domain/command-presenter.js";
+export declare class JsonCommandPresenter implements CommandPresenter {
+    reportError(error: unknown): void;
+    reportResult<T>(data: T): void;
+    trackStep<T>(name: string, task: () => Promise<T>): Promise<T>;
+}

package/dist/adapters/commander/presenters/json-command-presenter.js

@@ -0,0 +1,26 @@
+import { toErrorMessage } from "../error-reporting.js";
+export class JsonCommandPresenter {
+    reportError(error) {
+        process.stdout.write(JSON.stringify({ error: toErrorMessage(error), ok: false }) + "\n");
+    }
+    reportResult(data) {
+        process.stdout.write(JSON.stringify({ data, ok: true }) + "\n");
+    }
+    async trackStep(name, task) {
+        process.stderr.write(JSON.stringify({ name, status: "start", type: "step" }) + "\n");
+        try {
+            const result = await task();
+            process.stderr.write(JSON.stringify({ name, status: "success", type: "step" }) + "\n");
+            return result;
+        }
+        catch (error) {
+            process.stderr.write(JSON.stringify({
+                error: toErrorMessage(error),
+                name,
+                status: "error",
+                type: "step",
+            }) + "\n");
+            throw error;
+        }
+    }
+}

package/dist/adapters/commander/presenters/text-command-presenter.d.ts

@@ -0,0 +1,6 @@
+import type { CommandPresenter } from "../../../domain/command-presenter.js";
+export declare class TextCommandPresenter implements CommandPresenter {
+    reportError(error: unknown): void;
+    reportResult<T>(data: T): void;
+    trackStep<T>(name: string, task: () => Promise<T>): Promise<T>;
+}

package/dist/adapters/commander/presenters/text-command-presenter.js

@@ -0,0 +1,21 @@
+/**
+ * TextCommandPresenter — human-readable adapter for the CommandPresenter domain port.
+ *
+ * Renders step progress via oraPromise for interactive terminal feedback,
+ * and writes results and errors to the console with chalk colouring.
+ * Intended for interactive terminal sessions (TTY).
+ */
+import chalk from "chalk";
+import { oraPromise } from "ora";
+import { toErrorMessage } from "../error-reporting.js";
+export class TextCommandPresenter {
+    reportError(error) {
+        console.error(chalk.red(toErrorMessage(error)));
+    }
+    reportResult(data) {
+        console.log(data);
+    }
+    async trackStep(name, task) {
+        return oraPromise(task(), { text: name });
+    }
+}

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

@@ -1,5 +1,12 @@
 import { describe, expect, test } from "vitest";
+import { z } from "zod";
 import getActions from "../actions.js";
+const terraformBackendActionSchema = z.object({
+    data: z.object({
+        terraformBackendKey: z.string(),
+    }),
+    type: z.literal("addMany"),
+});
 export const getPayload = (includeInit = false) => {
     const cloudAccount = {
         csp: "azure",
@@ -63,4 +70,23 @@ describe("actions", () => {
             .map((action) => action.type);
         expect(actionTypes).toEqual(actionsOrder);
     });
+    test.each([
+        {
+            expectedKeys: [
+                "dx/mytest/bootstrapper.tfstate",
+                "dx/mytest/core.tfstate",
+            ],
+            payload: getPayload(true),
+        },
+        {
+            expectedKeys: ["dx/mytest/bootstrapper.tfstate"],
+            payload: getPayload(false),
+        },
+    ])("uses prefix/domain/scope state keys in shared backend actions", ({ expectedKeys, payload }) => {
+        const actions = getActions("/templates/path")(payload);
+        const terraformBackendKeys = actions
+            .filter((action) => terraformBackendActionSchema.safeParse(action).success)
+            .map((action) => action.data.terraformBackendKey);
+        expect(terraformBackendKeys).toEqual(expectedKeys);
+    });
 });

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

@@ -18,10 +18,13 @@ describe("workspaceSchema — domain transforms", () => {
         expect(result.success).toBe(true);
         expect(result.success && result.data.domain).toBe("api");
     });
-    it("defaults domain to empty string when not provided", () => {
+    it("requires domain to be provided", () => {
         const result = workspaceSchema.safeParse({});
-        expect(result.success).toBe(true);
-        expect(result.success && result.data.domain).toBe("");
+        expect(result.success).toBe(false);
+    });
+    it("rejects domains that would create nested paths", () => {
+        const result = workspaceSchema.safeParse({ domain: "core/platform" });
+        expect(result.success).toBe(false);
     });
 });
 describe("formatInitializationDetails", () => {

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

@@ -1,12 +1,14 @@
 import { getLogger } from "@logtape/logtape";
 import * as path from "node:path";
 import { formatTerraformCode } from "../../../terraform/fmt.js";
+import { terraformStateKey } from "../../helpers/terraform-state-key.js";
 import { payloadSchema } from "./prompts.js";
-const addModule = (env, templatesPath, init = false) => {
+const addModule = (context, templatesPath, init = false) => {
+    const { env } = context;
     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) => [
+    return (name) => [
         {
             base: templatesPath,
             data: { cloudAccountsByCsp, includesProdIO, init },
@@ -19,7 +21,11 @@ const addModule = (env, templatesPath, init = false) => {
         },
         {
             base: path.join(templatesPath, "shared"),
-            data: { cloudAccountsByCsp, init, terraformBackendKey },
+            data: {
+                cloudAccountsByCsp,
+                init,
+                terraformBackendKey: terraformStateKey(context, name),
+            },
             destination: path.join(cwd, "infra", name, "{{env.name}}"),
             force: true,
             templateFiles: path.join(templatesPath, "shared"),
@@ -41,17 +47,17 @@ const addWorkflowModule = (templatesPath) => {
     };
 };
 export default function getActions(templatesPath) {
-    return (payload) => {
+    return (input) => {
         const logger = getLogger(["gen", "env"]);
-        logger.debug("payload {payload}", { payload });
-        const { env, github, init } = payloadSchema.parse(payload);
-        const addEnvironmentModule = addModule(env, templatesPath, !!init);
+        logger.debug("environment generator input {input}", { input });
+        const { env, init, workspace } = payloadSchema.parse(input);
+        const addEnvironmentModule = addModule({ env, workspace }, templatesPath, !!init);
         const actions = [
             {
                 type: "getTerraformBackend",
             },
             addWorkflowModule(templatesPath),
-            ...addEnvironmentModule("bootstrapper", `${github.repo}.bootstrapper.${env.name}.tfstate`),
+            ...addEnvironmentModule("bootstrapper"),
         ];
         if (init) {
             actions.unshift({
@@ -61,7 +67,7 @@ export default function getActions(templatesPath) {
                     ? "provisionTerraformBackend"
                     : "getTerraformBackend",
             });
-            actions.push(...addEnvironmentModule("core", `${env.prefix}.core.${env.name}.tfstate`));
+            actions.push(...addEnvironmentModule("core"));
         }
         return actions;
     };

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

@@ -4,6 +4,7 @@ import setProvisionTerraformBackendAction from "../../actions/provision-terrafor
 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";
 export const PLOP_ENVIRONMENT_GENERATOR_NAME = "DX_DeploymentEnvironment";
@@ -12,6 +13,7 @@ export default function (plop, templatesPath, cloudAccountRepository, cloudAccou
     setEnvShortHelper(plop);
     setResourcePrefixHelper(plop);
     setEqHelper(plop);
+    setTerraformStateKeyHelper(plop);
     setGetTerraformBackend(plop, cloudAccountService);
     setProvisionTerraformBackendAction(plop, cloudAccountService);
     setInitCloudAccountsAction(plop, cloudAccountService, gitHubService);

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

@@ -9,7 +9,7 @@ type InquirerChoice<T> = inquirer.Separator | {
 import { z } from "zod/v4";
 import { GitHubRepo } from "../../../../domain/github-repo.js";
 export declare const workspaceSchema: z.ZodObject<{
-    domain: z.ZodDefault<z.ZodString>;
+    domain: z.ZodString;
 }, z.core.$strip>;
 export declare const payloadSchema: z.ZodObject<{
     env: z.ZodObject<{
@@ -60,7 +60,7 @@ export declare const payloadSchema: z.ZodObject<{
     }, z.core.$strip>>;
     tags: z.ZodRecord<z.ZodString, z.ZodString>;
     workspace: z.ZodObject<{
-        domain: z.ZodDefault<z.ZodString>;
+        domain: z.ZodString;
     }, z.core.$strip>;
 }, z.core.$strip>;
 export type Payload = z.infer<typeof payloadSchema>;

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

@@ -19,8 +19,14 @@ const initSchema = z.object({
         .optional(),
 });
 const tagsSchema = z.record(z.string(), z.string().min(1));
+const workspaceDomainSchema = z
+    .string()
+    .trim()
+    .toLowerCase()
+    .min(1, "Domain is required")
+    .regex(/^[a-z0-9-]+$/, "Domain may contain only lowercase letters, numbers, and hyphens");
 export const workspaceSchema = z.object({
-    domain: z.string().trim().toLowerCase().default(""),
+    domain: workspaceDomainSchema,
 });
 export const payloadSchema = z.object({
     env: environmentSchema,
@@ -76,9 +82,10 @@ const prompts = (deps) => async (inquirer) => {
         },
         {
             filter: (value) => value.trim().toLowerCase(),
-            message: "Domain (optional)",
+            message: "Domain",
             name: "workspace.domain",
             type: "input",
+            validate: validatePrompt(workspaceSchema.shape.domain),
         },
         {
             choices: [

package/dist/adapters/plop/helpers/__tests__/terraform-state-key.test.d.ts

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

package/dist/adapters/plop/helpers/__tests__/terraform-state-key.test.js

@@ -0,0 +1,35 @@
+/**
+ * Tests for Terraform state key generation used by the environment generator.
+ */
+import { describe, expect, it } from "vitest";
+import { terraformStateKey } from "../terraform-state-key.js";
+const createMockContext = (overrides = {}) => ({
+    env: {
+        cloudAccounts: [],
+        name: "dev",
+        prefix: "dx",
+    },
+    workspace: {
+        domain: "shared",
+    },
+    ...overrides,
+});
+describe("terraformStateKey", () => {
+    it("returns keys using the prefix/domain/scope convention", () => {
+        const result = terraformStateKey(createMockContext(), "bootstrapper");
+        expect(result).toBe("dx/shared/bootstrapper.tfstate");
+    });
+    it("supports hyphenated names", () => {
+        const result = terraformStateKey(createMockContext({
+            workspace: { domain: "playground" },
+        }), "mcp-server");
+        expect(result).toBe("dx/playground/mcp-server.tfstate");
+    });
+    it("rejects names that would create nested paths", () => {
+        expect(() => terraformStateKey(createMockContext(), "core/root")).toThrow(/Terraform state name may contain only lowercase letters, numbers, and hyphens/u);
+    });
+    it("rejects names with uppercase letters or surrounding spaces", () => {
+        expect(() => terraformStateKey(createMockContext(), "Mcp-Server")).toThrow(/Terraform state name may contain only lowercase letters, numbers, and hyphens/u);
+        expect(() => terraformStateKey(createMockContext(), " mcp-server ")).toThrow(/Terraform state name may contain only lowercase letters, numbers, and hyphens/u);
+    });
+});

package/dist/adapters/plop/helpers/terraform-state-key.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Terraform state key helper.
+ *
+ * Keeps the DX environment generator aligned with the shared
+ * prefix/domain/scope.tfstate convention for remote state keys.
+ */
+import { type NodePlopAPI } from "node-plop";
+import { z } from "zod";
+declare const terraformStateContextSchema: 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>;
+    workspace: z.ZodObject<{
+        domain: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+type TerraformStateContext = z.infer<typeof terraformStateContextSchema>;
+export declare const terraformStateKey: (context: TerraformStateContext, name: string) => string;
+declare const _default: (plop: NodePlopAPI) => void;
+export default _default;

package/dist/adapters/plop/helpers/terraform-state-key.js

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { payloadSchema } from "../generators/environment/prompts.js";
+const terraformStateContextSchema = payloadSchema.pick({
+    env: true,
+    workspace: true,
+});
+const terraformStateNameSchema = z
+    .string()
+    .regex(/^[a-z0-9-]+$/, "Terraform state name may contain only lowercase letters, numbers, and hyphens");
+export const terraformStateKey = (context, name) => {
+    const parsedName = terraformStateNameSchema.safeParse(name);
+    if (!parsedName.success) {
+        throw new Error(parsedName.error.issues[0]?.message ?? "Invalid Terraform state name", {
+            cause: parsedName.error,
+        });
+    }
+    return `${context.env.prefix}/${context.workspace.domain}/${parsedName.data}.tfstate`;
+};
+export default (plop) => {
+    plop.setHelper("terraformStateKey", (input, name) => {
+        const context = terraformStateContextSchema.safeParse(input);
+        if (!context.success) {
+            throw new Error(context.error.issues[0]?.message ??
+                "Invalid Terraform state helper input", {
+                cause: context.error,
+            });
+        }
+        return terraformStateKey(context.data, name);
+    });
+};

package/package.json

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

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

@@ -60,7 +60,7 @@ module "azure-{{displayName}}_core_values" {
     storage_account_name = "{{@root.terraform.backend.storageAccountName}}"
     subscription_id      = "{{@root.terraform.backend.subscriptionId}}"
     container_name       = "terraform-state"
-    key                  = "{{@root.env.prefix}}.core.{{@root.env.name}}.tfstate"
+    key                  = "{{terraformStateKey @root "core"}}"
   }
 }