@pagopa/dx-cli 0.22.1 → 0.22.3

package/dist/adapters/commander/__tests__/env.test.js

@@ -1,43 +1,45 @@
+import fc from "fast-check";
 /**
  * Tests for the CLI environment schema.
  * Validates that `cliEnvSchema` correctly parses `process.env`.
  */
 import { afterEach, describe, expect, it, vi } from "vitest";
+import { z } from "zod";
 import { cliEnvSchema } from "../env.js";
+// The accepted stringbool values mirror those recognised by z.stringbool().
+const CI_TRUTHY = ["true", "1", "yes", "y", "on"];
+const CI_FALSEY = ["false", "0", "no", "n", "off"];
+const CI_ACCEPTED = [...CI_TRUTHY, ...CI_FALSEY];
 describe("cliEnvSchema", () => {
     afterEach(() => {
         vi.unstubAllEnvs();
     });
     describe("CI field", () => {
-        it("is undefined when CI is not set", () => {
-            vi.stubEnv("CI", undefined);
-            const result = cliEnvSchema.safeParse(process.env);
-            expect(result.success).toBe(true);
-            expect(result.success && result.data.CI).toBeUndefined();
+        it("should be true for truthy string-bool values", () => {
+            fc.assert(fc.property(fc.constantFrom(...CI_TRUTHY), (value) => {
+                vi.stubEnv("CI", value);
+                const result = cliEnvSchema.safeParse(process.env);
+                expect(result.success).toBe(true);
+                expect(result.success && result.data.CI).toBe(true);
+            }));
         });
-        it("captures any non-empty CI value", () => {
-            vi.stubEnv("CI", "true");
-            const result = cliEnvSchema.safeParse(process.env);
-            expect(result.success).toBe(true);
-            expect(result.success && result.data.CI).toBe("true");
+        it("should be false for falsey string-bool values or when unset", () => {
+            fc.assert(fc.property(fc.constantFrom(...CI_FALSEY, undefined), (value) => {
+                vi.stubEnv("CI", value);
+                const result = cliEnvSchema.safeParse(process.env);
+                expect(result.success).toBe(true);
+                expect(result.success && result.data.CI).toBe(false);
+            }));
         });
-        it("captures CI=false as a string (presence is the signal, not the value)", () => {
-            vi.stubEnv("CI", "false");
-            const result = cliEnvSchema.safeParse(process.env);
-            expect(result.success).toBe(true);
-            expect(result.success && result.data.CI).toBe("false");
+        it("should not parse unrecognised values", () => {
+            fc.assert(fc.property(
+            // Every string not in the accepted list
+            fc.string().filter((s) => !CI_ACCEPTED.includes(s.toLowerCase())), (value) => {
+                vi.stubEnv("CI", value);
+                const result = cliEnvSchema.safeParse(process.env);
+                expect(result.success).toBe(false);
+                expect(result.error).toBeInstanceOf(z.ZodError);
+            }));
         });
-        it("captures CI=1 for numeric-style env vars", () => {
-            vi.stubEnv("CI", "1");
-            const result = cliEnvSchema.safeParse(process.env);
-            expect(result.success).toBe(true);
-            expect(result.success && result.data.CI).toBe("1");
-        });
-    });
-    it("passes through an object with unrelated env keys without failing", () => {
-        vi.stubEnv("CI", "true");
-        const result = cliEnvSchema.safeParse(process.env);
-        expect(result.success).toBe(true);
-        expect(result.success && result.data.CI).toBe("true");
     });
 });

package/dist/adapters/commander/env.d.ts

@@ -8,6 +8,6 @@
  */
 import { z } from "zod";
 export declare const cliEnvSchema: z.ZodObject<{
-    CI: z.ZodOptional<z.ZodString>;
+    CI: z.ZodDefault<z.ZodCodec<z.ZodString, z.ZodBoolean>>;
 }, z.core.$loose>;
 export type CliEnv = z.infer<typeof cliEnvSchema>;

package/dist/adapters/commander/env.js

@@ -9,9 +9,7 @@
 import { z } from "zod";
 export const cliEnvSchema = z
     .object({
-    // Standard CI marker. Presence (any string value) signals an automated
-    // pipeline where interactive prompts must not block. Follows the same
-    // convention used by `is-interactive` and `ora`.
-    CI: z.string().optional(),
+    // Use a truthy value to enable CI mode.
+    CI: z.stringbool().default(false),
 })
     .loose();

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.1",
+  "version": "0.22.3",
   "type": "module",
   "description": "A CLI useful to manage DX tools.",
   "repository": {
@@ -58,6 +58,7 @@
     "@types/semver": "^7.7.1",
     "@vitest/coverage-v8": "^3.2.4",
     "eslint": "^10.3.0",
+    "fast-check": "^4.8.0",
     "memfs": "^4.57.2",
     "plop": "^4.0.5",
     "prettier": "3.8.3",

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"}}"
   }
 }