@pagopa/dx-cli 0.15.2 → 0.15.4

package/dist/domain/__tests__/environment.test.js

@@ -0,0 +1,282 @@
+import { describe, expect, it, vi } from "vitest";
+import { getInitializationStatus, getTerraformBackend, hasUserPermissionToInitialize, } from "../environment.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-account-id",
+    ...overrides,
+});
+const createMockEnvironment = (overrides = {}) => ({
+    cloudAccounts: [createMockCloudAccount()],
+    name: "dev",
+    prefix: "dx",
+    ...overrides,
+});
+const createMockTerraformBackend = (overrides = {}) => ({
+    resourceGroupName: "dx-d-itn-tf-rg",
+    storageAccountName: "dxditntfst",
+    subscriptionId: "00000000-0000-0000-0000-000000000000",
+    type: "azurerm",
+    ...overrides,
+});
+describe("getInitializationStatus", () => {
+    it("should return initialized true when all cloud accounts are initialized and backend exists", async () => {
+        const mockBackend = createMockTerraformBackend();
+        const mockService = createMockCloudAccountService({
+            getTerraformBackend: vi.fn().mockResolvedValue(mockBackend),
+            isInitialized: vi.fn().mockResolvedValue(true),
+        });
+        const environment = createMockEnvironment();
+        const result = await getInitializationStatus(mockService, environment);
+        expect(result).toEqual({ initialized: true });
+    });
+    it("should return CLOUD_ACCOUNT_NOT_INITIALIZED issue when cloud account is not initialized", async () => {
+        const cloudAccount = createMockCloudAccount({ id: "uninitialized-id" });
+        const mockBackend = createMockTerraformBackend();
+        const mockService = createMockCloudAccountService({
+            getTerraformBackend: vi.fn().mockResolvedValue(mockBackend),
+            isInitialized: vi.fn().mockResolvedValue(false),
+        });
+        const environment = createMockEnvironment({
+            cloudAccounts: [cloudAccount],
+        });
+        const result = await getInitializationStatus(mockService, environment);
+        expect(result).toEqual({
+            initialized: false,
+            issues: [
+                {
+                    cloudAccount,
+                    type: "CLOUD_ACCOUNT_NOT_INITIALIZED",
+                },
+            ],
+        });
+    });
+    it("should return MISSING_REMOTE_BACKEND issue when terraform backend is not found", async () => {
+        const mockService = createMockCloudAccountService({
+            getTerraformBackend: vi.fn().mockResolvedValue(undefined),
+            isInitialized: vi.fn().mockResolvedValue(true),
+        });
+        const environment = createMockEnvironment();
+        const result = await getInitializationStatus(mockService, environment);
+        expect(result).toEqual({
+            initialized: false,
+            issues: [
+                {
+                    type: "MISSING_REMOTE_BACKEND",
+                },
+            ],
+        });
+    });
+    it("should return multiple issues when both cloud account is not initialized and backend is missing", async () => {
+        const cloudAccount = createMockCloudAccount();
+        const mockService = createMockCloudAccountService({
+            getTerraformBackend: vi.fn().mockResolvedValue(undefined),
+            isInitialized: vi.fn().mockResolvedValue(false),
+        });
+        const environment = createMockEnvironment({
+            cloudAccounts: [cloudAccount],
+        });
+        const result = await getInitializationStatus(mockService, environment);
+        expect(result).toEqual({
+            initialized: false,
+            issues: [
+                {
+                    cloudAccount,
+                    type: "CLOUD_ACCOUNT_NOT_INITIALIZED",
+                },
+                {
+                    type: "MISSING_REMOTE_BACKEND",
+                },
+            ],
+        });
+    });
+    it("should check initialization for each cloud account with correct parameters", async () => {
+        const cloudAccount1 = createMockCloudAccount({ id: "account-1" });
+        const cloudAccount2 = createMockCloudAccount({ id: "account-2" });
+        const mockBackend = createMockTerraformBackend();
+        const isInitializedMock = vi.fn().mockResolvedValue(true);
+        const mockService = createMockCloudAccountService({
+            getTerraformBackend: vi.fn().mockResolvedValue(mockBackend),
+            isInitialized: isInitializedMock,
+        });
+        const environment = createMockEnvironment({
+            cloudAccounts: [cloudAccount1, cloudAccount2],
+            name: "prod",
+            prefix: "io",
+        });
+        await getInitializationStatus(mockService, environment);
+        expect(isInitializedMock).toHaveBeenCalledTimes(2);
+        expect(isInitializedMock).toHaveBeenCalledWith("account-1", expect.objectContaining({
+            name: "prod",
+            prefix: "io",
+        }));
+        expect(isInitializedMock).toHaveBeenCalledWith("account-2", expect.objectContaining({
+            name: "prod",
+            prefix: "io",
+        }));
+    });
+    it("should return issues for multiple uninitialized cloud accounts", async () => {
+        const cloudAccount1 = createMockCloudAccount({ id: "account-1" });
+        const cloudAccount2 = createMockCloudAccount({ id: "account-2" });
+        const mockBackend = createMockTerraformBackend();
+        const mockService = createMockCloudAccountService({
+            getTerraformBackend: vi.fn().mockResolvedValue(mockBackend),
+            isInitialized: vi.fn().mockResolvedValue(false),
+        });
+        const environment = createMockEnvironment({
+            cloudAccounts: [cloudAccount1, cloudAccount2],
+        });
+        const result = await getInitializationStatus(mockService, environment);
+        expect(result).toEqual({
+            initialized: false,
+            issues: [
+                {
+                    cloudAccount: cloudAccount1,
+                    type: "CLOUD_ACCOUNT_NOT_INITIALIZED",
+                },
+                {
+                    cloudAccount: cloudAccount2,
+                    type: "CLOUD_ACCOUNT_NOT_INITIALIZED",
+                },
+            ],
+        });
+    });
+});
+describe("getTerraformBackend", () => {
+    it("should return the terraform backend when it exists", async () => {
+        const mockBackend = createMockTerraformBackend();
+        const mockService = createMockCloudAccountService({
+            getTerraformBackend: vi.fn().mockResolvedValue(mockBackend),
+        });
+        const environment = createMockEnvironment();
+        const result = await getTerraformBackend(mockService, environment);
+        expect(result).toEqual(mockBackend);
+    });
+    it("should return undefined when no terraform backend exists", async () => {
+        const mockService = createMockCloudAccountService({
+            getTerraformBackend: vi.fn().mockResolvedValue(undefined),
+        });
+        const environment = createMockEnvironment();
+        const result = await getTerraformBackend(mockService, environment);
+        expect(result).toBeUndefined();
+    });
+    it("should call getTerraformBackend with correct parameters", async () => {
+        const getTerraformBackendMock = vi.fn().mockResolvedValue(undefined);
+        const mockService = createMockCloudAccountService({
+            getTerraformBackend: getTerraformBackendMock,
+        });
+        const environment = createMockEnvironment({
+            cloudAccounts: [createMockCloudAccount({ id: "my-account" })],
+            name: "uat",
+            prefix: "io",
+        });
+        await getTerraformBackend(mockService, environment);
+        expect(getTerraformBackendMock).toHaveBeenCalledWith("my-account", expect.objectContaining({
+            name: "uat",
+            prefix: "io",
+        }));
+    });
+    it("should return the first backend found when multiple cloud accounts exist", async () => {
+        const mockBackend = createMockTerraformBackend({
+            storageAccountName: "firstaccountst",
+        });
+        const getTerraformBackendMock = vi.fn().mockResolvedValue(mockBackend);
+        const mockService = createMockCloudAccountService({
+            getTerraformBackend: getTerraformBackendMock,
+        });
+        const environment = createMockEnvironment({
+            cloudAccounts: [
+                createMockCloudAccount({ id: "account-1" }),
+                createMockCloudAccount({ id: "account-2" }),
+            ],
+        });
+        const result = await getTerraformBackend(mockService, environment);
+        expect(result).toEqual(mockBackend);
+        // Should only call for the first account due to early return
+        expect(getTerraformBackendMock).toHaveBeenCalledTimes(1);
+    });
+    it("should return undefined when environment has no cloud accounts", async () => {
+        const mockService = createMockCloudAccountService();
+        const environment = createMockEnvironment({
+            cloudAccounts: [],
+        });
+        const result = await getTerraformBackend(mockService, environment);
+        expect(result).toBeUndefined();
+    });
+});
+describe("hasUserPermissionToInitialize", () => {
+    it("should return true when all cloud accounts have permission", async () => {
+        const mockService = createMockCloudAccountService({
+            hasUserPermissionToInitialize: vi.fn().mockResolvedValue(true),
+        });
+        const environment = createMockEnvironment({
+            cloudAccounts: [
+                createMockCloudAccount({ id: "account-1" }),
+                createMockCloudAccount({ id: "account-2" }),
+            ],
+        });
+        const result = await hasUserPermissionToInitialize(mockService, environment);
+        expect(result).toBe(true);
+    });
+    it("should return false when any cloud account lacks permission", async () => {
+        const hasUserPermissionMock = vi
+            .fn()
+            .mockResolvedValueOnce(true)
+            .mockResolvedValueOnce(false);
+        const mockService = createMockCloudAccountService({
+            hasUserPermissionToInitialize: hasUserPermissionMock,
+        });
+        const environment = createMockEnvironment({
+            cloudAccounts: [
+                createMockCloudAccount({ id: "account-1" }),
+                createMockCloudAccount({ id: "account-2" }),
+            ],
+        });
+        const result = await hasUserPermissionToInitialize(mockService, environment);
+        expect(result).toBe(false);
+        expect(hasUserPermissionMock).toHaveBeenCalledTimes(2);
+    });
+    it("should short-circuit and return false on first unauthorized account", async () => {
+        const hasUserPermissionMock = vi.fn().mockResolvedValue(false);
+        const mockService = createMockCloudAccountService({
+            hasUserPermissionToInitialize: hasUserPermissionMock,
+        });
+        const environment = createMockEnvironment({
+            cloudAccounts: [
+                createMockCloudAccount({ id: "account-1" }),
+                createMockCloudAccount({ id: "account-2" }),
+                createMockCloudAccount({ id: "account-3" }),
+            ],
+        });
+        const result = await hasUserPermissionToInitialize(mockService, environment);
+        expect(result).toBe(false);
+        // Should only check the first account before short-circuiting
+        expect(hasUserPermissionMock).toHaveBeenCalledTimes(1);
+        expect(hasUserPermissionMock).toHaveBeenCalledWith("account-1");
+    });
+    it("should call service with correct cloud account IDs", async () => {
+        const hasUserPermissionMock = vi.fn().mockResolvedValue(true);
+        const mockService = createMockCloudAccountService({
+            hasUserPermissionToInitialize: hasUserPermissionMock,
+        });
+        const environment = createMockEnvironment({
+            cloudAccounts: [
+                createMockCloudAccount({ id: "account-a" }),
+                createMockCloudAccount({ id: "account-b" }),
+            ],
+        });
+        await hasUserPermissionToInitialize(mockService, environment);
+        expect(hasUserPermissionMock).toHaveBeenCalledTimes(2);
+        expect(hasUserPermissionMock).toHaveBeenNthCalledWith(1, "account-a");
+        expect(hasUserPermissionMock).toHaveBeenNthCalledWith(2, "account-b");
+    });
+});

package/dist/domain/__tests__/info.test.d.ts

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

package/dist/domain/__tests__/info.test.js

@@ -0,0 +1,77 @@
+import { errAsync, okAsync } from "neverthrow";
+import { describe, expect, it } from "vitest";
+import { getInfo } from "../info.js";
+import { makeMockDependencies, makeMockPackageJson, makeMockRepositoryRoot, } from "./data.js";
+describe("getInfo", () => {
+    describe("packageManager", () => {
+        it("should return default packageManager (npm) when packageManager is not detected", async () => {
+            const mockPackageJson = makeMockPackageJson({
+                packageManager: undefined,
+            });
+            const mockDependencies = makeMockDependencies();
+            const repositoryRoot = makeMockRepositoryRoot();
+            mockDependencies.repositoryReader.findRepositoryRoot.mockReturnValue(okAsync(repositoryRoot));
+            mockDependencies.packageJsonReader.readPackageJson.mockReturnValue(okAsync(mockPackageJson));
+            mockDependencies.repositoryReader.fileExists.mockReturnValue(okAsync(false));
+            mockDependencies.repositoryReader.readFile.mockReturnValue(okAsync("22.0.0"));
+            const result = await getInfo(mockDependencies)();
+            expect(result.packageManager).toStrictEqual("npm");
+            expect(mockDependencies.repositoryReader.fileExists).nthCalledWith(1, "a/repo/root/pnpm-lock.yaml");
+            expect(mockDependencies.repositoryReader.fileExists).nthCalledWith(2, "a/repo/root/yarn.lock");
+            expect(mockDependencies.repositoryReader.fileExists).nthCalledWith(3, "a/repo/root/package-lock.json");
+        });
+        it("should return yarn when yarn.lock is present", async () => {
+            const mockPackageJson = makeMockPackageJson({
+                packageManager: undefined,
+            });
+            const mockDependencies = makeMockDependencies();
+            mockDependencies.packageJsonReader.readPackageJson.mockReturnValue(okAsync(mockPackageJson));
+            mockDependencies.repositoryReader.fileExists
+                .mockReturnValueOnce(okAsync(false))
+                .mockReturnValueOnce(okAsync(true)); // yarn lock file exists
+            mockDependencies.repositoryReader.readFile.mockReturnValue(okAsync("22.0.0"));
+            const repositoryRoot = makeMockRepositoryRoot();
+            mockDependencies.repositoryReader.findRepositoryRoot.mockReturnValue(okAsync(repositoryRoot));
+            const result = await getInfo(mockDependencies)();
+            expect(result.packageManager).toStrictEqual("yarn");
+            expect(mockDependencies.repositoryReader.fileExists).nthCalledWith(1, "a/repo/root/pnpm-lock.yaml");
+            expect(mockDependencies.repositoryReader.fileExists).nthCalledWith(2, "a/repo/root/yarn.lock");
+            expect(mockDependencies.repositoryReader.fileExists).not.toHaveBeenCalledWith("a/repo/root/package-lock.json");
+        });
+    });
+    it("should return all info", async () => {
+        const mockPackageJson = makeMockPackageJson({
+            devDependencies: new Map([["turbo", "^2.5.0"]]),
+        });
+        const repositoryRoot = makeMockRepositoryRoot();
+        const mockDependencies = makeMockDependencies();
+        mockDependencies.repositoryReader.findRepositoryRoot.mockReturnValue(okAsync(repositoryRoot));
+        mockDependencies.packageJsonReader.readPackageJson.mockReturnValue(okAsync(mockPackageJson));
+        mockDependencies.repositoryReader.readFile
+            .mockReturnValueOnce(okAsync("\n22.0.0\n"))
+            .mockReturnValueOnce(okAsync("1.0.0\n"));
+        const result = await getInfo(mockDependencies)();
+        expect(result).toStrictEqual({
+            node: "22.0.0",
+            packageManager: "pnpm",
+            terraform: "1.0.0",
+            turbo: "^2.5.0",
+        });
+        expect(mockDependencies.repositoryReader.readFile).toHaveBeenCalledWith("a/repo/root/.node-version");
+        expect(mockDependencies.repositoryReader.readFile).toHaveBeenCalledWith("a/repo/root/.terraform-version");
+    });
+    it("should only required information", async () => {
+        const repositoryRoot = makeMockRepositoryRoot();
+        const mockDependencies = makeMockDependencies();
+        mockDependencies.repositoryReader.findRepositoryRoot.mockReturnValue(okAsync(repositoryRoot));
+        mockDependencies.packageJsonReader.readPackageJson.mockReturnValue(okAsync(makeMockPackageJson()));
+        mockDependencies.repositoryReader.readFile.mockReturnValue(errAsync(new Error("File not found")));
+        const result = await getInfo(mockDependencies)();
+        expect(result).toStrictEqual({
+            node: undefined,
+            packageManager: "pnpm",
+            terraform: undefined,
+            turbo: undefined,
+        });
+    });
+});

package/dist/domain/__tests__/package-json.test.d.ts

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

package/dist/domain/__tests__/package-json.test.js

@@ -0,0 +1,39 @@
+import { errAsync, ok, okAsync } from "neverthrow";
+import { describe, expect, it } from "vitest";
+import { checkMonorepoScripts } from "../package-json.js";
+import { makeMockDependencies, makeMockRepositoryRoot } from "./data.js";
+describe("checkMonorepoScripts", () => {
+    const repositoryRoot = makeMockRepositoryRoot();
+    it("should return error result when getScripts fails", async () => {
+        const deps = makeMockDependencies();
+        const errorMessage = "Oh No!";
+        deps.packageJsonReader.getScripts.mockReturnValueOnce(errAsync(new Error(errorMessage)));
+        const result = await checkMonorepoScripts(deps, repositoryRoot);
+        expect(result.isErr()).toBe(true);
+    });
+    it("should return ok result with successful validation when all required scripts are present", async () => {
+        const deps = makeMockDependencies();
+        const scripts = new Map()
+            .set("build", "eslint .")
+            .set("code-review", "eslint .");
+        deps.packageJsonReader.getScripts.mockReturnValueOnce(okAsync(scripts));
+        deps.packageJsonReader.getRootRequiredScripts.mockReturnValueOnce(new Map().set("code-review", "eslint ."));
+        const result = await checkMonorepoScripts(deps, repositoryRoot);
+        expect(result).toStrictEqual(ok({
+            checkName: "Monorepo Scripts",
+            isValid: true,
+            successMessage: "Monorepo scripts are correctly set up",
+        }));
+    });
+    it("should return ok result with failed validation when required scripts are missing", async () => {
+        const deps = makeMockDependencies();
+        deps.packageJsonReader.getScripts.mockReturnValueOnce(okAsync(new Map()));
+        deps.packageJsonReader.getRootRequiredScripts.mockReturnValueOnce(new Map().set("code-review", "eslint ."));
+        const result = await checkMonorepoScripts(deps, repositoryRoot);
+        expect(result).toStrictEqual(ok({
+            checkName: "Monorepo Scripts",
+            errorMessage: "Missing required scripts: code-review",
+            isValid: false,
+        }));
+    });
+});

package/dist/domain/__tests__/repository.test.d.ts

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

package/dist/domain/__tests__/repository.test.js

@@ -0,0 +1,101 @@
+import { errAsync, ok, okAsync } from "neverthrow";
+import { describe, expect, it } from "vitest";
+import { checkPreCommitConfig, checkTurboConfig } from "../repository.js";
+import { makeMockConfig, makeMockDependencies, makeMockRepositoryRoot, } from "./data.js";
+describe("checkPreCommitConfig", () => {
+    it("should return ok result with successful validation when .pre-commit-config.yaml exists", async () => {
+        const deps = makeMockDependencies();
+        const repositoryRoot = makeMockRepositoryRoot();
+        deps.repositoryReader.fileExists.mockReturnValueOnce(okAsync(true));
+        const result = await checkPreCommitConfig(deps, repositoryRoot);
+        expect(result).toStrictEqual(ok({
+            checkName: "Pre-commit Configuration",
+            isValid: true,
+            successMessage: "Pre-commit configuration is present in the repository root",
+        }));
+        expect(deps.repositoryReader.fileExists).toHaveBeenCalledWith("a/repo/root/.pre-commit-config.yaml");
+    });
+    it("should return ok result with failed validation when .pre-commit-config.yaml does not exist", async () => {
+        const deps = makeMockDependencies();
+        const repositoryRoot = makeMockRepositoryRoot();
+        const errorMessage = ".pre-commit-config.yaml not found in repository root. Make sure to have pre-commit configured for the repository.";
+        deps.repositoryReader.fileExists.mockReturnValueOnce(errAsync(new Error(errorMessage)));
+        const result = await checkPreCommitConfig(deps, repositoryRoot);
+        expect(result).toStrictEqual(ok({
+            checkName: "Pre-commit Configuration",
+            errorMessage,
+            isValid: false,
+        }));
+    });
+});
+describe("checkTurboConfig", () => {
+    const config = makeMockConfig();
+    const repositoryRoot = makeMockRepositoryRoot();
+    it("should return ok result with successful validation when turbo.json exists and turbo dependency is present", async () => {
+        const deps = makeMockDependencies();
+        deps.repositoryReader.fileExists.mockReturnValueOnce(okAsync(true));
+        deps.packageJsonReader.getDependencies.mockReturnValueOnce(okAsync(new Map().set("turbo", "^2.5.2")));
+        const result = await checkTurboConfig(deps, repositoryRoot, config);
+        expect(result).toStrictEqual(ok({
+            checkName: "Turbo Configuration",
+            isValid: true,
+            successMessage: "Turbo configuration is present in the monorepo root and turbo dependency is installed",
+        }));
+        expect(deps.repositoryReader.fileExists).toHaveBeenCalledWith("a/repo/root/turbo.json");
+    });
+    it("should return ok result with failed validation when turbo.json exists but turbo dependency is missing", async () => {
+        const deps = makeMockDependencies();
+        deps.repositoryReader.fileExists.mockReturnValueOnce(okAsync(true));
+        deps.packageJsonReader.getDependencies.mockReturnValueOnce(okAsync(new Map().set("eslint", "^8.0.0")));
+        const result = await checkTurboConfig(deps, repositoryRoot, config);
+        expect(result).toStrictEqual(ok({
+            checkName: "Turbo Configuration",
+            errorMessage: "Turbo dependency not found in devDependencies. Please add 'turbo' to your devDependencies.",
+            isValid: false,
+        }));
+    });
+    it("should return ok result with failed validation when turbo.json does not exist", async () => {
+        const deps = makeMockDependencies();
+        const errorMessage = "turbo.json not found in repository root. Make sure to have Turbo configured for the monorepo.";
+        deps.repositoryReader.fileExists.mockReturnValueOnce(errAsync(new Error(errorMessage)));
+        const result = await checkTurboConfig(deps, repositoryRoot, config);
+        expect(result).toStrictEqual(ok({
+            checkName: "Turbo Configuration",
+            errorMessage,
+            isValid: false,
+        }));
+    });
+    it("should return the error message when turbo is not listed in devDependencies", async () => {
+        const deps = makeMockDependencies();
+        deps.repositoryReader.fileExists.mockReturnValueOnce(okAsync(true));
+        deps.packageJsonReader.getDependencies.mockReturnValueOnce(okAsync(new Map().set("eslint", "^8.0.0")));
+        const result = await checkTurboConfig(deps, repositoryRoot, config);
+        expect(result).toStrictEqual(ok({
+            checkName: "Turbo Configuration",
+            errorMessage: "Turbo dependency not found in devDependencies. Please add 'turbo' to your devDependencies.",
+            isValid: false,
+        }));
+    });
+    it("should return the error message when turbo version is less than minimum", async () => {
+        const deps = makeMockDependencies();
+        deps.repositoryReader.fileExists.mockReturnValueOnce(okAsync(true));
+        deps.packageJsonReader.getDependencies.mockReturnValueOnce(okAsync(new Map().set("turbo", "1.0.0")));
+        const result = await checkTurboConfig(deps, repositoryRoot, config);
+        expect(result).toStrictEqual(ok({
+            checkName: "Turbo Configuration",
+            errorMessage: `Turbo version (1.0.0) is too low. Minimum required version is ${config.minVersions.turbo}.`,
+            isValid: false,
+        }));
+    });
+    it("should return the success message when turbo version is ok", async () => {
+        const deps = makeMockDependencies();
+        deps.repositoryReader.fileExists.mockReturnValueOnce(okAsync(true));
+        deps.packageJsonReader.getDependencies.mockReturnValueOnce(okAsync(new Map().set("turbo", config.minVersions.turbo)));
+        const result = await checkTurboConfig(deps, repositoryRoot, config);
+        expect(result).toStrictEqual(ok({
+            checkName: "Turbo Configuration",
+            isValid: true,
+            successMessage: "Turbo configuration is present in the monorepo root and turbo dependency is installed",
+        }));
+    });
+});

package/dist/domain/__tests__/workspace.test.d.ts

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

package/dist/domain/__tests__/workspace.test.js

@@ -0,0 +1,57 @@
+import { err, ok } from "neverthrow";
+import { describe, expect, it } from "vitest";
+import { checkWorkspaces, workspaceSchema } from "../workspace.js";
+import { makeMockDependencies } from "./data.js";
+describe("checkWorkspaces", () => {
+    const monorepoDir = "/path/to/monorepo";
+    const validWorkspaces = [
+        workspaceSchema.parse({
+            name: "workspace1",
+            path: "/path/to/workspace1",
+        }),
+        workspaceSchema.parse({
+            name: "workspace2",
+            path: "/path/to/workspace2",
+        }),
+    ];
+    it("should return the list of workspaces", async () => {
+        const deps = makeMockDependencies();
+        deps.repositoryReader.getWorkspaces.mockResolvedValueOnce(ok(validWorkspaces));
+        const result = await checkWorkspaces(deps, monorepoDir);
+        expect(result).toStrictEqual(ok({
+            checkName: "Workspaces",
+            isValid: true,
+            successMessage: "Found 2 workspaces",
+        }));
+    });
+    it("should return error when getWorkspaces fails", async () => {
+        const deps = makeMockDependencies();
+        deps.repositoryReader.getWorkspaces.mockResolvedValueOnce(err(new Error("Failed to get workspaces")));
+        const result = await checkWorkspaces(deps, monorepoDir);
+        expect(result).toStrictEqual(ok({
+            checkName: "Workspaces",
+            errorMessage: "Something is wrong with the workspaces configuration. If you need help, please contact the DevEx team.",
+            isValid: false,
+        }));
+    });
+    it("should return success when workspaces are found", async () => {
+        const deps = makeMockDependencies();
+        deps.repositoryReader.getWorkspaces.mockResolvedValueOnce(ok([validWorkspaces[0]]));
+        const result = await checkWorkspaces(deps, monorepoDir);
+        expect(result).toStrictEqual(ok({
+            checkName: "Workspaces",
+            isValid: true,
+            successMessage: "Found 1 workspace",
+        }));
+    });
+    it("should return error when no workspace configuration is found", async () => {
+        const deps = makeMockDependencies();
+        deps.repositoryReader.getWorkspaces.mockResolvedValueOnce(ok([]));
+        const result = await checkWorkspaces(deps, monorepoDir);
+        expect(result).toStrictEqual(ok({
+            checkName: "Workspaces",
+            errorMessage: "No workspace configuration found. Make sure to configure workspaces in pnpm-workspace.yaml.",
+            isValid: false,
+        }));
+    });
+});

package/dist/domain/cloud-account.d.ts

@@ -0,0 +1,28 @@
+import { z } from "zod/v4";
+import { type EnvironmentId } from "./environment.js";
+import { TerraformBackend } from "./remote-backend.js";
+export declare const cloudAccountSchema: z.ZodObject<{
+    csp: z.ZodDefault<z.ZodEnum<{
+        azure: "azure";
+    }>>;
+    defaultLocation: z.ZodString;
+    displayName: z.ZodString;
+    id: z.ZodString;
+}, z.core.$strip>;
+export type CloudAccount = z.infer<typeof cloudAccountSchema>;
+export type CloudAccountRepository = {
+    list(): Promise<CloudAccount[]>;
+};
+export type CloudAccountService = {
+    getTerraformBackend(cloudAccountId: CloudAccount["id"], environment: EnvironmentId): Promise<TerraformBackend | undefined>;
+    hasUserPermissionToInitialize(cloudAccountId: CloudAccount["id"]): Promise<boolean>;
+    initialize(cloudAccount: CloudAccount, environment: EnvironmentId, tags?: Record<string, string>): Promise<void>;
+    isInitialized(cloudAccountId: CloudAccount["id"], environment: EnvironmentId): Promise<boolean>;
+    provisionTerraformBackend(cloudAccount: CloudAccount, environment: EnvironmentId, tags?: Record<string, string>): Promise<TerraformBackend>;
+};
+export declare const cloudRegionSchema: z.ZodObject<{
+    displayName: z.ZodString;
+    name: z.ZodString;
+    short: z.ZodString;
+}, z.core.$strip>;
+export type CloudRegion = z.infer<typeof cloudRegionSchema>;

package/dist/domain/cloud-account.js

@@ -0,0 +1,12 @@
+import { z } from "zod/v4";
+export const cloudAccountSchema = z.object({
+    csp: z.enum(["azure"]).default("azure"),
+    defaultLocation: z.string(),
+    displayName: z.string().min(1),
+    id: z.string().min(1),
+});
+export const cloudRegionSchema = z.object({
+    displayName: z.string().min(1),
+    name: z.string().min(1),
+    short: z.string().min(1).toLowerCase(),
+});

package/dist/domain/codemod.d.ts

@@ -0,0 +1,11 @@
+import { ResultAsync } from "neverthrow";
+import { InfoResult } from "./info.js";
+export type Codemod = {
+    apply: (info: InfoResult) => Promise<void>;
+    description: string;
+    id: string;
+};
+export type CodemodRegistry = {
+    getAll: () => ResultAsync<Codemod[], Error>;
+    getById: (id: string) => ResultAsync<Codemod | undefined, Error>;
+};

package/dist/domain/codemod.js

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

package/dist/domain/dependencies.d.ts

@@ -0,0 +1,10 @@
+import { GitHubService } from "./github.js";
+import { PackageJsonReader } from "./package-json.js";
+import { RepositoryReader } from "./repository.js";
+import { ValidationReporter } from "./validation.js";
+export type Dependencies = {
+    gitHubService: GitHubService;
+    packageJsonReader: PackageJsonReader;
+    repositoryReader: RepositoryReader;
+    validationReporter: ValidationReporter;
+};

package/dist/domain/dependencies.js

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

package/dist/domain/doctor.d.ts

@@ -0,0 +1,10 @@
+import { Config } from "../config.js";
+import { Dependencies } from "./dependencies.js";
+import { ValidationCheck } from "./validation.js";
+type DoctorResult = {
+    checks: ValidationCheck[];
+    hasErrors: boolean;
+};
+export declare const runDoctor: (dependencies: Dependencies, config: Config) => Promise<DoctorResult>;
+export declare const printDoctorResult: ({ validationReporter }: Dependencies, result: DoctorResult) => void[];
+export {};