@pagopa/dx-cli 0.15.1 → 0.15.3

package/dist/adapters/codemods/__tests__/use-azure-appsvc.test.js

@@ -0,0 +1,77 @@
+import { describe, expect, it } from "vitest";
+import { migrateWorkflow } from "../use-azure-appsvc.js";
+describe("migrateWorkflow", () => {
+    const sha = "testsha";
+    const migrate = migrateWorkflow(sha);
+    it("adds disable_auto_staging_deploy under with for web_app_deploy", () => {
+        const input = `
+jobs:
+  deploy:
+    uses: pagopa/dx/.github/workflows/web_app_deploy.yaml@main
+    with:
+      web_app_name: my-app
+      use_staging_slot: true
+`;
+        const output = migrate(input, "workflow.yaml");
+        expect(output).toContain("disable_auto_staging_deploy: true");
+    });
+    it("adds disable_auto_staging_deploy under with for function_app_deploy", () => {
+        const input = `
+jobs:
+  deploy:
+    uses: pagopa/dx/.github/workflows/function_app_deploy.yaml@main
+    with:
+      function_app_name: my-func
+      use_staging_slot: true
+`;
+        const output = migrate(input, "workflow.yaml");
+        expect(output).toContain("disable_auto_staging_deploy: true");
+    });
+    it("renames function_app_name to web_app_name", () => {
+        const input = `
+jobs:
+  deploy:
+    uses: pagopa/dx/.github/workflows/function_app_deploy.yaml@main
+    with:
+      function_app_name: my-func
+`;
+        const output = migrate(input, "workflow.yaml");
+        expect(output).toContain("web_app_name: my-func");
+        expect(output).not.toContain("function_app_name:");
+    });
+    it("removes use_staging_slot", () => {
+        const input = `
+jobs:
+  deploy:
+    uses: pagopa/dx/.github/workflows/web_app_deploy.yaml@main
+    with:
+      web_app_name: my-app
+      use_staging_slot: true
+`;
+        const output = migrate(input, "workflow.yaml");
+        expect(output).not.toContain("use_staging_slot:");
+    });
+    it("updates uses to release-azure-appsvc.yaml@sha", () => {
+        const input = `
+jobs:
+  deploy:
+    uses: pagopa/dx/.github/workflows/web_app_deploy.yaml@main
+    with:
+      web_app_name: my-app
+`;
+        const output = migrate(input, "workflow.yaml");
+        expect(output).toContain(`uses: pagopa/dx/.github/workflows/release-azure-appsvc-v1.yaml@${sha}`);
+    });
+    it("does not change unrelated workflows", () => {
+        const input = `
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+`;
+        const output = migrate(input, "workflow.yaml");
+        expect(output).toBe(input);
+    });
+});

package/dist/adapters/codemods/__tests__/use-pnpm.test.d.ts

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

package/dist/adapters/codemods/__tests__/use-pnpm.test.js

@@ -0,0 +1,148 @@
+import { beforeEach, describe, expect, test, vi } from "vitest";
+import YAML from "yaml";
+import { extractPackageExtensions, NPM, preparePackageJsonForPnpm, usePnpm, writePnpmWorkspaceFile, Yarn, } from "../use-pnpm.js";
+const { readFile, stdout, writeFile } = vi.hoisted(() => ({
+    readFile: vi.fn(async () => ""),
+    stdout: vi.fn(),
+    writeFile: vi.fn(),
+}));
+vi.mock("execa", () => ({
+    $: vi.fn((opts) => {
+        const hasOptions = typeof opts === "object" && Object.hasOwn(opts, "lines");
+        if (hasOptions) {
+            return () => stdout().then((output) => ({
+                stdout: output.split("\n"),
+            }));
+        }
+        return stdout().then((output) => ({
+            stdout: output,
+        }));
+    }),
+}));
+vi.mock("node:fs/promises", () => ({
+    default: {
+        appendFile: () => Promise.resolve(),
+        readFile,
+        rm: () => Promise.resolve(),
+        stat: () => Promise.resolve({
+            isFile: () => true,
+        }),
+        writeFile,
+    },
+}));
+vi.mock("../git.js", async () => ({
+    getLatestCommitShaOrRef: async () => "dummy-sha",
+}));
+describe("pm", () => {
+    test("yarn workspaces are parsed correctly", async () => {
+        const yarn = new Yarn();
+        stdout.mockResolvedValueOnce(`{"location":".","name":"io-messages"}\n{"location":"apps/citizen-func","name":"citizen-func"}`);
+        const workspaces = await yarn.listWorkspaces();
+        expect(workspaces).toEqual(["io-messages", "citizen-func"]);
+    });
+    test("npm workspaces are parsed correctly", async () => {
+        const npm = new NPM();
+        stdout.mockResolvedValueOnce(`[{ "name": "io-messages", "location": "." },{ "name": "citizen-func", "location": "apps/citizen-func" }]`);
+        const workspaces = await npm.listWorkspaces();
+        expect(workspaces).toEqual(["io-messages", "citizen-func"]);
+    });
+});
+describe("extractPackageExtensions", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    test("returns packageExtensions only if present", async () => {
+        const yarnrc = {
+            packageExtensions: {
+                "some-package@*": {
+                    peerDependencies: {
+                        react: "*",
+                    },
+                },
+            },
+        };
+        readFile.mockResolvedValueOnce(YAML.stringify(yarnrc));
+        await expect(extractPackageExtensions()).resolves.toEqual(yarnrc.packageExtensions);
+        expect(readFile).toHaveBeenCalledOnce();
+    });
+    test("returns undefined if packageExtensions is not present", async () => {
+        const yarnrc = {
+            someOtherField: {},
+        };
+        readFile.mockResolvedValueOnce(YAML.stringify(yarnrc));
+        await expect(extractPackageExtensions()).resolves.toBeUndefined();
+        expect(readFile).toHaveBeenCalledOnce();
+    });
+});
+describe("preparePackageJsonForPnpm", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    test("removes packageManager field and keeps workspaces", async () => {
+        const packageJson = {
+            name: "test-monorepo",
+            packageManager: "yarn@1.22.10",
+            version: "1.0.0",
+            workspaces: ["packages/*"],
+        };
+        readFile.mockResolvedValueOnce(JSON.stringify(packageJson, null, 2));
+        const workspaces = await preparePackageJsonForPnpm();
+        expect(workspaces).toEqual(["packages/*"]);
+        expect(readFile).toHaveBeenCalledOnce();
+        expect(writeFile).toHaveBeenCalledWith("package.json", JSON.stringify({
+            name: packageJson.name,
+            version: packageJson.version,
+        }, null, 2));
+    });
+});
+describe("writePnpmWorkspaceFile", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    test("writes pnpm-workspace.yaml with given workspaces", async () => {
+        const workspaces = ["packages/*", "apps/*"];
+        const packageExtensions = {
+            "express@*": {
+                peerDependencies: {
+                    typescript: "*",
+                },
+            },
+        };
+        await writePnpmWorkspaceFile(workspaces, packageExtensions);
+        expect(writeFile).toHaveBeenCalledWith("pnpm-workspace.yaml", expect.stringContaining(YAML.stringify({ packages: workspaces })), "utf-8");
+        expect(writeFile).toHaveBeenCalledWith("pnpm-workspace.yaml", expect.stringContaining(YAML.stringify({ packageExtensions })), "utf-8");
+    });
+});
+describe("usePnpm", () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+    });
+    test("rejects if the project is already using pnpm", async () => {
+        await expect(usePnpm("pnpm", "10.20")).rejects.toThrow();
+    });
+    test.each([
+        { expected: false, version: "18.0.0" },
+        { expected: false, version: "20.10.0" },
+        { expected: false, version: "20.19.4" },
+        { expected: true, version: "22.0.0" },
+        { expected: true, version: "20.19.5" },
+    ])("rejects if Node.js version is less than required ($version)", async ({ expected, version }) => {
+        stdout.mockResolvedValue("[]");
+        readFile.mockResolvedValueOnce(JSON.stringify({ name: "test-monorepo", workspaces: [] }));
+        await expect(usePnpm("npm", version).then(() => true, () => false)).resolves.toBe(expected);
+    });
+    test("moves workspaces from package.json to pnpm-workspace.yaml", async () => {
+        const packageJson = {
+            name: "test-monorepo",
+            packageManager: "yarn@1.22.10",
+            version: "1.0.0",
+            workspaces: ["packages/*"],
+        };
+        readFile.mockResolvedValueOnce(JSON.stringify(packageJson, null, 2));
+        stdout.mockResolvedValue(`[]`); // npm list workspaces
+        await usePnpm("npm", "22.0.0");
+        expect(writeFile).toHaveBeenNthCalledWith(2, "pnpm-workspace.yaml", expect.stringContaining(YAML.stringify({
+            packages: packageJson.workspaces,
+        })), "utf-8");
+    });
+});

package/dist/adapters/codemods/git.d.ts

@@ -0,0 +1,2 @@
+export declare const getLatestCommitSha: (owner: string, repo: string, ref?: string) => Promise<string>;
+export declare const getLatestCommitShaOrRef: (owner: string, repo: string, ref?: string) => Promise<string>;

package/dist/adapters/codemods/git.js

@@ -0,0 +1,18 @@
+import { getLogger } from "@logtape/logtape";
+import { Octokit } from "octokit";
+export const getLatestCommitSha = async (owner, repo, ref = "main") => {
+    const octokit = new Octokit();
+    const response = await octokit.rest.repos.getCommit({
+        owner,
+        ref,
+        repo,
+    });
+    return response.data.sha;
+};
+export const getLatestCommitShaOrRef = async (owner, repo, ref = "main") => {
+    const logger = getLogger(["dx-cli", "codemod"]);
+    return getLatestCommitSha(owner, repo, ref).catch(() => {
+        logger.warn("Failed to fetch the latest commit from {owner}/{repo}, fallback to {fallback}", { fallback: ref, owner, repo });
+        return ref;
+    });
+};

package/dist/adapters/codemods/index.d.ts

@@ -0,0 +1,3 @@
+import { LocalCodemodRegistry } from "./registry.js";
+declare const registry: LocalCodemodRegistry;
+export default registry;

package/dist/adapters/codemods/index.js

@@ -0,0 +1,9 @@
+import { LocalCodemodRegistry } from "./registry.js";
+import { updateCodeReview } from "./update-code-review.js";
+import { useAzureAppsvc } from "./use-azure-appsvc.js";
+import usePnpm from "./use-pnpm.js";
+const registry = new LocalCodemodRegistry();
+registry.add(usePnpm);
+registry.add(useAzureAppsvc);
+registry.add(updateCodeReview);
+export default registry;

package/dist/adapters/codemods/registry.d.ts

@@ -0,0 +1,8 @@
+import { Codemod, CodemodRegistry } from "../../domain/codemod.js";
+export declare class LocalCodemodRegistry implements CodemodRegistry {
+    #private;
+    constructor();
+    add(codemod: Codemod): void;
+    getAll(): import("neverthrow").ResultAsync<Codemod[], never>;
+    getById(id: string): import("neverthrow").ResultAsync<Codemod | undefined, never>;
+}

package/dist/adapters/codemods/registry.js

@@ -0,0 +1,16 @@
+import { okAsync } from "neverthrow";
+export class LocalCodemodRegistry {
+    #m;
+    constructor() {
+        this.#m = new Map();
+    }
+    add(codemod) {
+        this.#m.set(codemod.id, codemod);
+    }
+    getAll() {
+        return okAsync(Array.from(this.#m.values()));
+    }
+    getById(id) {
+        return okAsync(this.#m.get(id));
+    }
+}

package/dist/adapters/codemods/update-code-review.d.ts

@@ -0,0 +1,3 @@
+import { Codemod } from "../../domain/codemod.js";
+export declare const updateJSCodeReviewJob: (sha: string) => (workflow: string, filename: string) => string;
+export declare const updateCodeReview: Codemod;

package/dist/adapters/codemods/update-code-review.js

@@ -0,0 +1,60 @@
+import { getLogger } from "@logtape/logtape";
+import { replaceInFile } from "replace-in-file";
+import * as YAML from "yaml";
+import { getLatestCommitSha } from "./git.js";
+import { isChildOf } from "./yaml.js";
+export const updateJSCodeReviewJob = (sha) => (workflow, filename) => {
+    const logger = getLogger(["dx-cli", "codemod"]);
+    const document = YAML.parseDocument(workflow);
+    let updated = false;
+    YAML.visit(document, {
+        Map(_, map, path) {
+            if (map.has("jobs") || isChildOf(path, "jobs")) {
+                return undefined;
+            }
+            if (map.has("uses")) {
+                const uses = map.get("uses");
+                if (typeof uses === "string" &&
+                    uses.startsWith("pagopa/dx/.github/workflows/js_code_review.yaml@")) {
+                    map.set("secrets", "inherit");
+                    map.set("permissions", {
+                        contents: "read",
+                        "pull-requests": "write",
+                    });
+                    map.set("uses", `pagopa/dx/.github/workflows/js_code_review.yaml@${sha}`);
+                    updated = true;
+                }
+            }
+            return YAML.visit.SKIP;
+        },
+    });
+    if (updated) {
+        logger.info("Workflow {filename} updated", {
+            filename,
+        });
+        return YAML.stringify(document);
+    }
+    return workflow;
+};
+export const updateCodeReview = {
+    apply: async () => {
+        const logger = getLogger(["dx-cli", "codemod"]);
+        const owner = "pagopa";
+        const repo = "dx";
+        return getLatestCommitSha(owner, repo)
+            .then(async (sha) => {
+            await replaceInFile({
+                allowEmptyPaths: true,
+                files: [".github/workflows/*.yaml"],
+                processor: updateJSCodeReviewJob(sha),
+            });
+        })
+            .catch(() => {
+            logger.error("Failed to fetch the latest commit sha from {repository}", {
+                repository: `${owner}/${repo}`,
+            });
+        });
+    },
+    description: "Update js_code_review workflow to its latest version",
+    id: "update-code-review",
+};

package/dist/adapters/codemods/use-azure-appsvc.d.ts

@@ -0,0 +1,3 @@
+import { Codemod } from "../../domain/codemod.js";
+export declare const migrateWorkflow: (sha: string) => (workflow: string, filename: string) => string;
+export declare const useAzureAppsvc: Codemod;

package/dist/adapters/codemods/use-azure-appsvc.js

@@ -0,0 +1,84 @@
+import { getLogger } from "@logtape/logtape";
+import { replaceInFile } from "replace-in-file";
+import YAML from "yaml";
+import { getLatestCommitShaOrRef } from "./git.js";
+import { isChildOf } from "./yaml.js";
+export const migrateWorkflow = (sha) => (workflow, filename) => {
+    const logger = getLogger(["dx-cli", "codemod"]);
+    logger.debug("Processing {filename} file", { filename });
+    const document = YAML.parseDocument(workflow);
+    let updated = false;
+    /**
+     * Visit the YAML AST to find and update specific keys
+     * - Visit the tree until we find job with "uses" containing "web_app_deploy" or "function_app_deploy"
+     * - Add "disable_auto_staging_deploy: true" under "with"
+     * - Rename "function_app_name" to "web_app_name"
+     * - Remove "use_staging_slot"
+     * - Update "uses" to point to "pagopa/dx/.github/workflows/release-azure-appsvc.yaml@LATEST_SHA"
+     */
+    YAML.visit(document, {
+        Map(_, map, path) {
+            if (isChildOf(path, "jobs") || isChildOf(path, "with")) {
+                return undefined;
+            }
+            if (map.has("jobs")) {
+                return undefined;
+            }
+            if (map.has("uses")) {
+                const uses = map.get("uses");
+                if (typeof uses === "string" &&
+                    uses.match(/^pagopa\/dx\/.github\/workflows\/(web|function)_app_deploy/)) {
+                    logger.debug("Adding disable_auto_staging_deploy");
+                    map.addIn(["with", "disable_auto_staging_deploy"], true);
+                    map.set("permissions", {
+                        attestations: "write",
+                        contents: "read",
+                        "id-token": "write",
+                    });
+                    updated = true;
+                    return undefined;
+                }
+            }
+            return YAML.visit.SKIP;
+        },
+        Pair(_, pair) {
+            if (YAML.isScalar(pair.key)) {
+                if (pair.key.value === "function_app_name") {
+                    updated = true;
+                    logger.debug("Updating function_app_name to web_app_name");
+                    return new YAML.Pair("web_app_name", pair.value);
+                }
+                if (pair.key.value === "use_staging_slot") {
+                    updated = true;
+                    logger.debug("Removing use_staging_slot");
+                    return YAML.visit.REMOVE;
+                }
+                if (pair.key.value === "uses") {
+                    updated = true;
+                    logger.debug("Updating uses value");
+                    return new YAML.Pair("uses", `pagopa/dx/.github/workflows/release-azure-appsvc-v1.yaml@${sha}`);
+                }
+            }
+        },
+    });
+    if (updated) {
+        logger.info("Workflow {filename} updated", {
+            filename,
+        });
+        return YAML.stringify(document);
+    }
+    logger.debug("No changes applied to {filename}", { filename });
+    return workflow;
+};
+export const useAzureAppsvc = {
+    apply: async () => {
+        const sha = await getLatestCommitShaOrRef("pagopa", "dx");
+        await replaceInFile({
+            allowEmptyPaths: true,
+            files: [".github/workflows/*.yaml"],
+            processor: migrateWorkflow(sha),
+        });
+    },
+    description: "Refactor legacy deploy workflows to use release-azure-appsvc",
+    id: "use-azure-appsvc",
+};

package/dist/adapters/codemods/use-pnpm.d.ts

@@ -0,0 +1,22 @@
+type NodePackageManager = {
+    listWorkspaces(): Promise<string[]>;
+    lockFileName: string;
+};
+export declare class NPM implements NodePackageManager {
+    lockFileName: string;
+    listWorkspaces(): Promise<string[]>;
+}
+export declare class Yarn implements NodePackageManager {
+    lockFileName: string;
+    listWorkspaces(): Promise<string[]>;
+}
+export declare function extractPackageExtensions(): Promise<object | undefined>;
+export declare function preparePackageJsonForPnpm(): Promise<string[]>;
+export declare function writePnpmWorkspaceFile(workspaces: string[], packageExtensions: object | undefined): Promise<void>;
+export declare const usePnpm: (packageManager: string, currentNodeVersion: string) => Promise<void>;
+declare const _default: {
+    apply: (info: import("../../domain/info.js").InfoResult) => Promise<void>;
+    description: string;
+    id: string;
+};
+export default _default;