@pagopa/dx-cli 0.22.3 → 0.22.4

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

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

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

@@ -0,0 +1,23 @@
+/**
+ * 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

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

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

@@ -0,0 +1,108 @@
+/**
+ * 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

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

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

@@ -0,0 +1,60 @@
+/**
+ * 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/commander/presenters/index.d.ts

@@ -0,0 +1,27 @@
+import type { CommandPresenter } from "../../../domain/command-presenter.js";
+/**
+ * Output logger factory.
+ *
+ * isNonInteractive determines whether the CLI should suppress interactive
+ * prompts (e.g. when running in a CI pipeline). This is independent of the
+ * output format: a user can request JSON output while still answering prompts,
+ * and a CI system can set CI=true with text output.
+ *
+ * createCommandPresenter selects the appropriate CommandPresenter adapter based solely
+ * on the requested output format.
+ */
+import type { CliEnv } from "../env.js";
+/**
+ * Returns true when the CLI should suppress interactive prompts.
+ *
+ * Checks the parsed CI boolean from CliEnv (coerced by zod's stringbool),
+ * following the same convention used by `is-interactive` and `ora`.
+ */
+export declare const isNonInteractive: (env: CliEnv) => boolean;
+/**
+ * Returns the appropriate CommandPresenter adapter for the requested output mode.
+ *
+ * - "text" → TextCommandPresenter (chalk + ora, for human terminal sessions)
+ * - "json" → JsonCommandPresenter (NDJSON on stderr, JSON envelope on stdout)
+ */
+export declare const createCommandPresenter: (output: "json" | "text") => CommandPresenter;

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

@@ -0,0 +1,16 @@
+import { JsonCommandPresenter } from "./json-command-presenter.js";
+import { TextCommandPresenter } from "./text-command-presenter.js";
+/**
+ * Returns true when the CLI should suppress interactive prompts.
+ *
+ * Checks the parsed CI boolean from CliEnv (coerced by zod's stringbool),
+ * following the same convention used by `is-interactive` and `ora`.
+ */
+export const isNonInteractive = (env) => env.CI;
+/**
+ * Returns the appropriate CommandPresenter adapter for the requested output mode.
+ *
+ * - "text" → TextCommandPresenter (chalk + ora, for human terminal sessions)
+ * - "json" → JsonCommandPresenter (NDJSON on stderr, JSON envelope on stdout)
+ */
+export const createCommandPresenter = (output) => output === "json" ? new JsonCommandPresenter() : new TextCommandPresenter();

package/dist/adapters/commander/presenters/json-command-presenter.d.ts

@@ -0,0 +1,19 @@
+/**
+ * JsonCommandPresenter — structured adapter for the CommandPresenter domain port.
+ *
+ * Uses a split-stream convention for machine-readable output:
+ *   - stdout: final result/error envelope (JSON, one line)
+ *   - stderr: step lifecycle events (NDJSON progress stream)
+ *
+ * Each line is a self-describing JSON object discriminated by its fields:
+ *
+ *   stderr: {"type":"step","status":"start"|"success"|"error","name":"...","error":"...?"}
+ *   stdout: {"ok":true,"data":{...}}
+ *   stdout: {"ok":false,"error":"..."}
+ */
+import type { CommandPresenter } from "../../../domain/command-presenter.js";
+export declare class JsonCommandPresenter implements CommandPresenter {
+    reportError(error: unknown): void;
+    reportResult<T>(data: T): void;
+    trackStep<T>(name: string, task: () => Promise<T>): Promise<T>;
+}

package/dist/adapters/commander/presenters/json-command-presenter.js

@@ -0,0 +1,26 @@
+import { toErrorMessage } from "../error-reporting.js";
+export class JsonCommandPresenter {
+    reportError(error) {
+        process.stdout.write(JSON.stringify({ error: toErrorMessage(error), ok: false }) + "\n");
+    }
+    reportResult(data) {
+        process.stdout.write(JSON.stringify({ data, ok: true }) + "\n");
+    }
+    async trackStep(name, task) {
+        process.stderr.write(JSON.stringify({ name, status: "start", type: "step" }) + "\n");
+        try {
+            const result = await task();
+            process.stderr.write(JSON.stringify({ name, status: "success", type: "step" }) + "\n");
+            return result;
+        }
+        catch (error) {
+            process.stderr.write(JSON.stringify({
+                error: toErrorMessage(error),
+                name,
+                status: "error",
+                type: "step",
+            }) + "\n");
+            throw error;
+        }
+    }
+}

package/dist/adapters/commander/presenters/text-command-presenter.d.ts

@@ -0,0 +1,6 @@
+import type { CommandPresenter } from "../../../domain/command-presenter.js";
+export declare class TextCommandPresenter implements CommandPresenter {
+    reportError(error: unknown): void;
+    reportResult<T>(data: T): void;
+    trackStep<T>(name: string, task: () => Promise<T>): Promise<T>;
+}

package/dist/adapters/commander/presenters/text-command-presenter.js

@@ -0,0 +1,21 @@
+/**
+ * TextCommandPresenter — human-readable adapter for the CommandPresenter domain port.
+ *
+ * Renders step progress via oraPromise for interactive terminal feedback,
+ * and writes results and errors to the console with chalk colouring.
+ * Intended for interactive terminal sessions (TTY).
+ */
+import chalk from "chalk";
+import { oraPromise } from "ora";
+import { toErrorMessage } from "../error-reporting.js";
+export class TextCommandPresenter {
+    reportError(error) {
+        console.error(chalk.red(toErrorMessage(error)));
+    }
+    reportResult(data) {
+        console.log(data);
+    }
+    async trackStep(name, task) {
+        return oraPromise(task(), { text: name });
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pagopa/dx-cli",
-  "version": "0.22.3",
+  "version": "0.22.4",
   "type": "module",
   "description": "A CLI useful to manage DX tools.",
   "repository": {