@pagopa/dx-cli 0.15.1 → 0.15.3

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

@@ -0,0 +1,214 @@
+import { getLogger } from "@logtape/logtape";
+import { $ } from "execa";
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import { replaceInFile } from "replace-in-file";
+import semver from "semver";
+import YAML from "yaml";
+import { getLatestCommitShaOrRef } from "./git.js";
+import { updateJSCodeReviewJob } from "./update-code-review.js";
+import { migrateWorkflow } from "./use-azure-appsvc.js";
+export class NPM {
+    lockFileName = "package-lock.json";
+    async listWorkspaces() {
+        const { stdout } = await $ `npm query .workspace`;
+        const workspaces = JSON.parse(stdout);
+        const workspaceNames = [];
+        if (Array.isArray(workspaces)) {
+            for (const ws of workspaces) {
+                if (Object.hasOwn(ws, "name")) {
+                    workspaceNames.push(ws.name);
+                }
+            }
+        }
+        return workspaceNames;
+    }
+}
+export class Yarn {
+    lockFileName = "yarn.lock";
+    async listWorkspaces() {
+        const { stdout } = await $({ lines: true }) `yarn workspaces list --json`;
+        const workspaceNames = [];
+        for (const line of stdout) {
+            const ws = JSON.parse(line);
+            if (Object.hasOwn(ws, "name")) {
+                workspaceNames.push(ws.name);
+            }
+        }
+        return workspaceNames;
+    }
+}
+export async function extractPackageExtensions() {
+    // Read the .yarnrc.yaml file if it exists and extract the packageExtensions field
+    try {
+        const yarnrc = await fs.readFile(".yarnrc.yml", "utf-8");
+        const parsed = YAML.parse(yarnrc);
+        if (parsed.packageExtensions) {
+            return parsed.packageExtensions;
+        }
+    }
+    catch {
+        // File does not exist or is not readable, ignore
+    }
+    return undefined;
+}
+export async function preparePackageJsonForPnpm() {
+    const packageJson = await fs.readFile("package.json", "utf-8");
+    const manifest = JSON.parse(packageJson);
+    let workspaces = [];
+    if (Object.hasOwn(manifest, "packageManager")) {
+        delete manifest.packageManager;
+    }
+    if (Object.hasOwn(manifest, "workspaces")) {
+        if (Array.isArray(manifest.workspaces)) {
+            workspaces = manifest.workspaces;
+        }
+        delete manifest.workspaces;
+    }
+    await fs.writeFile("package.json", JSON.stringify(manifest, null, 2));
+    return workspaces;
+}
+export async function writePnpmWorkspaceFile(workspaces, packageExtensions) {
+    // We inline all the default settings here because Renovate
+    // does not support PNPM's config dependencies yet.
+    const pnpmWorkspace = {
+        cleanupUnusedCatalogs: true,
+        linkWorkspacePackages: true,
+        packageExtensions,
+        packageImportMethod: "clone-or-copy",
+        packages: workspaces.length > 0 ? workspaces : ["apps/*", "packages/*"],
+    };
+    const yamlContent = YAML.stringify(pnpmWorkspace);
+    await fs.writeFile("pnpm-workspace.yaml", yamlContent, "utf-8");
+}
+async function removeFiles(...files) {
+    await Promise.all(files.map((file) => 
+    // Remove the file if it exists, fail silently if it doesn't.
+    fs.rm(file, { force: true, recursive: true }).catch(() => undefined)));
+}
+async function replacePMOccurrences() {
+    const logger = getLogger(["dx-cli", "codemod"]);
+    logger.info("Replacing yarn and npm occurrences in files...");
+    const results = await replaceInFile({
+        allowEmptyPaths: true,
+        files: ["**/*.json", "**/*.md", "**/Dockerfile", "**/docker-compose.yml"],
+        from: [
+            "https://yarnpkg.com/",
+            "https://classic.yarnpkg.com/",
+            /\b(yarn workspace|npm -(\b-workspace\b|\bw\b)) (\S+)\b/g,
+            /\b(yarn workspace|npm -(\b-workspace\b|\bw\b))\b/g,
+            /\b(yarn install --immutable|npm ci)\b/g,
+            /\b(yarn -q dlx|npx)\b/g,
+            /\b((yarn|npm) run)\b/g,
+            /(^|\s|")(yarn|npm)(?!\S)/gi,
+        ],
+        ignore: ["**/node_modules/**", "**/dist/**", "**/build/**"],
+        to: [
+            "https://pnpm.io/",
+            "https://pnpm.io/",
+            "pnpm --filter $3",
+            "pnpm --filter <package-selector>",
+            "pnpm install --frozen-lockfile",
+            "pnpm dlx",
+            "pnpm run",
+            "$1pnpm",
+        ],
+    });
+    const count = results.reduce((acc, file) => (file.hasChanged ? acc + 1 : acc), 0);
+    logger.info("Replaced yarn occurrences in {count} files", { count });
+}
+async function updateDXWorkflows() {
+    const logger = getLogger(["dx-cli", "codemod"]);
+    logger.info("Updating Github Workflows workflows...");
+    // Get the latest commit sha from the main branch of the dx repository
+    const sha = await getLatestCommitShaOrRef("pagopa", "dx");
+    // Update the js_code_review workflow to use the latest commit sha
+    const results = await replaceInFile({
+        allowEmptyPaths: true,
+        files: [".github/workflows/*.yaml"],
+        processor: updateJSCodeReviewJob(sha),
+    });
+    const ignore = results.filter((r) => r.hasChanged).map((r) => r.file);
+    // Update the legacy deployment workflow to release-azure-appsvc-v1.yaml
+    await replaceInFile({
+        allowEmptyPaths: true,
+        files: [".github/workflows/*.yaml"],
+        ignore,
+        processor: migrateWorkflow(sha),
+    });
+}
+export const usePnpm = async (packageManager, currentNodeVersion) => {
+    const minNodeVersion = "20.19.5";
+    assert.notEqual(packageManager, "pnpm", "Project is already using pnpm");
+    assert.ok(semver.gte(currentNodeVersion, minNodeVersion), `his codemod requires Node.js >= ${minNodeVersion}. Current version: ${currentNodeVersion}`);
+    const logger = getLogger(["dx-cli", "codemod"]);
+    const pm = packageManager === "yarn" ? new Yarn() : new NPM();
+    const localWorkspaces = await pm.listWorkspaces();
+    // Update local dependencies to use "workspace:" protocol
+    if (localWorkspaces.length > 0) {
+        logger.info("Using the {protocol} protocol for local dependencies", {
+            protocol: "workspace:",
+        });
+        await replaceInFile({
+            allowEmptyPaths: true,
+            files: ["**/package.json"],
+            from: localWorkspaces.map((ws) => new RegExp(`"${ws}": ".*?"`, "g")),
+            to: localWorkspaces.map((ws) => `"${ws}": "workspace:^"`),
+        });
+    }
+    // Remove unused field from package.json
+    logger.info("Remove unused fields from {file}", {
+        file: "package.json",
+    });
+    const workspaces = await preparePackageJsonForPnpm();
+    // Extract custom packageExtensions from .yarnrc.yml if any
+    const packageExtensions = packageManager === "yarn" ? await extractPackageExtensions() : undefined;
+    // Create pnpm-workspace.yaml
+    logger.info("Create {file}", {
+        file: "pnpm-workspace.yaml",
+    });
+    await writePnpmWorkspaceFile(workspaces, packageExtensions);
+    // Remove yarn and node_modules files and folders
+    logger.info("Remove node_modules and yarn files");
+    await removeFiles(".yarnrc", ".yarnrc.yml", "yarn.config.cjs", ".yarn", ".pnp.cjs", ".pnp.loader.cjs", "node_modules");
+    // Import lockfile
+    const stat = await fs.stat(pm.lockFileName);
+    if (stat.isFile()) {
+        logger.info("Importing {source} to {target}", {
+            source: pm.lockFileName,
+            target: "pnpm-lock.yaml",
+        });
+        await $ `corepack pnpm@latest import ${pm.lockFileName}`;
+        await removeFiles(pm.lockFileName);
+    }
+    else {
+        logger.info("No {source} file found, skipping import.", {
+            source: pm.lockFileName,
+        });
+    }
+    // Replace yarn and npm occurrences in files and update workflows
+    await replacePMOccurrences();
+    await updateDXWorkflows();
+    // Add pnpm store to .gitignore
+    logger.info("Adding pnpm store to .gitignore...");
+    await fs.appendFile(".gitignore", "\n\n# PNPM\n.pnpm-store");
+    // Set pnpm as the package manager
+    logger.info("Setting pnpm as the package manager...");
+    await $ `corepack use pnpm@latest`;
+};
+const apply = async (info) => {
+    const logger = getLogger(["dx-cli", "codemod"]);
+    try {
+        await usePnpm(info.packageManager, process.versions.node);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            logger.error(error.message);
+        }
+    }
+};
+export default {
+    apply,
+    description: "Migrate the project to use pnpm as the package manager",
+    id: "use-pnpm",
+};

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

@@ -0,0 +1,2 @@
+import * as YAML from "yaml";
+export declare const isChildOf: (path: Parameters<YAML.visitorFn<unknown>>[2], key: string) => boolean;

package/dist/adapters/codemods/yaml.js

@@ -0,0 +1,8 @@
+import * as YAML from "yaml";
+export const isChildOf = (path, key) => {
+    const ancestor = path.at(-1);
+    return (YAML.isPair(ancestor) &&
+        YAML.isScalar(ancestor.key) &&
+        typeof ancestor.key.value === "string" &&
+        ancestor.key.value === key);
+};

package/dist/adapters/commander/commands/codemod.d.ts

@@ -0,0 +1,8 @@
+import { Command } from "commander";
+import { ApplyCodemodById } from "../../../use-cases/apply-codemod.js";
+import { ListCodemods } from "../../../use-cases/list-codemods.js";
+export type CodemodCommandDependencies = {
+    applyCodemodById: ApplyCodemodById;
+    listCodemods: ListCodemods;
+};
+export declare const makeCodemodCommand: ({ applyCodemodById, listCodemods, }: CodemodCommandDependencies) => Command;

package/dist/adapters/commander/commands/codemod.js

@@ -0,0 +1,22 @@
+import { getLogger } from "@logtape/logtape";
+import { Command } from "commander";
+export const makeCodemodCommand = ({ applyCodemodById, listCodemods, }) => new Command("codemod")
+    .description("Manage and apply migration scripts to the repository")
+    .addCommand(new Command("list")
+    .description("List available migration scripts")
+    .action(async function () {
+    await listCodemods()
+        .andTee((codemods) => console.table(codemods, ["id", "description"]))
+        .orTee((error) => this.error(error.message));
+}))
+    .addCommand(new Command("apply")
+    .argument("<id>", "The id of the codemod to apply")
+    .description("Apply migration scripts to the repository")
+    .action(async function (id) {
+    const logger = getLogger(["dx-cli", "codemod"]);
+    await applyCodemodById(id)
+        .andTee(() => {
+        logger.info("Codemod applied ✅");
+    })
+        .orTee((error) => this.error(error.message));
+}));

package/dist/adapters/commander/commands/doctor.d.ts

@@ -0,0 +1,4 @@
+import { Command } from "commander";
+import { Config } from "../../../config.js";
+import { Dependencies } from "../../../domain/dependencies.js";
+export declare const makeDoctorCommand: (dependencies: Dependencies, config: Config) => Command;

package/dist/adapters/commander/commands/doctor.js

@@ -0,0 +1,12 @@
+import { Command } from "commander";
+import * as process from "node:process";
+import { printDoctorResult, runDoctor } from "../../../domain/doctor.js";
+export const makeDoctorCommand = (dependencies, config) => new Command()
+    .name("doctor")
+    .description("Verify the repository setup according to the DevEx guidelines")
+    .action(async () => {
+    const result = await runDoctor(dependencies, config);
+    printDoctorResult(dependencies, result);
+    const exitCode = result.hasErrors ? 1 : 0;
+    process.exit(exitCode);
+});

package/dist/adapters/commander/commands/info.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+import { Dependencies } from "../../../domain/dependencies.js";
+export declare const makeInfoCommand: (dependencies: Dependencies) => Command;

package/dist/adapters/commander/commands/info.js

@@ -0,0 +1,9 @@
+import { Command } from "commander";
+import { getInfo, printInfo } from "../../../domain/info.js";
+export const makeInfoCommand = (dependencies) => new Command()
+    .name("info")
+    .description("Display information about the project")
+    .action(async () => {
+    const result = await getInfo(dependencies)();
+    printInfo(result);
+});

package/dist/adapters/commander/commands/init.d.ts

@@ -0,0 +1,7 @@
+import { Command } from "commander";
+import { GitHubService } from "../../../domain/github.js";
+type InitCommandDependencies = {
+    gitHubService: GitHubService;
+};
+export declare const makeInitCommand: ({ gitHubService, }: InitCommandDependencies) => Command;
+export {};

package/dist/adapters/commander/commands/init.js

@@ -0,0 +1,126 @@
+import chalk from "chalk";
+import { Command } from "commander";
+import { $ } from "execa";
+import { errAsync, okAsync, ResultAsync } from "neverthrow";
+import * as path from "node:path";
+import { oraPromise } from "ora";
+import { Repository, RepositoryNotFoundError, } from "../../../domain/github.js";
+import { tf$ } from "../../execa/terraform.js";
+import { payloadSchema as answersSchema, PLOP_MONOREPO_GENERATOR_NAME, } from "../../plop/generators/monorepo/index.js";
+import { setMonorepoGenerator } from "../../plop/index.js";
+import { getGenerator, getPrompts, initPlop } from "../../plop/index.js";
+import { decode } from "../../zod/index.js";
+import { exitWithError } from "../index.js";
+const withSpinner = (text, successText, failText, promise) => ResultAsync.fromPromise(oraPromise(promise, {
+    failText,
+    successText,
+    text,
+}), (cause) => {
+    console.error(`Something went wrong: ${JSON.stringify(cause, null, 2)}`);
+    return new Error(failText, { cause });
+});
+// TODO: Check Cloud Environment exists
+// TODO: Check CSP CLI is installed
+// TODO: Check user has permissions to handle Terraform state
+const validateAnswers = (githubService) => (answers) => ResultAsync.fromPromise(githubService.getRepository(answers.repoOwner, answers.repoName), (error) => error)
+    .andThen(({ fullName }) => errAsync(new Error(`Repository ${fullName} already exists.`)))
+    .orElse((error) => error instanceof RepositoryNotFoundError
+    ? // If repository is not found, it's safe to proceed
+        okAsync(answers)
+    : // Otherwise, propagate the error
+        errAsync(error))
+    .map(() => answers);
+const runGeneratorActions = (generator) => (answers) => withSpinner("Creating workspace files...", "Workspace files created successfully!", "Failed to create workspace files.", generator.runActions(answers)).map(() => answers);
+const displaySummary = (initResult) => {
+    const { pr, repository } = initResult;
+    console.log(chalk.green.bold("\nWorkspace created successfully!"));
+    if (repository) {
+        console.log(`- Name: ${chalk.cyan(repository.name)}`);
+        console.log(`- GitHub Repository: ${chalk.cyan(repository.url)}\n`);
+    }
+    else {
+        console.log(chalk.yellow(`\n⚠️ GitHub repository may not have been created automatically.`));
+    }
+    if (pr) {
+        console.log(chalk.green.bold("\nNext Steps:"));
+        console.log(`1. Review the Pull Request in the GitHub repository: ${chalk.underline(pr.url)}`);
+        console.log(`2. Visit ${chalk.underline("https://dx.pagopa.it/getting-started")} to deploy your first project\n`);
+    }
+    else {
+        console.log(chalk.yellow(`\n⚠️ There was an error during Pull Request creation.`));
+        console.log(`Please, manually create a Pull Request in the GitHub repository to review the scaffolded code.\n`);
+    }
+};
+const checkTerraformCliIsInstalled = (text, successText, failText) => withSpinner(text, successText, failText, tf$ `terraform -version`);
+const checkPreconditions = () => checkTerraformCliIsInstalled("Checking Terraform CLI is installed...", "Terraform CLI is installed!", "Terraform CLI is not installed.");
+const createRemoteRepository = ({ repoName, repoOwner, }) => {
+    const cwd = path.resolve(repoName, "infra", "repository");
+    const applyTerraform = async () => {
+        await tf$({ cwd }) `terraform init`;
+        await tf$({ cwd }) `terraform apply -auto-approve`;
+    };
+    return withSpinner("Creating GitHub repository...", "GitHub repository created successfully!", "Failed to create GitHub repository.", applyTerraform()).map(() => new Repository(repoName, repoOwner));
+};
+const initializeGitRepository = (repository) => {
+    const cwd = path.resolve(repository.name);
+    const branchName = "features/scaffold-workspace";
+    const git$ = $({
+        cwd,
+        shell: true,
+    });
+    const pushToOrigin = async () => {
+        await git$ `git init`;
+        await git$ `git add README.md`;
+        await git$ `git commit --no-gpg-sign -m "Create README.md"`;
+        await git$ `git branch -M main`;
+        await git$ `git remote add origin ${repository.ssh}`;
+        await git$ `git push -u origin main`;
+        await git$ `git switch -c ${branchName}`;
+        await git$ `git add .`;
+        await git$ `git commit --no-gpg-sign -m "Scaffold workspace"`;
+        await git$ `git push -u origin ${branchName}`;
+    };
+    return withSpinner("Pushing code to GitHub...", "Code pushed to GitHub successfully!", "Failed to push code to GitHub.", pushToOrigin()).map(() => ({ branchName, repository }));
+};
+const handleNewGitHubRepository = (githubService) => (answers) => createRemoteRepository(answers)
+    .andThen(initializeGitRepository)
+    .andThen((localWorkspace) => createPullRequest(githubService)(localWorkspace).map((pr) => ({
+    pr,
+    repository: localWorkspace.repository,
+})));
+const makeInitResult = (answers, { pr, repository }) => ({
+    pr,
+    repository,
+});
+const createPullRequest = (githubService) => ({ branchName, repository, }) => withSpinner("Creating Pull Request...", "Pull Request created successfully!", "Failed to create Pull Request.", githubService.createPullRequest({
+    base: "main",
+    body: "This PR contains the scaffolded monorepo structure.",
+    head: branchName,
+    owner: repository.owner,
+    repo: repository.name,
+    title: "Scaffold repository",
+}))
+    // If PR creation fails, don't block the workflow
+    .orElse(() => okAsync(undefined));
+export const makeInitCommand = ({ gitHubService, }) => new Command()
+    .name("init")
+    .description("Command to initialize resources (like projects, subscriptions, ...)")
+    .addCommand(new Command("project")
+    .description("Initialize a new monorepo project")
+    .action(async function () {
+    await checkPreconditions()
+        .andThen(initPlop)
+        .andTee(setMonorepoGenerator)
+        .andThen((plop) => getGenerator(plop)(PLOP_MONOREPO_GENERATOR_NAME))
+        .andThen((generator) => 
+    // Ask the user the questions defined in the plop generator
+    getPrompts(generator)
+        // Decode the answers to match the Answers schema
+        .andThen(decode(answersSchema))
+        // Validate the answers (like checking permissions, checking GitHub user or org existence, etc.)
+        .andThen(validateAnswers(gitHubService))
+        // Run the generator with the provided answers (this will create the files locally)
+        .andThen(runGeneratorActions(generator)))
+        .andThen((answers) => handleNewGitHubRepository(gitHubService)(answers).map((repoPr) => makeInitResult(answers, repoPr)))
+        .match(displaySummary, exitWithError(this));
+}));

package/dist/adapters/commander/commands/savemoney.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const makeSavemoneyCommand: () => Command;

package/dist/adapters/commander/commands/savemoney.js

@@ -0,0 +1,26 @@
+import { azure, loadConfig } from "@pagopa/dx-savemoney";
+import { Command } from "commander";
+export const makeSavemoneyCommand = () => new Command("savemoney")
+    .description("Analyze Azure subscriptions and report unused or inefficient resources")
+    .option("-c, --config <path>", "Path to configuration file (JSON)")
+    .option("-f, --format <format>", "Report format: json, table, or detailed-json (default: table)", "table")
+    .option("-l, --location <string>", "Preferred Azure location for resources", "italynorth")
+    .option("-d, --days <number>", "Number of days for metrics analysis", "30")
+    .option("-v, --verbose", "Enable verbose logging")
+    .action(async function (options) {
+    try {
+        // Load configuration
+        const config = await loadConfig(options.config);
+        const finalConfig = {
+            ...config,
+            preferredLocation: options.location || config.preferredLocation,
+            timespanDays: Number.parseInt(options.days, 10) || config.timespanDays,
+            verbose: options.verbose || false,
+        };
+        // Run analysis
+        await azure.analyzeAzureResources(finalConfig, options.format);
+    }
+    catch (error) {
+        this.error(`Analysis failed: ${error instanceof Error ? error.message : error}`);
+    }
+});

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

@@ -0,0 +1,7 @@
+import { Command } from "commander";
+import { Config } from "../../config.js";
+import { Dependencies } from "../../domain/dependencies.js";
+import { CodemodCommandDependencies } from "./commands/codemod.js";
+export type CliDependencies = CodemodCommandDependencies;
+export declare const makeCli: (deps: Dependencies, config: Config, cliDeps: CliDependencies, version: string) => Command;
+export declare const exitWithError: (command: Command) => (error: Error) => never;

package/dist/adapters/commander/index.js

@@ -0,0 +1,19 @@
+import { Command } from "commander";
+import { makeCodemodCommand, } from "./commands/codemod.js";
+import { makeDoctorCommand } from "./commands/doctor.js";
+import { makeInfoCommand } from "./commands/info.js";
+import { makeInitCommand } from "./commands/init.js";
+import { makeSavemoneyCommand } from "./commands/savemoney.js";
+export const makeCli = (deps, config, cliDeps, version) => {
+    const program = new Command();
+    program.name("dx").description("The CLI for DX-Platform").version(version);
+    program.addCommand(makeDoctorCommand(deps, config));
+    program.addCommand(makeCodemodCommand(cliDeps));
+    program.addCommand(makeInitCommand(deps));
+    program.addCommand(makeSavemoneyCommand());
+    program.addCommand(makeInfoCommand(deps));
+    return program;
+};
+export const exitWithError = (command) => (error) => {
+    command.error(error.message);
+};

package/dist/adapters/execa/terraform.d.ts

@@ -0,0 +1,27 @@
+/**
+ * A pre-configured instance of the `execa` library for running Terraform commands.
+ *
+ * This instance is customized with specific environment variables and shell settings
+ * to ensure compatibility with Terraform automation workflows.
+ *
+ * Environment Variables:
+ * - `NO_COLOR`: Disables colored output to make logs cleaner and easier to parse.
+ * - `TF_IN_AUTOMATION`: Indicates that Terraform is running in an automated environment.
+ * - `TF_INPUT`: Disables interactive prompts, ensuring non-interactive execution.
+ *
+ * Configuration:
+ * - `shell: true`: Enables the use of the system shell for command execution.
+ *
+ * Usage:
+ * @example
+ * await tf$`terraform init`;
+ * await tf$`terraform apply -auto-approve`;
+ */
+export declare const tf$: import("execa").ExecaScriptMethod<{
+    environment: {
+        NO_COLOR: string;
+        TF_IN_AUTOMATION: string;
+        TF_INPUT: string;
+    };
+    shell: true;
+}>;

package/dist/adapters/execa/terraform.js

@@ -0,0 +1,28 @@
+import { $ } from "execa";
+/**
+ * A pre-configured instance of the `execa` library for running Terraform commands.
+ *
+ * This instance is customized with specific environment variables and shell settings
+ * to ensure compatibility with Terraform automation workflows.
+ *
+ * Environment Variables:
+ * - `NO_COLOR`: Disables colored output to make logs cleaner and easier to parse.
+ * - `TF_IN_AUTOMATION`: Indicates that Terraform is running in an automated environment.
+ * - `TF_INPUT`: Disables interactive prompts, ensuring non-interactive execution.
+ *
+ * Configuration:
+ * - `shell: true`: Enables the use of the system shell for command execution.
+ *
+ * Usage:
+ * @example
+ * await tf$`terraform init`;
+ * await tf$`terraform apply -auto-approve`;
+ */
+export const tf$ = $({
+    environment: {
+        NO_COLOR: "1",
+        TF_IN_AUTOMATION: "1",
+        TF_INPUT: "0",
+    },
+    shell: true,
+});

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

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

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

@@ -0,0 +1,67 @@
+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/github/github-repo.d.ts

@@ -0,0 +1,2 @@
+import { GitHubRepo } from "../../domain/github-repo.js";
+export declare const getGithubRepo: () => Promise<GitHubRepo | undefined>;

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

@@ -0,0 +1,31 @@
+import { $ } from "execa";
+import * as assert from "node:assert/strict";
+import { githubRepoSchema } from "../../domain/github-repo.js";
+export const getGithubRepo = async () => {
+    const result = await $ `git config --get remote.origin.url`;
+    const repoUrl = result.stdout.trim();
+    if (repoUrl === "") {
+        return undefined;
+    }
+    let owner;
+    let repo;
+    // Handle SSH URLs (git@github.com:owner/repo.git)
+    if (repoUrl.startsWith("git@github.com:")) {
+        const sshPattern = /^git@github\.com:([^/]+)\/(.+?)(?:\.git)?$/;
+        const match = repoUrl.match(sshPattern);
+        assert.ok(match, "Invalid GitHub SSH URL format");
+        [, owner, repo] = match;
+    }
+    else {
+        // Handle HTTPS URLs (https://github.com/owner/repo.git)
+        const url = new URL(repoUrl);
+        assert.equal(url.origin, "https://github.com", "Only GitHub repositories are supported");
+        const [, urlOwner, urlRepo] = url.pathname.split("/");
+        owner = urlOwner;
+        repo = urlRepo.replace(/\.git$/, "");
+    }
+    return githubRepoSchema.parse({
+        owner,
+        repo,
+    });
+};

package/dist/adapters/logtape/validation-reporter.d.ts

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