@pagopa/dx-cli 0.22.4 → 0.23.1

package/dist/adapters/plop/helpers/__tests__/resource-prefix.test.js

@@ -1,113 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { resourcePrefix } from "../resource-prefix.js";
-const createMockPayload = (overrides = {}) => ({
-    env: {
-        cloudAccounts: [],
-        name: "dev",
-        prefix: "dx",
-    },
-    workspace: {
-        domain: "",
-    },
-    ...overrides,
-});
-describe("resourcePrefix", () => {
-    it("should return prefix with env prefix and environment short code when domain is empty", () => {
-        const payload = createMockPayload({
-            env: {
-                cloudAccounts: [],
-                name: "dev",
-                prefix: "dx",
-            },
-            workspace: {
-                domain: "",
-            },
-        });
-        const result = resourcePrefix(payload);
-        expect(result).toBe("dx-d");
-    });
-    it("should return prefix with env prefix, environment short code, and domain when domain is provided", () => {
-        const payload = createMockPayload({
-            env: {
-                cloudAccounts: [],
-                name: "dev",
-                prefix: "dx",
-            },
-            workspace: {
-                domain: "api",
-            },
-        });
-        const result = resourcePrefix(payload);
-        expect(result).toBe("dx-d-api");
-    });
-    it("should handle prod environment with short code 'p'", () => {
-        const payload = createMockPayload({
-            env: {
-                cloudAccounts: [],
-                name: "prod",
-                prefix: "pgo",
-            },
-            workspace: {
-                domain: "core",
-            },
-        });
-        const result = resourcePrefix(payload);
-        expect(result).toBe("pgo-p-core");
-    });
-    it("should handle uat environment with short code 'u'", () => {
-        const payload = createMockPayload({
-            env: {
-                cloudAccounts: [],
-                name: "uat",
-                prefix: "test",
-            },
-            workspace: {
-                domain: "web",
-            },
-        });
-        const result = resourcePrefix(payload);
-        expect(result).toBe("test-u-web");
-    });
-    it("should convert result to lowercase", () => {
-        const payload = createMockPayload({
-            env: {
-                cloudAccounts: [
-                    {
-                        csp: "azure",
-                        defaultLocation: "westeurope",
-                        displayName: "Test Account",
-                        id: "test-account-id",
-                    },
-                ],
-                name: "prod",
-                prefix: "UPPER",
-            },
-            workspace: {
-                domain: "DOMAIN",
-            },
-        });
-        const result = resourcePrefix(payload);
-        expect(result).toBe("upper-p-domain");
-    });
-    it("should handle different prefix lengths", () => {
-        const payload = createMockPayload({
-            env: {
-                cloudAccounts: [
-                    {
-                        csp: "azure",
-                        defaultLocation: "westeurope",
-                        displayName: "Test Account",
-                        id: "test-account-id",
-                    },
-                ],
-                name: "dev",
-                prefix: "ab",
-            },
-            workspace: {
-                domain: "",
-            },
-        });
-        const result = resourcePrefix(payload);
-        expect(result).toBe("ab-d");
-    });
-});

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

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

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

@@ -1,35 +0,0 @@
-/**
- * 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/__tests__/validate-prompt.test.d.ts

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

package/dist/adapters/plop/helpers/__tests__/validate-prompt.test.js

@@ -1,60 +0,0 @@
-// Tests for the shared validatePrompt helper.
-import { describe, expect, it } from "vitest";
-import { z } from "zod/v4";
-import { validatePrompt } from "../validate-prompt.js";
-describe("validatePrompt", () => {
-    it("returns true when input is valid", () => {
-        const schema = z.string().min(1, "Must not be empty");
-        const validate = validatePrompt(schema);
-        const result = validate("hello");
-        expect(result).toBe(true);
-    });
-    it("returns a string error message when input is invalid", () => {
-        const schema = z.string().min(1, "Must not be empty");
-        const validate = validatePrompt(schema);
-        const result = validate("");
-        expect(typeof result).toBe("string");
-        expect(result).not.toBe(true);
-    });
-    it("returns the pretty-printed zod error message", () => {
-        const schema = z.string().min(3, "Too short");
-        const validate = validatePrompt(schema);
-        const result = validate("ab");
-        expect(result).toContain("Too short");
-    });
-    it("returns true for input that passes a min/max length schema", () => {
-        const schema = z.string().min(2).max(4);
-        const validate = validatePrompt(schema);
-        expect(validate("ab")).toBe(true);
-        expect(validate("abc")).toBe(true);
-        expect(validate("abcd")).toBe(true);
-    });
-    it("returns error string when input is too short for min/max length schema", () => {
-        const schema = z.string().min(2).max(4);
-        const validate = validatePrompt(schema);
-        const result = validate("a");
-        expect(typeof result).toBe("string");
-    });
-    it("returns error string when input is too long for min/max length schema", () => {
-        const schema = z.string().min(2).max(4);
-        const validate = validatePrompt(schema);
-        const result = validate("abcde");
-        expect(typeof result).toBe("string");
-    });
-    it("validates input after schema transforms are applied", () => {
-        // Schema with trim+toLowerCase then min length check
-        const schema = z.string().trim().toLowerCase().min(2);
-        const validate = validatePrompt(schema);
-        // "  A  " after trim is "A", after toLowerCase is "a" → length 1 → fails min(2)
-        const result = validate("  A  ");
-        expect(typeof result).toBe("string");
-    });
-    it("works with a non-string schema", () => {
-        const schema = z.array(z.string()).min(1, "Select at least one item");
-        const validate = validatePrompt(schema);
-        expect(validate(["item1"])).toBe(true);
-        const result = validate([]);
-        expect(typeof result).toBe("string");
-        expect(result).toContain("Select at least one item");
-    });
-});

package/dist/adapters/yaml/__tests__/index.test.d.ts

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

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

@@ -1,53 +0,0 @@
-import { err, ok } from "neverthrow";
-import { describe, expect, it } from "vitest";
-import { parseYaml } from "../index.js";
-describe("parseYaml", () => {
-    const yamlContent = `
-packages:
-  - packages/*
-  - apps/*
-  - infra/modules/*
-
-catalog:
-  prettier: 3.6.2
-  eslint: ^9.30.1
-  typescript: ~5.8.3
-  tsup: ^8.5.0
-  vitest: ^3.2.4
-  '@vitest/coverage-v8': ^3.2.4
-  '@tsconfig/node20': ^20.1.6
-  '@types/node': ^20.19.4
-
-onlyBuiltDependencies:
-  - esbuild
-
-packageImportMethod: clone-or-copy
-`;
-    it("should parse valid YAML content", () => {
-        const result = parseYaml(yamlContent);
-        expect(result).toStrictEqual(ok({
-            catalog: {
-                "@tsconfig/node20": "^20.1.6",
-                "@types/node": "^20.19.4",
-                "@vitest/coverage-v8": "^3.2.4",
-                eslint: "^9.30.1",
-                prettier: "3.6.2",
-                tsup: "^8.5.0",
-                typescript: "~5.8.3",
-                vitest: "^3.2.4",
-            },
-            onlyBuiltDependencies: ["esbuild"],
-            packageImportMethod: "clone-or-copy",
-            packages: ["packages/*", "apps/*", "infra/modules/*"],
-        }));
-    });
-    it("should parse empty YAML content", () => {
-        const yamlContent = "";
-        const result = parseYaml(yamlContent);
-        expect(result).toStrictEqual(ok(null));
-    });
-    it("should return an error for invalid YAML content", () => {
-        const result = parseYaml("invalid: yaml: content: here");
-        expect(result).toStrictEqual(err(new Error("Failed to parse YAML")));
-    });
-});

package/dist/domain/__tests__/data.d.ts

@@ -1,19 +0,0 @@
-import { Octokit } from "octokit";
-import { DeepMockProxy, MockProxy } from "vitest-mock-extended";
-import { Config } from "../../config.js";
-import { AuthorizationService } from "../authorization.js";
-import { GitHubService } from "../github.js";
-import { PackageJson, PackageJsonReader } from "../package-json.js";
-import { RepositoryReader } from "../repository.js";
-import { ValidationReporter } from "../validation.js";
-export declare const makeMockPackageJson: (overrides?: Partial<PackageJson>) => PackageJson;
-export declare const makeMockDependencies: () => {
-    authorizationService: MockProxy<AuthorizationService>;
-    gitHubService: MockProxy<GitHubService>;
-    octokit: DeepMockProxy<Octokit>;
-    packageJsonReader: MockProxy<PackageJsonReader>;
-    repositoryReader: MockProxy<RepositoryReader>;
-    validationReporter: MockProxy<ValidationReporter>;
-};
-export declare const makeMockConfig: () => Config;
-export declare const makeMockRepositoryRoot: () => string;

package/dist/domain/__tests__/data.js

@@ -1,28 +0,0 @@
-import { mock, mockDeep } from "vitest-mock-extended";
-export const makeMockPackageJson = (overrides = {}) => {
-    const basePackageJson = {
-        dependencies: new Map(),
-        devDependencies: new Map(),
-        name: "test-package",
-        packageManager: "pnpm",
-        scripts: new Map(),
-    };
-    return {
-        ...basePackageJson,
-        ...overrides,
-    };
-};
-export const makeMockDependencies = () => ({
-    authorizationService: mock(),
-    gitHubService: mock(),
-    octokit: mockDeep(),
-    packageJsonReader: mock(),
-    repositoryReader: mock(),
-    validationReporter: mock(),
-});
-export const makeMockConfig = () => ({
-    minVersions: {
-        nx: "22",
-    },
-});
-export const makeMockRepositoryRoot = () => "a/repo/root";

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

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

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

@@ -1,332 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { environmentSchema, 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");
-    });
-});
-describe("environmentSchema — prefix transforms", () => {
-    const baseEnv = {
-        cloudAccounts: [
-            {
-                csp: "azure",
-                defaultLocation: "westeurope",
-                displayName: "Test Account",
-                id: "test-account-id",
-            },
-        ],
-        name: "dev",
-        prefix: "dx",
-    };
-    it("lowercases an uppercase prefix", () => {
-        const result = environmentSchema.safeParse({ ...baseEnv, prefix: "ABC" });
-        expect(result.success).toBe(true);
-        expect(result.success && result.data.prefix).toBe("abc");
-    });
-    it("lowercases a mixed-case prefix", () => {
-        const result = environmentSchema.safeParse({ ...baseEnv, prefix: "AbCd" });
-        expect(result.success).toBe(true);
-        expect(result.success && result.data.prefix).toBe("abcd");
-    });
-    it("trims leading and trailing whitespace from prefix", () => {
-        const result = environmentSchema.safeParse({ ...baseEnv, prefix: " dx " });
-        expect(result.success).toBe(true);
-        expect(result.success && result.data.prefix).toBe("dx");
-    });
-    it("trims and lowercases prefix together", () => {
-        const result = environmentSchema.safeParse({ ...baseEnv, prefix: " DX " });
-        expect(result.success).toBe(true);
-        expect(result.success && result.data.prefix).toBe("dx");
-    });
-    it("still rejects a prefix shorter than 2 characters after trim", () => {
-        const result = environmentSchema.safeParse({ ...baseEnv, prefix: " a " });
-        expect(result.success).toBe(false);
-    });
-    it("still rejects a prefix longer than 4 characters after trim", () => {
-        const result = environmentSchema.safeParse({
-            ...baseEnv,
-            prefix: "abcde",
-        });
-        expect(result.success).toBe(false);
-    });
-    it("accepts a valid lowercase prefix unchanged", () => {
-        const result = environmentSchema.safeParse({ ...baseEnv, prefix: "dx" });
-        expect(result.success).toBe(true);
-        expect(result.success && result.data.prefix).toBe("dx");
-    });
-});

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

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