@pagopa/dx-cli 0.22.4 → 0.23.1

package/dist/adapters/commander/presenters/__tests__/index.test.js

@@ -1,23 +0,0 @@
-/**
- * Tests for isNonInteractive and createCommandPresenter factory.
- */
-import { describe, expect, it } from "vitest";
-import { createCommandPresenter, isNonInteractive } from "../index.js";
-import { JsonCommandPresenter } from "../json-command-presenter.js";
-import { TextCommandPresenter } from "../text-command-presenter.js";
-describe("isNonInteractive", () => {
-    it("returns true when CI is true", () => {
-        expect(isNonInteractive({ CI: true })).toBe(true);
-    });
-    it("returns false when CI is false", () => {
-        expect(isNonInteractive({ CI: false })).toBe(false);
-    });
-});
-describe("createCommandPresenter", () => {
-    it("returns a TextCommandPresenter when output is 'text'", () => {
-        expect(createCommandPresenter("text")).toBeInstanceOf(TextCommandPresenter);
-    });
-    it("returns a JsonCommandPresenter when output is 'json'", () => {
-        expect(createCommandPresenter("json")).toBeInstanceOf(JsonCommandPresenter);
-    });
-});

package/dist/adapters/commander/presenters/__tests__/json.test.d.ts

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

package/dist/adapters/commander/presenters/__tests__/json.test.js

@@ -1,108 +0,0 @@
-/**
- * Tests for JsonCommandPresenter.
- *
- * JsonCommandPresenter uses a split-stream convention:
- *   - stdout for the final result/error envelope
- *   - stderr for step lifecycle (progress) events
- *
- * Tests verify the wire format, correct stream usage, and that values
- * flow through correctly.
- */
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { JsonCommandPresenter } from "../json-command-presenter.js";
-const captureStdout = () => {
-    const written = [];
-    vi.spyOn(process.stdout, "write").mockImplementation((data) => {
-        written.push(String(data));
-        return true;
-    });
-    return { written };
-};
-const captureStderr = () => {
-    const written = [];
-    vi.spyOn(process.stderr, "write").mockImplementation((data) => {
-        written.push(String(data));
-        return true;
-    });
-    return { written };
-};
-describe("JsonCommandPresenter", () => {
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-    describe("trackStep", () => {
-        it("executes the task and returns its resolved value", async () => {
-            captureStderr();
-            const logger = new JsonCommandPresenter();
-            const result = await logger.trackStep("check terraform", () => Promise.resolve(42));
-            expect(result).toBe(42);
-        });
-        it("emits start then success events to stderr", async () => {
-            const stderr = captureStderr();
-            const logger = new JsonCommandPresenter();
-            await logger.trackStep("check terraform", () => Promise.resolve("done"));
-            expect(stderr.written).toHaveLength(2);
-            expect(JSON.parse(stderr.written[0])).toMatchObject({
-                name: "check terraform",
-                status: "start",
-                type: "step",
-            });
-            expect(JSON.parse(stderr.written[1])).toMatchObject({
-                name: "check terraform",
-                status: "success",
-                type: "step",
-            });
-        });
-        it("emits error event to stderr and rethrows on task failure", async () => {
-            const stderr = captureStderr();
-            const logger = new JsonCommandPresenter();
-            const error = new Error("terraform not found");
-            await expect(logger.trackStep("check terraform", () => Promise.reject(error))).rejects.toThrow("terraform not found");
-            expect(JSON.parse(stderr.written[1])).toMatchObject({
-                error: "terraform not found",
-                name: "check terraform",
-                status: "error",
-                type: "step",
-            });
-        });
-        it("can run multiple sequential steps", async () => {
-            captureStderr();
-            const logger = new JsonCommandPresenter();
-            const order = [];
-            await logger.trackStep("step A", async () => {
-                order.push("A");
-            });
-            await logger.trackStep("step B", async () => {
-                order.push("B");
-            });
-            expect(order).toEqual(["A", "B"]);
-        });
-    });
-    describe("reportResult", () => {
-        it("emits an ok:true JSON envelope to stdout", () => {
-            const stdout = captureStdout();
-            const logger = new JsonCommandPresenter();
-            logger.reportResult({ repository: { name: "my-repo" } });
-            expect(JSON.parse(stdout.written[0])).toEqual({
-                data: { repository: { name: "my-repo" } },
-                ok: true,
-            });
-        });
-    });
-    describe("reportError", () => {
-        it("emits an ok:false JSON envelope to stdout", () => {
-            const stdout = captureStdout();
-            const logger = new JsonCommandPresenter();
-            logger.reportError(new Error("something failed"));
-            expect(JSON.parse(stdout.written[0])).toMatchObject({
-                error: "something failed",
-                ok: false,
-            });
-        });
-        it("handles non-Error values without throwing", () => {
-            captureStdout();
-            const logger = new JsonCommandPresenter();
-            expect(() => logger.reportError("plain string error")).not.toThrow();
-        });
-    });
-});

package/dist/adapters/commander/presenters/__tests__/text.test.d.ts

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

package/dist/adapters/commander/presenters/__tests__/text.test.js

@@ -1,60 +0,0 @@
-/**
- * Tests for TextCommandPresenter.
- *
- * The TextCommandPresenter wraps oraPromise for step feedback and chalk for
- * final output. Tests verify the observable behavior: tasks are executed,
- * values flow through, and errors surface correctly.
- */
-import { afterEach, describe, expect, it, vi } from "vitest";
-// Mock oraPromise so tests don't spin up a real TTY spinner
-vi.mock("ora", () => ({
-    oraPromise: (_promise) => _promise,
-}));
-import { TextCommandPresenter } from "../text-command-presenter.js";
-describe("TextCommandPresenter", () => {
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-    describe("trackStep", () => {
-        it("executes the task and returns its resolved value", async () => {
-            const logger = new TextCommandPresenter();
-            const result = await logger.trackStep("check terraform", () => Promise.resolve(42));
-            expect(result).toBe(42);
-        });
-        it("propagates task rejection as a thrown error", async () => {
-            const logger = new TextCommandPresenter();
-            const error = new Error("terraform not found");
-            await expect(logger.trackStep("check terraform", () => Promise.reject(error))).rejects.toThrow("terraform not found");
-        });
-        it("can run multiple sequential steps", async () => {
-            const logger = new TextCommandPresenter();
-            const order = [];
-            await logger.trackStep("step A", async () => {
-                order.push("A");
-            });
-            await logger.trackStep("step B", async () => {
-                order.push("B");
-            });
-            expect(order).toEqual(["A", "B"]);
-        });
-    });
-    describe("reportResult", () => {
-        it("calls console.log without throwing", () => {
-            vi.spyOn(console, "log").mockImplementation(() => undefined);
-            const logger = new TextCommandPresenter();
-            expect(() => logger.reportResult({ repository: { name: "my-repo" } })).not.toThrow();
-        });
-    });
-    describe("reportError", () => {
-        it("calls console.error without throwing", () => {
-            vi.spyOn(console, "error").mockImplementation(() => undefined);
-            const logger = new TextCommandPresenter();
-            expect(() => logger.reportError(new Error("something failed"))).not.toThrow();
-        });
-        it("handles non-Error values without throwing", () => {
-            vi.spyOn(console, "error").mockImplementation(() => undefined);
-            const logger = new TextCommandPresenter();
-            expect(() => logger.reportError("plain string error")).not.toThrow();
-        });
-    });
-});

package/dist/adapters/github/__tests__/github-repo.spec.d.ts

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

package/dist/adapters/github/__tests__/github-repo.spec.js

@@ -1,67 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-vi.mock("execa", () => ({
-    $: vi.fn(),
-}));
-import { $ } from "execa";
-import { getGithubRepo } from "../github-repo.js";
-const mock$ = $;
-describe("getGithubRepo", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it("should return undefined if no remote URL is set", async () => {
-        mock$.mockResolvedValue({ stdout: "" });
-        const result = await getGithubRepo();
-        expect(result).toBeUndefined();
-    });
-    it("should parse GitHub repository URL and return owner and repo", async () => {
-        mock$.mockResolvedValue({ stdout: "https://github.com/pagopa/dx" });
-        const result = await getGithubRepo();
-        expect(result).toEqual({
-            owner: "pagopa",
-            repo: "dx",
-        });
-    });
-    it("should handle repository URLs with .git suffix", async () => {
-        mock$.mockResolvedValue({ stdout: "https://github.com/pagopa/dx.git" });
-        const result = await getGithubRepo();
-        expect(result).toEqual({
-            owner: "pagopa",
-            repo: "dx",
-        });
-    });
-    it("should throw an error for non-GitHub repositories", async () => {
-        mock$.mockResolvedValue({ stdout: "https://gitlab.com/owner/repo" });
-        await expect(getGithubRepo()).rejects.toThrow("Only GitHub repositories are supported");
-    });
-    it("should handle repository names with hyphens", async () => {
-        mock$.mockResolvedValue({
-            stdout: "https://github.com/my-org/my-repo-name",
-        });
-        const result = await getGithubRepo();
-        expect(result).toEqual({
-            owner: "my-org",
-            repo: "my-repo-name",
-        });
-    });
-    it("should handle repository names with underscores", async () => {
-        mock$.mockResolvedValue({
-            stdout: "https://github.com/my_org/my_repo_name",
-        });
-        const result = await getGithubRepo();
-        expect(result).toEqual({
-            owner: "my_org",
-            repo: "my_repo_name",
-        });
-    });
-    it("should handle ssh repository URLs", async () => {
-        mock$.mockResolvedValue({
-            stdout: "git@github.com:my-org/my-repo-name.git",
-        });
-        const result = await getGithubRepo();
-        expect(result).toEqual({
-            owner: "my-org",
-            repo: "my-repo-name",
-        });
-    });
-});

package/dist/adapters/node/__tests__/data.d.ts

@@ -1,18 +0,0 @@
-import { PackageJson } from "../../../domain/package-json.js";
-export declare const makeMockPackageJson: (overrides?: Partial<PackageJson>) => {
-    dependencies: Map<string, string> | {
-        aDependency: string;
-        anotherDependency: string;
-    };
-    devDependencies: Map<string, string> | {
-        turbo: string;
-        typescript: string;
-    };
-    name: string;
-    scripts: Map<string & import("zod").$brand<"ScriptName">, string> | {
-        build: string;
-        "code-review": string;
-    };
-    packageManager?: "npm" | "pnpm" | "yarn" | undefined;
-};
-export declare const makeMockPnpmWorkspaceYaml: () => string;

package/dist/adapters/node/__tests__/data.js

@@ -1,22 +0,0 @@
-export const makeMockPackageJson = (overrides = {}) => {
-    const basePackageJson = {
-        dependencies: {
-            aDependency: "^4.17.21",
-            anotherDependency: "^8.0.0",
-        },
-        devDependencies: {
-            turbo: "^2.5.2",
-            typescript: "^5.0.0",
-        },
-        name: "aPackageName",
-        scripts: {
-            build: "tsc",
-            "code-review": "eslint .",
-        },
-    };
-    return { ...basePackageJson, ...overrides };
-};
-export const makeMockPnpmWorkspaceYaml = () => `
-  packages:
-  - packages/*
-`;

package/dist/adapters/node/__tests__/package-json.test.d.ts

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

package/dist/adapters/node/__tests__/package-json.test.js

@@ -1,86 +0,0 @@
-import { vol } from "memfs";
-import { err, ok } from "neverthrow";
-import fs from "node:fs/promises";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { makePackageJsonReader } from "../package-json.js";
-import { makeMockPackageJson } from "./data.js";
-vi.mock("node:fs/promises");
-describe("makePackageJsonReader", () => {
-    const mockPackageJson = makeMockPackageJson();
-    const rootDir = "/some/dir";
-    beforeEach(() => {
-        vol.reset();
-        vol.fromJSON({
-            "./package.json": JSON.stringify(mockPackageJson),
-        }, rootDir);
-    });
-    describe("getScripts", () => {
-        it("should parse scripts from package.json", async () => {
-            const spy = vi.spyOn(fs, "readFile");
-            const packageJsonReader = makePackageJsonReader();
-            const result = await packageJsonReader.getScripts(rootDir);
-            expect(result).toStrictEqual(ok(new Map().set("build", "tsc").set("code-review", "eslint .")));
-            expect(spy).toHaveBeenCalledWith(`${rootDir}/package.json`, "utf-8");
-        });
-        it("should return an empty array when no scripts exist", async () => {
-            vol.fromJSON({
-                "./package.json": JSON.stringify(makeMockPackageJson({ scripts: undefined })),
-            }, rootDir);
-            const spy = vi.spyOn(fs, "readFile");
-            const packageJsonReader = makePackageJsonReader();
-            const result = await packageJsonReader.getScripts(rootDir);
-            expect(result).toStrictEqual(ok(new Map()));
-            expect(spy).toHaveBeenCalledWith(`${rootDir}/package.json`, "utf-8");
-        });
-        it("should return an error when package.json does not exist", async () => {
-            vol.reset();
-            const packageJsonReader = makePackageJsonReader();
-            const result = await packageJsonReader.getScripts(rootDir);
-            expect(result).toStrictEqual(err(new Error("Failed to read file: /some/dir/package.json")));
-        });
-        it("should return an error when package.json is invalid JSON", async () => {
-            vol.fromJSON({
-                "./package.json": "invalid json content",
-            }, rootDir);
-            const packageJsonReader = makePackageJsonReader();
-            const result = await packageJsonReader.getScripts(rootDir);
-            expect(result).toStrictEqual(err(new Error("Failed to parse JSON")));
-        });
-    });
-    describe("getDependencies", () => {
-        it("should parse devDependencies from package.json", async () => {
-            const spy = vi.spyOn(fs, "readFile");
-            const packageJsonReader = makePackageJsonReader();
-            const result = await packageJsonReader.getDependencies(rootDir, "dev");
-            expect(result).toStrictEqual(ok(new Map().set("turbo", "^2.5.2").set("typescript", "^5.0.0")));
-            expect(spy).toHaveBeenCalledWith(`${rootDir}/package.json`, "utf-8");
-        });
-        it("should parse dependencies from package.json", async () => {
-            const spy = vi.spyOn(fs, "readFile");
-            const packageJsonReader = makePackageJsonReader();
-            const result = await packageJsonReader.getDependencies(rootDir, "prod");
-            expect(result).toStrictEqual(ok(new Map()
-                .set("aDependency", "^4.17.21")
-                .set("anotherDependency", "^8.0.0")));
-            expect(spy).toHaveBeenCalledWith(`${rootDir}/package.json`, "utf-8");
-        });
-        it("should return an empty array when no dependencies exist", async () => {
-            vol.reset();
-            vol.fromJSON({
-                "./package.json": JSON.stringify(makeMockPackageJson({
-                    dependencies: undefined,
-                    devDependencies: undefined,
-                })),
-            }, rootDir);
-            const packageJsonReader = makePackageJsonReader();
-            const result = await packageJsonReader.getDependencies(rootDir, "dev");
-            expect(result).toStrictEqual(ok(new Map()));
-        });
-        it("should return an error when package.json does not exist for dependencies", async () => {
-            vol.reset();
-            const packageJsonReader = makePackageJsonReader();
-            const result = await packageJsonReader.getDependencies(rootDir, "dev");
-            expect(result).toStrictEqual(err(new Error("Failed to read file: /some/dir/package.json")));
-        });
-    });
-});

package/dist/adapters/node/__tests__/repository.test.d.ts

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

package/dist/adapters/node/__tests__/repository.test.js

@@ -1,77 +0,0 @@
-import * as glob from "glob";
-import { fs, vol } from "memfs";
-import { err, ok } from "neverthrow";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { makeRepositoryReader } from "../repository.js";
-import { makeMockPackageJson, makeMockPnpmWorkspaceYaml } from "./data.js";
-vi.mock("node:fs/promises");
-const mockFileSystem = {
-    "./packages/bar/package.json": JSON.stringify(makeMockPackageJson({ name: "bar" })),
-    "./packages/foo/package.json": JSON.stringify(makeMockPackageJson({ name: "foo" })),
-    "./pnpm-workspace.yaml": makeMockPnpmWorkspaceYaml(),
-};
-describe("makeRepositoryReader", () => {
-    const repoRoot = "/some/repo/root";
-    vi.mock("glob", { spy: true });
-    beforeEach(() => {
-        vi.clearAllMocks();
-        vol.reset();
-        vol.fromJSON(mockFileSystem, repoRoot);
-    });
-    describe("getWorkspaces", () => {
-        it("should return an error when pnpm-workspace.yaml does not exist", async () => {
-            vol.reset();
-            const repositoryReader = makeRepositoryReader();
-            const result = await repositoryReader.getWorkspaces(repoRoot);
-            expect(result).toStrictEqual(err(new Error("Failed to read file: /some/repo/root/pnpm-workspace.yaml")));
-        });
-        it("should return no workspaces if the packages entry is not in the pnpm-workspace.yaml file", async () => {
-            vol.reset();
-            vol.fromJSON({ ...mockFileSystem, "./pnpm-workspace.yaml": "a yaml" }, repoRoot);
-            const readFileSpy = vi.spyOn(fs.promises, "readFile");
-            const globSpy = vi.spyOn(glob, "glob");
-            const repositoryReader = makeRepositoryReader();
-            const result = await repositoryReader.getWorkspaces(repoRoot);
-            expect(result).toStrictEqual(ok([]));
-            expect(readFileSpy).nthCalledWith(1, "/some/repo/root/pnpm-workspace.yaml", "utf-8");
-            expect(globSpy).not.toHaveBeenCalled();
-        });
-    });
-    it("should return the workspaces", async () => {
-        const spyReadFile = vi.spyOn(fs.promises, "readFile");
-        const globSpy = vi.spyOn(glob, "glob");
-        globSpy.mockResolvedValueOnce(["packages/foo", "packages/bar"]);
-        const repositoryReader = makeRepositoryReader();
-        const result = await repositoryReader.getWorkspaces(repoRoot);
-        expect(result).toStrictEqual(ok([
-            {
-                name: "foo",
-                path: "/some/repo/root/packages/foo",
-            },
-            {
-                name: "bar",
-                path: "/some/repo/root/packages/bar",
-            },
-        ]));
-        expect(spyReadFile).nthCalledWith(1, "/some/repo/root/pnpm-workspace.yaml", "utf-8");
-        expect(globSpy).toHaveBeenCalledTimes(1);
-        expect(globSpy).toHaveBeenCalledWith("packages/*", {
-            cwd: repoRoot,
-        });
-        expect(spyReadFile).nthCalledWith(2, "/some/repo/root/packages/foo/package.json", "utf-8");
-        expect(spyReadFile).nthCalledWith(3, "/some/repo/root/packages/bar/package.json", "utf-8");
-    });
-    it("should return an error when the glob function fails", async () => {
-        const readFileSpy = vi.spyOn(fs.promises, "readFile");
-        const globSpy = vi.spyOn(glob, "glob");
-        // First read the pnpm-workspace.yaml file
-        globSpy.mockImplementationOnce(() => Promise.reject(new Error("glob failed")));
-        const repositoryReader = makeRepositoryReader();
-        const result = await repositoryReader.getWorkspaces(repoRoot);
-        expect(result).toStrictEqual(err(new Error("Failed to resolve workspace glob: packages/*")));
-        expect(readFileSpy).toBeCalledWith("/some/repo/root/pnpm-workspace.yaml", "utf-8");
-        expect(globSpy).toBeCalledWith("packages/*", {
-            cwd: repoRoot,
-        });
-    });
-});

package/dist/adapters/node/fs/__tests__/file-reader.test.d.ts

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

package/dist/adapters/node/fs/__tests__/file-reader.test.js

@@ -1,80 +0,0 @@
-import { fs, vol } from "memfs";
-import { err, ok } from "neverthrow";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { z } from "zod/v4";
-import { fileExists, readFile, readFileAndDecode } from "../file-reader.js";
-vi.mock("node:fs/promises");
-describe("readFileAndDecode", () => {
-    const testSchema = z.object({
-        name: z.string(),
-        version: z.string(),
-    });
-    const validData = {
-        name: "test-package",
-        version: "1.0.0",
-    };
-    beforeEach(() => {
-        vol.reset();
-        vol.fromJSON({
-            "./file.json": JSON.stringify(validData),
-            "./file.yaml": "name: test-package\nversion: 1.0.0",
-            "./invalid.json": JSON.stringify({ invalidKey: "anInvalidKey" }),
-        }, ".");
-    });
-    it("should read and parse a file", async () => {
-        const spy = vi.spyOn(fs.promises, "readFile");
-        const result = await readFileAndDecode("file.json", testSchema);
-        expect(result).toStrictEqual(ok(validData));
-        expect(spy).toHaveBeenCalledWith("file.json", "utf-8");
-    });
-    it("should return error when file does not exist", async () => {
-        const result = await readFileAndDecode("nonexistent.json", testSchema);
-        expect(result).toStrictEqual(err(new Error("Failed to read file: nonexistent.json")));
-    });
-    it("should return error when JSON parsing fails", async () => {
-        const result = await readFileAndDecode("file.yaml", testSchema);
-        expect(result).toStrictEqual(err(new Error("Failed to parse JSON")));
-    });
-    it("should return error when schema decoding fails", async () => {
-        const spy = vi.spyOn(fs.promises, "readFile");
-        const result = await readFileAndDecode("invalid.json", testSchema);
-        expect(result).toStrictEqual(err(new Error("Input is not valid for the given schema")));
-        expect(spy).toHaveBeenCalledWith("invalid.json", "utf-8");
-    });
-});
-describe("readFile", () => {
-    beforeEach(() => {
-        vol.reset();
-        vol.fromJSON({
-            "./existing.txt": "hello world",
-        }, ".");
-    });
-    it("should read a file when it exists", async () => {
-        const spy = vi.spyOn(fs.promises, "readFile");
-        const result = await readFile("existing.txt");
-        expect(result).toStrictEqual(ok("hello world"));
-        expect(spy).toHaveBeenCalledWith("existing.txt", "utf-8");
-    });
-    it("should return error when file does not exist", async () => {
-        const result = await readFile("/missing.txt");
-        expect(result).toStrictEqual(err(new Error("Failed to read file: /missing.txt")));
-    });
-});
-describe("fileExists", () => {
-    beforeEach(() => {
-        vol.reset();
-        vol.fromJSON({
-            "./file.txt": "content",
-        }, ".");
-    });
-    it("should return true when the path exists", async () => {
-        const spy = vi.spyOn(fs.promises, "stat");
-        const result = await fileExists("file.txt");
-        expect(result).toStrictEqual(ok(true));
-        expect(spy).toHaveBeenCalledWith("file.txt");
-    });
-    it("should return the error when the path does not exist", async () => {
-        const result = await fileExists("missing.txt");
-        expect(result).toStrictEqual(err(new Error("missing.txt not found.")));
-    });
-});

package/dist/adapters/node/json/__tests__/index.test.d.ts

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

package/dist/adapters/node/json/__tests__/index.test.js

@@ -1,14 +0,0 @@
-import { err, ok } from "neverthrow";
-import { describe, expect, it } from "vitest";
-import { parseJson } from "../index.js";
-describe("parseJson", () => {
-    const validJSONString = '{"name": "test"}';
-    it("should return JS object when valid JSON is provided", () => {
-        const result = parseJson(validJSONString);
-        expect(result).toStrictEqual(ok({ name: "test" }));
-    });
-    it("should return error when invalid JSON is provided", () => {
-        const result = parseJson("invalid JSON");
-        expect(result).toStrictEqual(err(new Error("Failed to parse JSON")));
-    });
-});

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

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