@pagopa/dx-cli 0.23.0 → 0.23.1

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

@@ -1,171 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { initCloudAccounts } from "../init-cloud-accounts.js";
-const createMockGitHubService = () => ({
-    createBranch: vi.fn(),
-    createOrUpdateEnvironmentSecret: vi.fn().mockResolvedValue(undefined),
-    createPullRequest: vi.fn(),
-    getFileContent: vi.fn(),
-    getRepository: vi.fn(),
-    updateFile: vi.fn(),
-});
-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: [],
-        runnerAppCredentials: {
-            clientId: "test-app-client-id",
-            id: "test-app-id",
-            installationId: "test-installation-id",
-            key: "test-private-key",
-        },
-        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],
-                runnerAppCredentials: {
-                    clientId: "test-app-client-id",
-                    id: "test-app-id",
-                    installationId: "test-installation-id",
-                    key: "test-private-key",
-                },
-                terraformBackend: {
-                    cloudAccount: createMockCloudAccount(),
-                },
-            },
-        });
-        await initCloudAccounts(payload, mockService, createMockGitHubService());
-        expect(initializeMock).toHaveBeenCalledTimes(2);
-        expect(initializeMock).toHaveBeenCalledWith(cloudAccount1, expect.objectContaining({ name: "prod", prefix: "io" }), {
-            clientId: "test-app-client-id",
-            id: "test-app-id",
-            installationId: "test-installation-id",
-            key: "test-private-key",
-        }, {
-            owner: "pagopa",
-            repo: "dx",
-        }, expect.any(Object), {});
-        expect(initializeMock).toHaveBeenCalledWith(cloudAccount2, expect.objectContaining({ name: "prod", prefix: "io" }), {
-            clientId: "test-app-client-id",
-            id: "test-app-id",
-            installationId: "test-installation-id",
-            key: "test-private-key",
-        }, {
-            owner: "pagopa",
-            repo: "dx",
-        }, expect.any(Object), {});
-    });
-    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: [],
-                runnerAppCredentials: {
-                    clientId: "test-app-client-id",
-                    id: "test-app-id",
-                    installationId: "test-installation-id",
-                    key: "test-private-key",
-                },
-                terraformBackend: {
-                    cloudAccount: createMockCloudAccount(),
-                },
-            },
-        });
-        await initCloudAccounts(payload, mockService, createMockGitHubService());
-        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, createMockGitHubService());
-        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],
-                runnerAppCredentials: {
-                    clientId: "test-app-client-id",
-                    id: "test-app-id",
-                    installationId: "test-installation-id",
-                    key: "test-private-key",
-                },
-                terraformBackend: {
-                    cloudAccount: createMockCloudAccount(),
-                },
-            },
-        });
-        await initCloudAccounts(payload, mockService, createMockGitHubService());
-        expect(initializeMock).toHaveBeenCalledWith(cloudAccount, expect.objectContaining({ name: "uat", prefix: "pagopa" }), {
-            clientId: "test-app-client-id",
-            id: "test-app-id",
-            installationId: "test-installation-id",
-            key: "test-private-key",
-        }, {
-            owner: "pagopa",
-            repo: "dx",
-        }, expect.any(Object), {});
-    });
-});

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

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

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

@@ -1,134 +0,0 @@
-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: [],
-        runnerAppCredentials: {
-            clientId: "test-app-client-id",
-            id: "test-app-id",
-            installationId: "test-installation-id",
-            key: "test-private-key",
-        },
-        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: [],
-                runnerAppCredentials: {
-                    clientId: "test-app-client-id",
-                    id: "test-app-id",
-                    installationId: "test-installation-id",
-                    key: "test-private-key",
-                },
-                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: [],
-                runnerAppCredentials: {
-                    clientId: "test-app-client-id",
-                    id: "test-app-id",
-                    installationId: "test-installation-id",
-                    key: "test-private-key",
-                },
-                terraformBackend: {
-                    cloudAccount: backendCloudAccount,
-                },
-            },
-        });
-        await provisionTerraformBackend(payload, mockService);
-        expect(provisionMock).toHaveBeenCalledWith(backendCloudAccount, expect.objectContaining({ name: "uat", prefix: "dx" }), {});
-    });
-});

package/dist/adapters/plop/generators/__tests__/temp-dir.d.ts

@@ -1,2 +0,0 @@
-export declare const cleanupTempDir: (tmpDir: string) => Promise<void>;
-export declare const readGeneratedFiles: (rootDir: string, filePaths: readonly string[]) => Promise<Record<string, string>>;

package/dist/adapters/plop/generators/__tests__/temp-dir.js

@@ -1,13 +0,0 @@
-/**
- * Temp directory helpers for Plop generator integration tests.
- */
-import fs from "node:fs/promises";
-import path from "node:path";
-export const cleanupTempDir = async (tmpDir) => {
-    await fs.rm(tmpDir, { force: true, recursive: true });
-};
-const readGeneratedFile = async (rootDir, filePath) => [
-    filePath,
-    await fs.readFile(path.join(rootDir, filePath), "utf-8"),
-];
-export const readGeneratedFiles = async (rootDir, filePaths) => Object.fromEntries(await Promise.all(filePaths.map((filePath) => readGeneratedFile(rootDir, filePath))));

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

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

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

@@ -1,92 +0,0 @@
-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",
-        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],
-            runnerAppCredentials: {
-                clientId: "test-app-client-id",
-                id: "test-app-id",
-                installationId: "test-installation-id",
-                key: "test-private-key",
-            },
-            terraformBackend: {
-                cloudAccount,
-            },
-        };
-    }
-    return payload;
-};
-describe("actions", () => {
-    test.each([
-        {
-            payload: getPayload(true),
-        },
-        {
-            payload: getPayload(false),
-        },
-    ])("correct order of actions", ({ payload }) => {
-        const actionsOrder = [
-            "getTerraformBackend",
-            "addMany",
-            "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);
-    });
-    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__/generation.test.d.ts

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

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

@@ -1,213 +0,0 @@
-import nodePlop from "node-plop";
-/**
- * Contract tests for the environment generator.
- *
- * They generate real files in a temp directory while asserting only
- * generator-specific behavior: which domain actions run for a given
- * generator state and which high-value values are materialized into
- * the generated infrastructure files.
- */
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";
-import setGetTerraformBackend from "../../../actions/get-terraform-backend.js";
-import setInitCloudAccountsAction from "../../../actions/init-cloud-accounts.js";
-import setProvisionTerraformBackendAction from "../../../actions/provision-terraform-backend.js";
-import setEnvShortHelper from "../../../helpers/env-short.js";
-import setEqHelper from "../../../helpers/eq.js";
-import setResourcePrefixHelper from "../../../helpers/resource-prefix.js";
-import setTerraformStateKeyHelper from "../../../helpers/terraform-state-key.js";
-import { resolveTemplatesPath } from "../../../templates-path.js";
-import { cleanupTempDir, readGeneratedFiles, } from "../../__tests__/temp-dir.js";
-import getActions from "../actions.js";
-import { PLOP_ENVIRONMENT_GENERATOR_NAME } from "../index.js";
-vi.mock("../../../../terraform/fmt.js", () => ({
-    formatTerraformCode: vi.fn((content) => content),
-}));
-/**
- * Register helpers and stub action types for the environment generator.
- * Cloud-service action types are registered with DI mock objects.
- */
-const registerEnvironmentSetup = (plop, mockCloudAccountService, mockGitHubService) => {
-    setEnvShortHelper(plop);
-    setResourcePrefixHelper(plop);
-    setEqHelper(plop);
-    setTerraformStateKeyHelper(plop);
-    setGetTerraformBackend(plop, mockCloudAccountService);
-    setProvisionTerraformBackendAction(plop, mockCloudAccountService);
-    setInitCloudAccountsAction(plop, mockCloudAccountService, mockGitHubService);
-};
-const mockTerraformBackend = {
-    resourceGroupName: "dx-d-itn-tf-rg",
-    storageAccountName: "dxditntfst",
-    subscriptionId: "00000000-0000-0000-0000-000000000000",
-    type: "azurerm",
-};
-const createMockCloudAccountService = (backend, isInitialized) => ({
-    getTerraformBackend: vi.fn().mockResolvedValue(backend),
-    hasUserPermissionToInitialize: vi.fn().mockResolvedValue(true),
-    initialize: vi.fn().mockResolvedValue(undefined),
-    isInitialized: vi.fn().mockResolvedValue(isInitialized),
-    provisionTerraformBackend: vi.fn().mockResolvedValue(backend),
-});
-const createMockGitHubService = () => ({
-    createBranch: vi.fn().mockResolvedValue(undefined),
-    createOrUpdateEnvironmentSecret: vi.fn().mockResolvedValue(undefined),
-    createPullRequest: vi.fn().mockResolvedValue(undefined),
-    getFileContent: vi.fn().mockResolvedValue(undefined),
-    getRepository: vi.fn().mockResolvedValue(undefined),
-    updateFile: vi.fn().mockResolvedValue(undefined),
-});
-const runEnvironmentGenerator = async ({ mockCloudAccountService, mockGitHubService, payload, tmpDirPrefix, }) => {
-    const originalCwd = process.cwd();
-    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), tmpDirPrefix));
-    process.chdir(tmpDir);
-    const plop = await nodePlop();
-    registerEnvironmentSetup(plop, mockCloudAccountService, mockGitHubService);
-    plop.setGenerator(PLOP_ENVIRONMENT_GENERATOR_NAME, {
-        actions: getActions(resolveTemplatesPath("environment")),
-        description: "Generate a new deployment environment",
-        prompts: [],
-    });
-    const generator = plop.getGenerator(PLOP_ENVIRONMENT_GENERATOR_NAME);
-    const result = await generator.runActions(payload);
-    const realFailures = result.failures.filter((f) => f.error !== "Aborted due to previous action failure");
-    if (realFailures.length > 0) {
-        const summary = realFailures.map((f) => `${f.type}: ${f.error}`).join("\n");
-        throw new Error(`Generator failed:\n${summary}`);
-    }
-    return { originalCwd, tmpDir };
-};
-describe("environment generator — file generation (no init)", () => {
-    let tmpDir;
-    let originalCwd;
-    const payload = {
-        env: {
-            cloudAccounts: [
-                {
-                    csp: "azure",
-                    defaultLocation: "italynorth",
-                    displayName: "DEV-DX",
-                    id: "sub-dev-123",
-                },
-            ],
-            name: "dev",
-            prefix: "dx",
-        },
-        github: {
-            owner: "pagopa",
-            repo: "my-project",
-        },
-        tags: {
-            BusinessUnit: "Platform",
-            CostCenter: "TS000",
-            ManagementTeam: "Engineering",
-        },
-        workspace: {
-            domain: "payments",
-        },
-    };
-    const mockCloudAccountService = createMockCloudAccountService(mockTerraformBackend, true);
-    const mockGitHubService = createMockGitHubService();
-    beforeAll(async () => {
-        ({ originalCwd, tmpDir } = await runEnvironmentGenerator({
-            mockCloudAccountService,
-            mockGitHubService,
-            payload,
-            tmpDirPrefix: "dx-cli-env-test-",
-        }));
-    });
-    afterAll(async () => {
-        process.chdir(originalCwd);
-        await cleanupTempDir(tmpDir);
-    });
-    it("materializes bootstrapper files from payload and backend state", async () => {
-        const generatedFiles = await readGeneratedFiles(tmpDir, [
-            `.github/workflows/_release-terraform-apply-bootstrapper-${payload.env.name}.yaml`,
-            `infra/bootstrapper/${payload.env.name}/main.tf`,
-            `infra/bootstrapper/${payload.env.name}/providers.tf`,
-            `infra/bootstrapper/${payload.env.name}/backend.tf`,
-            `infra/bootstrapper/${payload.env.name}/locals.tf`,
-        ]);
-        expect(generatedFiles).toMatchSnapshot();
-    });
-    it("skips init-only side effects and core files when init is absent", async () => {
-        const corePath = path.join(tmpDir, "infra", "core", payload.env.name);
-        expect(mockCloudAccountService.getTerraformBackend).toHaveBeenCalledWith(payload.env.cloudAccounts[0].id, payload.env);
-        expect(mockCloudAccountService.initialize).not.toHaveBeenCalled();
-        expect(mockCloudAccountService.provisionTerraformBackend).not.toHaveBeenCalled();
-        await expect(fs.stat(corePath)).rejects.toThrow();
-    });
-});
-describe("environment generator — file generation (with init)", () => {
-    let tmpDir;
-    let originalCwd;
-    const cloudAccount = {
-        csp: "azure",
-        defaultLocation: "italynorth",
-        displayName: "DEV-DX",
-        id: "sub-dev-123",
-    };
-    const payload = {
-        env: {
-            cloudAccounts: [cloudAccount],
-            name: "dev",
-            prefix: "dx",
-        },
-        github: {
-            owner: "pagopa",
-            repo: "my-project",
-        },
-        init: {
-            cloudAccountsToInitialize: [cloudAccount],
-            runnerAppCredentials: {
-                clientId: "test-app-client-id",
-                id: "test-app-id",
-                installationId: "test-installation-id",
-                key: "test-private-key",
-            },
-            terraformBackend: {
-                cloudAccount,
-            },
-        },
-        tags: {
-            BusinessUnit: "Platform",
-            CostCenter: "TS000",
-            ManagementTeam: "Engineering",
-        },
-        workspace: {
-            domain: "payments",
-        },
-    };
-    const mockCloudAccountService = createMockCloudAccountService(mockTerraformBackend, false);
-    const mockGitHubService = createMockGitHubService();
-    beforeAll(async () => {
-        ({ originalCwd, tmpDir } = await runEnvironmentGenerator({
-            mockCloudAccountService,
-            mockGitHubService,
-            payload,
-            tmpDirPrefix: "dx-cli-env-init-test-",
-        }));
-    });
-    afterAll(async () => {
-        process.chdir(originalCwd);
-        await cleanupTempDir(tmpDir);
-    });
-    it("runs init-specific actions when init is provided", () => {
-        expect(mockCloudAccountService.initialize).toHaveBeenCalledWith(cloudAccount, payload.env, 
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        payload.init.runnerAppCredentials, payload.github, mockGitHubService, payload.tags);
-        expect(mockCloudAccountService.provisionTerraformBackend).toHaveBeenCalledWith(cloudAccount, payload.env, payload.tags);
-        expect(mockCloudAccountService.getTerraformBackend).not.toHaveBeenCalled();
-    });
-    it("materializes init-specific infrastructure files", async () => {
-        const generatedFiles = await readGeneratedFiles(tmpDir, [
-            `infra/core/${payload.env.name}/main.tf`,
-            `infra/core/${payload.env.name}/providers.tf`,
-            `infra/core/${payload.env.name}/backend.tf`,
-            `infra/bootstrapper/${payload.env.name}/main.tf`,
-        ]);
-        expect(generatedFiles).toMatchSnapshot();
-    });
-});

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

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