@pagopa/dx-cli 0.15.2 → 0.15.3

package/dist/adapters/octokit/__tests__/index.test.js

@@ -0,0 +1,197 @@
+import { err, ok } from "neverthrow";
+import { RequestError } from "octokit";
+import { SemVer } from "semver";
+import { beforeEach, describe, expect, it } from "vitest";
+import { mockDeep, mockReset } from "vitest-mock-extended";
+import { PullRequest, Repository, RepositoryNotFoundError, } from "../../../domain/github.js";
+import { fetchLatestRelease, fetchLatestTag } from "../index.js";
+import { OctokitGitHubService } from "../index.js";
+const makeEnv = () => {
+    const mockOctokit = mockDeep();
+    const githubService = new OctokitGitHubService(mockOctokit);
+    return {
+        githubService,
+        mockOctokit,
+    };
+};
+describe("OctokitGitHubService", () => {
+    describe("getRepository", () => {
+        it("should return a Repository when the repository exists", async () => {
+            const { githubService, mockOctokit } = makeEnv();
+            const owner = "pagopa";
+            const name = "dx";
+            const mockResponse = {
+                data: {
+                    full_name: "pagopa/dx",
+                    name: "dx",
+                    owner: {
+                        login: "pagopa",
+                    },
+                },
+            };
+            mockOctokit.rest.repos.get.mockResolvedValue(mockResponse);
+            const result = await githubService.getRepository(owner, name);
+            expect(result).toBeInstanceOf(Repository);
+            expect(result.name).toBe("dx");
+            expect(result.owner).toBe("pagopa");
+            expect(result.fullName).toBe("pagopa/dx");
+            expect(result.url).toBe("https://github.com/pagopa/dx");
+            expect(result.ssh).toBe("git@github.com:pagopa/dx.git");
+            expect(mockOctokit.rest.repos.get).toHaveBeenCalledWith({
+                owner,
+                repo: name,
+            });
+        });
+        it("should throw an error when the repository does not exist (404)", async () => {
+            const { githubService, mockOctokit } = makeEnv();
+            const owner = "pagopa";
+            const name = "non-existent";
+            const error = new RequestError("Not Found", 404, {
+                request: {
+                    headers: {},
+                    method: "GET",
+                    url: "https://api.github.com/repos/pagopa/non-existent",
+                },
+                response: {
+                    data: { message: "Not Found" },
+                    headers: {},
+                    status: 404,
+                    url: "https://api.github.com/repos/pagopa/non-existent",
+                },
+            });
+            mockOctokit.rest.repos.get.mockRejectedValue(error);
+            await expect(githubService.getRepository(owner, name)).rejects.toThrow(RepositoryNotFoundError);
+            await expect(githubService.getRepository(owner, name)).rejects.toThrowError("Repository pagopa/non-existent not found");
+        });
+        it("should throw an error when the API call fails", async () => {
+            const { githubService, mockOctokit } = makeEnv();
+            const owner = "pagopa";
+            const name = "dx";
+            const error = new RequestError("API Error", 500, {
+                request: {
+                    headers: {},
+                    method: "GET",
+                    url: "https://api.github.com/repos/pagopa/dx",
+                },
+                response: {
+                    data: { message: "API Error" },
+                    headers: {},
+                    status: 500,
+                    url: "https://api.github.com/repos/pagopa/dx",
+                },
+            });
+            mockOctokit.rest.repos.get.mockRejectedValue(error);
+            await expect(githubService.getRepository(owner, name)).rejects.toThrowError("Failed to fetch repository pagopa/dx");
+        });
+    });
+    describe("createPullRequest", () => {
+        it("should return a PullRequest when creation succeeds", async () => {
+            const { githubService, mockOctokit } = makeEnv();
+            const params = {
+                base: "main",
+                body: "This is a test PR",
+                head: "feature-branch",
+                owner: "pagopa",
+                repo: "dx",
+                title: "Test Pull Request",
+            };
+            const mockResponse = {
+                data: {
+                    html_url: "https://github.com/pagopa/dx/pull/123",
+                },
+            };
+            mockOctokit.rest.pulls.create.mockResolvedValue(mockResponse);
+            const result = await githubService.createPullRequest(params);
+            expect(result).toBeInstanceOf(PullRequest);
+            expect(result.url).toBe("https://github.com/pagopa/dx/pull/123");
+            expect(mockOctokit.rest.pulls.create).toHaveBeenCalledWith({
+                base: params.base,
+                body: params.body,
+                head: params.head,
+                owner: params.owner,
+                repo: params.repo,
+                title: params.title,
+            });
+        });
+        it("should throw an error when PR creation fails", async () => {
+            const { githubService, mockOctokit } = makeEnv();
+            const params = {
+                base: "main",
+                body: "This is a test PR",
+                head: "feature-branch",
+                owner: "pagopa",
+                repo: "dx",
+                title: "Test Pull Request",
+            };
+            const error = new RequestError("Validation Failed", 422, {
+                request: {
+                    headers: {},
+                    method: "POST",
+                    url: "https://api.github.com/repos/pagopa/dx/pulls",
+                },
+                response: {
+                    data: { message: "Validation Failed" },
+                    headers: {},
+                    status: 422,
+                    url: "https://api.github.com/repos/pagopa/dx/pulls",
+                },
+            });
+            mockOctokit.rest.pulls.create.mockRejectedValue(error);
+            await expect(githubService.createPullRequest(params)).rejects.toThrowError("Failed to create pull request in pagopa/dx");
+        });
+    });
+});
+describe("octokit adapter", () => {
+    const owner = "test-owner";
+    const repo = "test-repo";
+    const client = mockDeep();
+    beforeEach(() => {
+        mockReset(client);
+    });
+    describe("fetchLatestTag", () => {
+        it("should return the highest valid semver tag", async () => {
+            client.request.mockResolvedValueOnce({
+                data: [
+                    { name: "v1.0.0" },
+                    { name: "2.0.0-beta.1" },
+                    { name: "2.0.0" },
+                    { name: "not-a-version" },
+                ],
+                headers: {},
+                status: 200,
+                url: "",
+            });
+            const result = await fetchLatestTag({ client, owner, repo });
+            expect(result).toStrictEqual(ok(new SemVer("2.0.0")));
+            expect(client.request).toHaveBeenCalledWith("GET /repos/{owner}/{repo}/tags", { owner, repo });
+        });
+        it("returns null if there are no valid semver tags", async () => {
+            client.request.mockResolvedValueOnce({
+                data: [{ name: "foo" }, { name: "bar" }],
+                headers: {},
+                status: 200,
+                url: "",
+            });
+            const result = await fetchLatestTag({ client, owner, repo });
+            expect(result).toStrictEqual(ok(null));
+        });
+        it("should return an error when client promise fails", async () => {
+            client.request.mockRejectedValueOnce(new Error("an error"));
+            const result = await fetchLatestTag({ client, owner, repo });
+            expect(result).toStrictEqual(err(new Error("Failed to fetch tags for test-owner/test-repo")));
+        });
+    });
+    describe("fetchLatestRelease", () => {
+        it("should return parsed semver for the latest release tag", async () => {
+            client.request.mockResolvedValueOnce({
+                data: { tag_name: "v1.2.3" },
+                headers: {},
+                status: 200,
+                url: "",
+            });
+            const result = await fetchLatestRelease({ client, owner, repo });
+            expect(result).toStrictEqual(ok(new SemVer("v1.2.3")));
+            expect(client.request).toHaveBeenCalledWith("GET /repos/{owner}/{repo}/releases/latest", { owner, repo });
+        });
+    });
+});

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

@@ -0,0 +1,24 @@
+import { ResultAsync } from "neverthrow";
+import { Octokit } from "octokit";
+import { GitHubService, PullRequest, Repository } from "../../domain/github.js";
+type GitHubReleaseParam = {
+    client: Octokit;
+    owner: string;
+    repo: string;
+};
+export declare class OctokitGitHubService implements GitHubService {
+    #private;
+    constructor(octokit: Octokit);
+    createPullRequest(params: {
+        base: string;
+        body: string;
+        head: string;
+        owner: string;
+        repo: string;
+        title: string;
+    }): Promise<PullRequest>;
+    getRepository(owner: string, name: string): Promise<Repository>;
+}
+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

@@ -0,0 +1,65 @@
+import { ResultAsync } from "neverthrow";
+import { RequestError } from "octokit";
+import semverParse from "semver/functions/parse.js";
+import semverSort from "semver/functions/sort.js";
+import { PullRequest, Repository, RepositoryNotFoundError, } from "../../domain/github.js";
+export class OctokitGitHubService {
+    #octokit;
+    constructor(octokit) {
+        this.#octokit = octokit;
+    }
+    async createPullRequest(params) {
+        try {
+            const { data } = await this.#octokit.rest.pulls.create({
+                base: params.base,
+                body: params.body,
+                head: params.head,
+                owner: params.owner,
+                repo: params.repo,
+                title: params.title,
+            });
+            return new PullRequest(data.html_url);
+        }
+        catch (error) {
+            throw new Error(`Failed to create pull request in ${params.owner}/${params.repo}`, {
+                cause: error,
+            });
+        }
+    }
+    async getRepository(owner, name) {
+        try {
+            const { data } = await this.#octokit.rest.repos.get({
+                owner,
+                repo: name,
+            });
+            return new Repository(data.name, data.owner.login);
+        }
+        catch (error) {
+            if (error instanceof RequestError && error.status === 404) {
+                throw new RepositoryNotFoundError(owner, name);
+            }
+            throw new Error(`Failed to fetch repository ${owner}/${name}`, {
+                cause: error,
+            });
+        }
+    }
+}
+export const fetchLatestTag = ({ client, owner, repo }) => ResultAsync.fromPromise(
+// Get repository tags
+client.request("GET /repos/{owner}/{repo}/tags", {
+    owner,
+    repo,
+}), () => new Error(`Failed to fetch tags for ${owner}/${repo}`))
+    .map(({ data }) => data.map(({ name }) => name))
+    // Filter out tags that are not valid semver
+    .map((tags) => tags.map((tag) => semverParse(tag)).filter((tag) => tag !== null))
+    // Sort tags in ascending order
+    .map(semverSort)
+    // Get the latest tag
+    .map((tags) => tags.pop() ?? null);
+export const fetchLatestRelease = ({ client, owner, repo, }) => ResultAsync.fromPromise(
+// Get the latest release for a repository
+client.request("GET /repos/{owner}/{repo}/releases/latest", {
+    owner,
+    repo,
+}), () => new Error(`Failed to fetch latest release for ${owner}/${repo}`)).map(({ data }) => semverParse(data.tag_name));

package/dist/adapters/plop/actions/__tests__/init-cloud-accounts.test.d.ts

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

package/dist/adapters/plop/actions/__tests__/init-cloud-accounts.test.js

@@ -0,0 +1,115 @@
+import { describe, expect, it, vi } from "vitest";
+import { initCloudAccounts } from "../init-cloud-accounts.js";
+const createMockCloudAccountService = (overrides = {}) => ({
+    getTerraformBackend: vi.fn().mockResolvedValue(undefined),
+    hasUserPermissionToInitialize: vi.fn().mockResolvedValue(true),
+    initialize: vi.fn().mockResolvedValue(undefined),
+    isInitialized: vi.fn().mockResolvedValue(true),
+    provisionTerraformBackend: vi.fn().mockResolvedValue(undefined),
+    ...overrides,
+});
+const createMockCloudAccount = (overrides = {}) => ({
+    csp: "azure",
+    defaultLocation: "westeurope",
+    displayName: "Test-Account",
+    id: "test-subscription-id",
+    ...overrides,
+});
+const createMockPayload = (overrides = {}) => ({
+    env: {
+        cloudAccounts: [createMockCloudAccount()],
+        name: "dev",
+        prefix: "dx",
+    },
+    github: {
+        owner: "pagopa",
+        repo: "dx",
+    },
+    init: {
+        cloudAccountsToInitialize: [],
+        terraformBackend: {
+            cloudAccount: createMockCloudAccount(),
+        },
+    },
+    tags: {},
+    workspace: {
+        domain: "test",
+    },
+    ...overrides,
+});
+describe("initCloudAccounts", () => {
+    it("should initialize all cloud accounts in cloudAccountsToInitialize", async () => {
+        const cloudAccount1 = createMockCloudAccount({ id: "account-1" });
+        const cloudAccount2 = createMockCloudAccount({ id: "account-2" });
+        const initializeMock = vi.fn().mockResolvedValue(undefined);
+        const mockService = createMockCloudAccountService({
+            initialize: initializeMock,
+        });
+        const payload = createMockPayload({
+            env: {
+                cloudAccounts: [],
+                name: "prod",
+                prefix: "io",
+            },
+            init: {
+                cloudAccountsToInitialize: [cloudAccount1, cloudAccount2],
+                terraformBackend: {
+                    cloudAccount: createMockCloudAccount(),
+                },
+            },
+        });
+        await initCloudAccounts(payload, mockService);
+        expect(initializeMock).toHaveBeenCalledTimes(2);
+        expect(initializeMock).toHaveBeenCalledWith(cloudAccount1, expect.objectContaining({ name: "prod", prefix: "io" }), {});
+        expect(initializeMock).toHaveBeenCalledWith(cloudAccount2, expect.objectContaining({ name: "prod", prefix: "io" }), {});
+    });
+    it("should not call initialize when cloudAccountsToInitialize is empty", async () => {
+        const initializeMock = vi.fn().mockResolvedValue(undefined);
+        const mockService = createMockCloudAccountService({
+            initialize: initializeMock,
+        });
+        const payload = createMockPayload({
+            init: {
+                cloudAccountsToInitialize: [],
+                terraformBackend: {
+                    cloudAccount: createMockCloudAccount(),
+                },
+            },
+        });
+        await initCloudAccounts(payload, mockService);
+        expect(initializeMock).not.toHaveBeenCalled();
+    });
+    it("should not call initialize when payload.init is undefined", async () => {
+        const initializeMock = vi.fn().mockResolvedValue(undefined);
+        const mockService = createMockCloudAccountService({
+            initialize: initializeMock,
+        });
+        const payload = createMockPayload({
+            init: undefined,
+        });
+        await initCloudAccounts(payload, mockService);
+        expect(initializeMock).not.toHaveBeenCalled();
+    });
+    it("should use prefix and environment name from payload.env", async () => {
+        const cloudAccount = createMockCloudAccount();
+        const initializeMock = vi.fn().mockResolvedValue(undefined);
+        const mockService = createMockCloudAccountService({
+            initialize: initializeMock,
+        });
+        const payload = createMockPayload({
+            env: {
+                cloudAccounts: [],
+                name: "uat",
+                prefix: "pagopa",
+            },
+            init: {
+                cloudAccountsToInitialize: [cloudAccount],
+                terraformBackend: {
+                    cloudAccount: createMockCloudAccount(),
+                },
+            },
+        });
+        await initCloudAccounts(payload, mockService);
+        expect(initializeMock).toHaveBeenCalledWith(cloudAccount, expect.objectContaining({ name: "uat", prefix: "pagopa" }), {});
+    });
+});

package/dist/adapters/plop/actions/__tests__/provision-terraform-backend.test.d.ts

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

package/dist/adapters/plop/actions/__tests__/provision-terraform-backend.test.js

@@ -0,0 +1,116 @@
+import { describe, expect, it, vi } from "vitest";
+import { provisionTerraformBackend } from "../provision-terraform-backend.js";
+const createMockCloudAccountService = (overrides = {}) => ({
+    getTerraformBackend: vi.fn().mockResolvedValue(undefined),
+    hasUserPermissionToInitialize: vi.fn().mockResolvedValue(true),
+    initialize: vi.fn().mockResolvedValue(undefined),
+    isInitialized: vi.fn().mockResolvedValue(true),
+    provisionTerraformBackend: vi.fn().mockResolvedValue(undefined),
+    ...overrides,
+});
+const createMockCloudAccount = (overrides = {}) => ({
+    csp: "azure",
+    defaultLocation: "westeurope",
+    displayName: "Test-Account",
+    id: "test-subscription-id",
+    ...overrides,
+});
+const createMockTerraformBackend = (overrides = {}) => ({
+    resourceGroupName: "dx-d-itn-tf-rg",
+    storageAccountName: "dxditntfst",
+    subscriptionId: "00000000-0000-0000-0000-000000000000",
+    type: "azurerm",
+    ...overrides,
+});
+const createMockPayload = (overrides = {}) => ({
+    env: {
+        cloudAccounts: [createMockCloudAccount()],
+        name: "dev",
+        prefix: "dx",
+    },
+    github: {
+        owner: "pagopa",
+        repo: "dx",
+    },
+    init: {
+        cloudAccountsToInitialize: [],
+        terraformBackend: {
+            cloudAccount: createMockCloudAccount(),
+        },
+    },
+    tags: {},
+    workspace: {
+        domain: "test",
+    },
+    ...overrides,
+});
+describe("provisionTerraformBackend", () => {
+    it("should provision terraform backend and return it", async () => {
+        const mockBackend = createMockTerraformBackend();
+        const provisionMock = vi.fn().mockResolvedValue(mockBackend);
+        const mockService = createMockCloudAccountService({
+            provisionTerraformBackend: provisionMock,
+        });
+        const payload = createMockPayload();
+        const result = await provisionTerraformBackend(payload, mockService);
+        expect(result).toEqual(mockBackend);
+    });
+    it("should call provisionTerraformBackend with correct parameters", async () => {
+        const cloudAccount = createMockCloudAccount({ id: "my-subscription" });
+        const provisionMock = vi
+            .fn()
+            .mockResolvedValue(createMockTerraformBackend());
+        const mockService = createMockCloudAccountService({
+            provisionTerraformBackend: provisionMock,
+        });
+        const payload = createMockPayload({
+            env: {
+                cloudAccounts: [cloudAccount],
+                name: "prod",
+                prefix: "io",
+            },
+            init: {
+                cloudAccountsToInitialize: [],
+                terraformBackend: {
+                    cloudAccount,
+                },
+            },
+        });
+        await provisionTerraformBackend(payload, mockService);
+        expect(provisionMock).toHaveBeenCalledWith(cloudAccount, expect.objectContaining({ name: "prod", prefix: "io" }), {});
+    });
+    it("should throw an error when payload.init is undefined", async () => {
+        const mockService = createMockCloudAccountService();
+        const payload = createMockPayload({
+            init: undefined,
+        });
+        await expect(provisionTerraformBackend(payload, mockService)).rejects.toThrow("This action requires initialization data in the payload");
+    });
+    it("should use the terraformBackend cloudAccount from init", async () => {
+        const envCloudAccount = createMockCloudAccount({ id: "env-account" });
+        const backendCloudAccount = createMockCloudAccount({
+            id: "backend-account",
+        });
+        const provisionMock = vi
+            .fn()
+            .mockResolvedValue(createMockTerraformBackend());
+        const mockService = createMockCloudAccountService({
+            provisionTerraformBackend: provisionMock,
+        });
+        const payload = createMockPayload({
+            env: {
+                cloudAccounts: [envCloudAccount],
+                name: "uat",
+                prefix: "dx",
+            },
+            init: {
+                cloudAccountsToInitialize: [],
+                terraformBackend: {
+                    cloudAccount: backendCloudAccount,
+                },
+            },
+        });
+        await provisionTerraformBackend(payload, mockService);
+        expect(provisionMock).toHaveBeenCalledWith(backendCloudAccount, expect.objectContaining({ name: "uat", prefix: "dx" }), {});
+    });
+});

package/dist/adapters/plop/actions/fetch-github-release.d.ts

@@ -0,0 +1,12 @@
+import { type NodePlopAPI } from "node-plop";
+import { Octokit } from "octokit";
+import { z } from "zod/v4";
+export declare const semverFetchOptionsSchema: z.ZodObject<{
+    repository: z.ZodObject<{
+        name: z.ZodString;
+        owner: z.ZodString;
+    }, z.core.$strip>;
+    resultKey: z.ZodString;
+}, z.core.$strip>;
+export type SemverFetchOptions = z.infer<typeof semverFetchOptionsSchema>;
+export default function (plop: NodePlopAPI, octokit: Octokit): void;

package/dist/adapters/plop/actions/fetch-github-release.js

@@ -0,0 +1,20 @@
+import { z } from "zod/v4";
+import { fetchLatestRelease } from "../../octokit/index.js";
+import { fetchLatestSemver } from "./semver.js";
+export const semverFetchOptionsSchema = z.object({
+    repository: z.object({
+        name: z.string(),
+        owner: z.string(),
+    }),
+    resultKey: z.string(),
+});
+export default function (plop, octokit) {
+    plop.setActionType("fetchGithubRelease", async (data, ctx) => {
+        const { repository, resultKey } = semverFetchOptionsSchema.parse(ctx);
+        return fetchLatestSemver(() => fetchLatestRelease({
+            client: octokit,
+            owner: repository.owner,
+            repo: repository.name,
+        }), data, resultKey);
+    });
+}

package/dist/adapters/plop/actions/get-node-version.d.ts

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

package/dist/adapters/plop/actions/get-node-version.js

@@ -0,0 +1,9 @@
+import { ResultAsync } from "neverthrow";
+import { getLatestByCodename } from "../../node/release.js";
+import { fetchLatestSemver } from "./semver.js";
+const fetchNodeVersion = () => ResultAsync.fromPromise(
+// Jod is the codename for Node.js 22 LTS
+getLatestByCodename("Jod"), (e) => new Error("Failed to fetch Node.js releases", { cause: e }));
+export default function (plop) {
+    plop.setActionType("getNodeVersion", async (data) => fetchLatestSemver(fetchNodeVersion, data, "nodeVersion"));
+}

package/dist/adapters/plop/actions/get-terraform-backend.d.ts

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

package/dist/adapters/plop/actions/get-terraform-backend.js

@@ -0,0 +1,17 @@
+import { getLogger } from "@logtape/logtape";
+import { getTerraformBackend } from "../../../domain/environment.js";
+import { payloadSchema } from "../generators/environment/prompts.js";
+export default function (plop, cloudAccountService) {
+    plop.setActionType("getTerraformBackend", async (data) => {
+        const logger = getLogger(["gen", "env"]);
+        if (data.terraform?.backend) {
+            return "Terraform Backend Retrieved";
+        }
+        const payload = payloadSchema.parse(data);
+        const backend = await getTerraformBackend(cloudAccountService, payload.env);
+        logger.debug("Retrieved terraform backend {backend}", { backend });
+        data.terraform ??= {};
+        data.terraform.backend = backend;
+        return "Terraform Backend Retrieved";
+    });
+}

package/dist/adapters/plop/actions/init-cloud-accounts.d.ts

@@ -0,0 +1,5 @@
+import { type NodePlopAPI } from "node-plop";
+import { CloudAccountService } from "../../../domain/cloud-account.js";
+import { type Payload } from "../generators/environment/prompts.js";
+export declare const initCloudAccounts: (payload: Payload, cloudAccountService: CloudAccountService) => Promise<void>;
+export default function (plop: NodePlopAPI, cloudAccountService: CloudAccountService): void;

package/dist/adapters/plop/actions/init-cloud-accounts.js

@@ -0,0 +1,13 @@
+import { payloadSchema, } from "../generators/environment/prompts.js";
+export const initCloudAccounts = async (payload, cloudAccountService) => {
+    if (payload.init) {
+        await Promise.all(payload.init.cloudAccountsToInitialize.map((cloudAccount) => cloudAccountService.initialize(cloudAccount, payload.env, payload.tags)));
+    }
+};
+export default function (plop, cloudAccountService) {
+    plop.setActionType("initCloudAccounts", async (data) => {
+        const payload = payloadSchema.parse(data);
+        await initCloudAccounts(payload, cloudAccountService);
+        return "Cloud Accounts Initialized";
+    });
+}

package/dist/adapters/plop/actions/provision-terraform-backend.d.ts

@@ -0,0 +1,10 @@
+import { type NodePlopAPI } from "node-plop";
+import { CloudAccountService } from "../../../domain/cloud-account.js";
+import { type Payload } from "../generators/environment/prompts.js";
+export declare const provisionTerraformBackend: (payload: Payload, cloudAccountService: CloudAccountService) => Promise<{
+    resourceGroupName: string;
+    storageAccountName: string;
+    subscriptionId: string;
+    type: "azurerm";
+}>;
+export default function (plop: NodePlopAPI, cloudAccountService: CloudAccountService): void;

package/dist/adapters/plop/actions/provision-terraform-backend.js

@@ -0,0 +1,16 @@
+import * as assert from "node:assert/strict";
+import { payloadSchema, } from "../generators/environment/prompts.js";
+export const provisionTerraformBackend = async (payload, cloudAccountService) => {
+    assert.ok(payload.init, "This action requires initialization data in the payload");
+    assert.ok(payload.init.terraformBackend, "This action requires terraformBackend data in the payload");
+    const terraformBackend = await cloudAccountService.provisionTerraformBackend(payload.init.terraformBackend.cloudAccount, payload.env, payload.tags);
+    return terraformBackend;
+};
+export default function (plop, cloudAccountService) {
+    plop.setActionType("provisionTerraformBackend", async (data) => {
+        const payload = payloadSchema.parse(data);
+        data.terraform ??= {};
+        data.terraform.backend = await provisionTerraformBackend(payload, cloudAccountService);
+        return "Terraform Backend Provisioned";
+    });
+}

package/dist/adapters/plop/actions/semver.d.ts

@@ -0,0 +1,19 @@
+import { ResultAsync } from "neverthrow";
+import { SemVer } from "semver";
+export type FetchSemverFn = () => ResultAsync<null | SemVer, Error>;
+/**
+ * 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 declare const fetchLatestSemver: (fetchSemverFn: FetchSemverFn, answers: Record<string, unknown>, answerKey: string, semverFormatFn?: (semver: SemVer) => string) => Promise<string>;