@pagopa/dx-cli 0.15.2 → 0.15.4

package/dist/adapters/logtape/validation-reporter.js

@@ -0,0 +1,14 @@
+import { getLogger } from "@logtape/logtape";
+export const makeValidationReporter = () => {
+    const logger = getLogger(["dx-cli", "validation"]);
+    return {
+        reportCheckResult(result) {
+            if (result.isValid) {
+                logger.info(`✅ ${result.successMessage}`);
+            }
+            else {
+                logger.error(`❌ ${result.errorMessage}`);
+            }
+        },
+    };
+};

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

@@ -0,0 +1,18 @@
+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/v4").$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

@@ -0,0 +1,22 @@
+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

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

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

@@ -0,0 +1,86 @@
+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

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

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

@@ -0,0 +1,77 @@
+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

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

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

@@ -0,0 +1,80 @@
+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/fs/file-reader.d.ts

@@ -0,0 +1,24 @@
+import { ResultAsync } from "neverthrow";
+import { z } from "zod/v4";
+/**
+ * Reads a file from a directory with a specific filename.
+ *
+ * @param filePath - The path to the file to read
+ * @returns ResultAsync with file content or error
+ */
+export declare const readFile: (filePath: string) => ResultAsync<string, Error>;
+/**
+ * Generic function to read a file and parse its content with a given zod schema.
+ *
+ * @param filePath - The path to the file to read
+ * @param schema - The zod schema to parse the file content with
+ * @returns ResultAsync with the parsed data or an error
+ */
+export declare const readFileAndDecode: <T>(filePath: string, schema: z.ZodSchema<T>) => ResultAsync<T, Error>;
+/**
+ * Checks if a file exists.
+ *
+ * @param path - The path to the file to check
+ * @returns ResultAsync with true if the file exists, false otherwise
+ */
+export declare const fileExists: (path: string) => ResultAsync<boolean, Error>;

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

@@ -0,0 +1,26 @@
+import { ResultAsync } from "neverthrow";
+import fs from "node:fs/promises";
+import { decode } from "../../zod/index.js";
+import { parseJson } from "../json/index.js";
+/**
+ * Reads a file from a directory with a specific filename.
+ *
+ * @param filePath - The path to the file to read
+ * @returns ResultAsync with file content or error
+ */
+export const readFile = (filePath) => ResultAsync.fromPromise(fs.readFile(filePath, "utf-8"), (cause) => new Error(`Failed to read file: ${filePath}`, { cause }));
+/**
+ * Generic function to read a file and parse its content with a given zod schema.
+ *
+ * @param filePath - The path to the file to read
+ * @param schema - The zod schema to parse the file content with
+ * @returns ResultAsync with the parsed data or an error
+ */
+export const readFileAndDecode = (filePath, schema) => readFile(filePath).andThen(parseJson).andThen(decode(schema));
+/**
+ * Checks if a file exists.
+ *
+ * @param path - The path to the file to check
+ * @returns ResultAsync with true if the file exists, false otherwise
+ */
+export const fileExists = (path) => ResultAsync.fromPromise(fs.stat(path), () => new Error(`${path} not found.`)).map(() => true);

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

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

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

@@ -0,0 +1,14 @@
+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/node/json/index.d.ts

@@ -0,0 +1,2 @@
+import { Result } from "neverthrow";
+export declare const parseJson: (text: string, reviver?: ((this: any, key: string, value: any) => any) | undefined) => Result<any, Error>;

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

@@ -0,0 +1,2 @@
+import { Result } from "neverthrow";
+export const parseJson = Result.fromThrowable(JSON.parse, (cause) => new Error("Failed to parse JSON", { cause }));

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

@@ -0,0 +1,2 @@
+import { PackageJsonReader } from "../../domain/package-json.js";
+export declare const makePackageJsonReader: () => PackageJsonReader;

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

@@ -0,0 +1,22 @@
+import { join } from "node:path";
+import * as process from "node:process";
+import { packageJsonSchema, } from "../../domain/package-json.js";
+import { readFileAndDecode } from "./fs/file-reader.js";
+export const makePackageJsonReader = () => ({
+    getDependencies: (cwd = process.cwd(), type) => {
+        const packageJsonPath = join(cwd, "package.json");
+        return readFileAndDecode(packageJsonPath, packageJsonSchema).map((packageJson) => {
+            const key = type === "dev" ? "devDependencies" : "dependencies";
+            return packageJson[key];
+        });
+    },
+    getRootRequiredScripts: () => new Map().set("code-review", "eslint ."),
+    getScripts: (cwd = process.cwd()) => {
+        const packageJsonPath = join(cwd, "package.json");
+        return readFileAndDecode(packageJsonPath, packageJsonSchema).map(({ scripts }) => scripts);
+    },
+    readPackageJson: (cwd = process.cwd()) => {
+        const packageJsonPath = join(cwd, "package.json");
+        return readFileAndDecode(packageJsonPath, packageJsonSchema);
+    },
+});

package/dist/adapters/node/release.d.ts

@@ -0,0 +1,2 @@
+import { SemVer } from "semver";
+export declare function getLatestByCodename(codename: "Jod"): Promise<SemVer>;

package/dist/adapters/node/release.js

@@ -0,0 +1,33 @@
+import * as assert from "node:assert/strict";
+import semverParse from "semver/functions/parse.js";
+import { z } from "zod/v4";
+const nodeReleaseSchema = z.object({
+    lts: z.union([z.string(), z.boolean()]).nullable(),
+    version: z.string(),
+});
+export async function getLatestByCodename(codename) {
+    const releases = await nodeReleases();
+    for (const release of releases) {
+        if (release.lts === codename) {
+            // throws if the version is invalid
+            return semverParse(release.version, {}, true);
+        }
+    }
+    throw new Error(`No LTS release found for codename: ${codename}`);
+}
+async function nodeReleases() {
+    try {
+        const response = await fetch("https://nodejs.org/dist/index.json");
+        assert.ok(response.ok, `Failed to fetch Node.js releases: ${response.statusText}`);
+        const json = await response.json();
+        return z.array(nodeReleaseSchema).parse(json);
+    }
+    catch (err) {
+        if (err instanceof z.ZodError) {
+            throw new Error("Invalid data format for Node.js releases", {
+                cause: err,
+            });
+        }
+        throw err;
+    }
+}

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

@@ -0,0 +1,2 @@
+import { RepositoryReader } from "../../domain/repository.js";
+export declare const makeRepositoryReader: () => RepositoryReader;

package/dist/adapters/node/repository.js

@@ -0,0 +1,47 @@
+import * as glob from "glob";
+import { okAsync, ResultAsync } from "neverthrow";
+import * as path from "node:path";
+import { z } from "zod/v4";
+import { packageJsonSchema } from "../../domain/package-json.js";
+import { workspaceSchema } from "../../domain/workspace.js";
+import { parseYaml } from "../yaml/index.js";
+import { decode } from "../zod/index.js";
+import { fileExists, readFile, readFileAndDecode } from "./fs/file-reader.js";
+const findRepositoryRoot = (dir = process.cwd()) => {
+    const gitPath = path.join(dir, ".git");
+    return fileExists(gitPath)
+        .mapErr(() => new Error("Could not find repository root. Make sure to have the repo initialized."))
+        .map(() => dir);
+};
+const resolveWorkspacePattern = (repoRoot, pattern) => ResultAsync.fromPromise(
+// For now it is not possible to use the fs.glob function (from node:fs/promises)
+// because it is not possible to run it on Node 20.x
+glob.glob(pattern, { cwd: repoRoot }), (cause) => new Error(`Failed to resolve workspace glob: ${pattern}`, {
+    cause,
+})).map((subDirectories) => 
+// Create the absolute path to the subdirectory
+subDirectories.map((directory) => path.join(repoRoot, directory)));
+const getWorkspaces = (repoRoot) => readFile(path.join(repoRoot, "pnpm-workspace.yaml"))
+    .andThen(parseYaml)
+    // Decode the pnpm-workspace.yaml file to a zod schema
+    .andThen((obj) => 
+// If no packages are defined, go on with an empty array
+decode(z.object({ packages: z.array(z.string()) }))(obj).orElse(() => okAsync({ packages: [] })))
+    .andThen(({ packages }) => 
+// For every package pattern in the pnpm-workspace.yaml file, get the list of subdirectories
+ResultAsync.combine(packages.map((pattern) => resolveWorkspacePattern(repoRoot, pattern)))
+    .map((workspacesList) => workspacesList.flat())
+    .andThen((workspaceFolders) => {
+    // For every subdirectory, read the package.json file and decode it to a zod schema
+    const workspaceResults = workspaceFolders.map((nodeWorkspaceDirectory) => readFileAndDecode(path.join(nodeWorkspaceDirectory, "package.json"), packageJsonSchema).map(({ name }) => 
+    // Create the workspace object using the package.json name and the nodeWorkspaceDirectory
+    workspaceSchema.parse({ name, path: nodeWorkspaceDirectory })));
+    // Execute and combine the results
+    return ResultAsync.combine(workspaceResults);
+}));
+export const makeRepositoryReader = () => ({
+    fileExists,
+    findRepositoryRoot,
+    getWorkspaces,
+    readFile,
+});

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

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