@pagopa/dx-cli 0.15.2 → 0.15.4

package/dist/adapters/plop/helpers/__tests__/resource-prefix.test.js

@@ -0,0 +1,113 @@
+import { describe, expect, it } from "vitest";
+import { resourcePrefix } from "../resource-prefix.js";
+const createMockPayload = (overrides = {}) => ({
+    env: {
+        cloudAccounts: [],
+        name: "dev",
+        prefix: "dx",
+    },
+    workspace: {
+        domain: "",
+    },
+    ...overrides,
+});
+describe("resourcePrefix", () => {
+    it("should return prefix with env prefix and environment short code when domain is empty", () => {
+        const payload = createMockPayload({
+            env: {
+                cloudAccounts: [],
+                name: "dev",
+                prefix: "dx",
+            },
+            workspace: {
+                domain: "",
+            },
+        });
+        const result = resourcePrefix(payload);
+        expect(result).toBe("dx-d");
+    });
+    it("should return prefix with env prefix, environment short code, and domain when domain is provided", () => {
+        const payload = createMockPayload({
+            env: {
+                cloudAccounts: [],
+                name: "dev",
+                prefix: "dx",
+            },
+            workspace: {
+                domain: "api",
+            },
+        });
+        const result = resourcePrefix(payload);
+        expect(result).toBe("dx-d-api");
+    });
+    it("should handle prod environment with short code 'p'", () => {
+        const payload = createMockPayload({
+            env: {
+                cloudAccounts: [],
+                name: "prod",
+                prefix: "pgo",
+            },
+            workspace: {
+                domain: "core",
+            },
+        });
+        const result = resourcePrefix(payload);
+        expect(result).toBe("pgo-p-core");
+    });
+    it("should handle uat environment with short code 'u'", () => {
+        const payload = createMockPayload({
+            env: {
+                cloudAccounts: [],
+                name: "uat",
+                prefix: "test",
+            },
+            workspace: {
+                domain: "web",
+            },
+        });
+        const result = resourcePrefix(payload);
+        expect(result).toBe("test-u-web");
+    });
+    it("should convert result to lowercase", () => {
+        const payload = createMockPayload({
+            env: {
+                cloudAccounts: [
+                    {
+                        csp: "azure",
+                        defaultLocation: "westeurope",
+                        displayName: "Test Account",
+                        id: "test-account-id",
+                    },
+                ],
+                name: "prod",
+                prefix: "UPPER",
+            },
+            workspace: {
+                domain: "DOMAIN",
+            },
+        });
+        const result = resourcePrefix(payload);
+        expect(result).toBe("upper-p-domain");
+    });
+    it("should handle different prefix lengths", () => {
+        const payload = createMockPayload({
+            env: {
+                cloudAccounts: [
+                    {
+                        csp: "azure",
+                        defaultLocation: "westeurope",
+                        displayName: "Test Account",
+                        id: "test-account-id",
+                    },
+                ],
+                name: "dev",
+                prefix: "ab",
+            },
+            workspace: {
+                domain: "",
+            },
+        });
+        const result = resourcePrefix(payload);
+        expect(result).toBe("ab-d");
+    });
+});

package/dist/adapters/plop/helpers/env-short.d.ts

@@ -0,0 +1,3 @@
+import { type NodePlopAPI } from "node-plop";
+declare const _default: (plop: NodePlopAPI) => void;
+export default _default;

package/dist/adapters/plop/helpers/env-short.js

@@ -0,0 +1,9 @@
+import * as assert from "node:assert/strict";
+import { environmentSchema, environmentShort, } from "../../../domain/environment.js";
+export default (plop) => {
+    plop.setHelper("envShort", (ctx) => {
+        const result = environmentSchema.shape.name.safeParse(ctx);
+        assert.ok(result.success, "envShort: Invalid Environment name provided");
+        return environmentShort[result.data];
+    });
+};

package/dist/adapters/plop/helpers/resource-prefix.d.ts

@@ -0,0 +1,5 @@
+import { type NodePlopAPI } from "node-plop";
+import { Payload } from "../generators/environment/prompts.js";
+export declare const resourcePrefix: (payload: Pick<Payload, "env" | "workspace">) => string;
+declare const _default: (plop: NodePlopAPI) => void;
+export default _default;

package/dist/adapters/plop/helpers/resource-prefix.js

@@ -0,0 +1,18 @@
+import * as assert from "node:assert/strict";
+import { environmentShort } from "../../../domain/environment.js";
+import { payloadSchema } from "../generators/environment/prompts.js";
+export const resourcePrefix = (payload) => {
+    const { env, workspace } = payload;
+    const prefix = [env.prefix, environmentShort[env.name]];
+    if (workspace.domain) {
+        prefix.push(workspace.domain);
+    }
+    return prefix.join("-").toLowerCase();
+};
+export default (plop) => {
+    plop.setHelper("resourcePrefix", (ctx) => {
+        const result = payloadSchema.safeParse(ctx);
+        assert.ok(result.success, "resourcePrefix: Invalid payload provided");
+        return resourcePrefix(result.data);
+    });
+};

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

@@ -0,0 +1,8 @@
+import type { NodePlopAPI } from "plop";
+import { Result, ResultAsync } from "neverthrow";
+import { PlopGenerator } from "node-plop";
+export declare const initPlop: () => ResultAsync<NodePlopAPI, Error>;
+export declare const getGenerator: (plopAPI: NodePlopAPI) => (name: string) => Result<PlopGenerator, Error>;
+export declare const getPrompts: (generator: PlopGenerator) => ResultAsync<any, Error>;
+export declare const setMonorepoGenerator: (plop: NodePlopAPI) => void;
+export declare const setDeploymentEnvironmentGenerator: (plop: NodePlopAPI) => void;

package/dist/adapters/plop/index.js

@@ -0,0 +1,24 @@
+import { DefaultAzureCredential } from "@azure/identity";
+import { Result, ResultAsync } from "neverthrow";
+import nodePlop from "node-plop";
+import path from "node:path";
+import { Octokit } from "octokit";
+import { AzureSubscriptionRepository } from "../azure/cloud-account-repository.js";
+import { AzureCloudAccountService } from "../azure/cloud-account-service.js";
+import createDeploymentEnvironmentGenerator from "../plop/generators/environment/index.js";
+import createMonorepoGenerator from "../plop/generators/monorepo/index.js";
+export const initPlop = () => ResultAsync.fromPromise(nodePlop(), () => new Error("Failed to initialize plop"));
+export const getGenerator = (plopAPI) => Result.fromThrowable(plopAPI.getGenerator, () => new Error("Generator not found"));
+export const getPrompts = (generator) => ResultAsync.fromPromise(generator.runPrompts(), (cause) => new Error("Failed to run the generator prompts", { cause }));
+export const setMonorepoGenerator = (plop) => {
+    const octokit = new Octokit({ auth: process.env.GITHUB_TOKEN });
+    const templatesPath = path.join(import.meta.dirname, "../../../templates/monorepo");
+    createMonorepoGenerator(plop, templatesPath, octokit);
+};
+export const setDeploymentEnvironmentGenerator = (plop) => {
+    const credential = new DefaultAzureCredential();
+    const cloudAccountRepository = new AzureSubscriptionRepository(credential);
+    const cloudAccountService = new AzureCloudAccountService(credential);
+    const templatesPath = path.join(import.meta.dirname, "../../../templates/environment");
+    createDeploymentEnvironmentGenerator(plop, templatesPath, cloudAccountRepository, cloudAccountService);
+};

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

@@ -0,0 +1 @@
+export declare function formatTerraformCode(sourceCode: string): Promise<string>;

package/dist/adapters/terraform/fmt.js

@@ -0,0 +1,17 @@
+import { getLogger } from "@logtape/logtape";
+import { execa } from "execa";
+export async function formatTerraformCode(sourceCode) {
+    try {
+        const result = await execa({
+            input: sourceCode.trim(),
+        })("terraform", ["fmt", "-"]);
+        return result.stdout;
+    }
+    catch {
+        const logger = getLogger(["gen", "env"]);
+        logger.error("Failed to format Terraform code. {sourceCode}", {
+            sourceCode,
+        });
+        throw new Error("Failed to format Terraform code");
+    }
+}

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

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

package/dist/adapters/yaml/__tests__/index.test.js

@@ -0,0 +1,53 @@
+import { err, ok } from "neverthrow";
+import { describe, expect, it } from "vitest";
+import { parseYaml } from "../index.js";
+describe("parseYaml", () => {
+    const yamlContent = `
+packages:
+  - packages/*
+  - apps/*
+  - infra/modules/*
+
+catalog:
+  prettier: 3.6.2
+  eslint: ^9.30.1
+  typescript: ~5.8.3
+  tsup: ^8.5.0
+  vitest: ^3.2.4
+  '@vitest/coverage-v8': ^3.2.4
+  '@tsconfig/node20': ^20.1.6
+  '@types/node': ^20.19.4
+
+onlyBuiltDependencies:
+  - esbuild
+
+packageImportMethod: clone-or-copy
+`;
+    it("should parse valid YAML content", () => {
+        const result = parseYaml(yamlContent);
+        expect(result).toStrictEqual(ok({
+            catalog: {
+                "@tsconfig/node20": "^20.1.6",
+                "@types/node": "^20.19.4",
+                "@vitest/coverage-v8": "^3.2.4",
+                eslint: "^9.30.1",
+                prettier: "3.6.2",
+                tsup: "^8.5.0",
+                typescript: "~5.8.3",
+                vitest: "^3.2.4",
+            },
+            onlyBuiltDependencies: ["esbuild"],
+            packageImportMethod: "clone-or-copy",
+            packages: ["packages/*", "apps/*", "infra/modules/*"],
+        }));
+    });
+    it("should parse empty YAML content", () => {
+        const yamlContent = "";
+        const result = parseYaml(yamlContent);
+        expect(result).toStrictEqual(ok(null));
+    });
+    it("should return an error for invalid YAML content", () => {
+        const result = parseYaml("invalid: yaml: content: here");
+        expect(result).toStrictEqual(err(new Error("Failed to parse YAML")));
+    });
+});

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

@@ -0,0 +1,8 @@
+import { Result } from "neverthrow";
+/**
+ * Parses YAML content and returns the parsed object.
+ *
+ * @param content - The YAML content to parse
+ * @returns Result with parsed YAML object or error
+ */
+export declare const parseYaml: (content: string) => Result<any, Error>;

package/dist/adapters/yaml/index.js

@@ -0,0 +1,9 @@
+import { Result } from "neverthrow";
+import yaml from "yaml";
+/**
+ * Parses YAML content and returns the parsed object.
+ *
+ * @param content - The YAML content to parse
+ * @returns Result with parsed YAML object or error
+ */
+export const parseYaml = Result.fromThrowable((content) => yaml.parse(content), () => new Error("Failed to parse YAML"));

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

@@ -0,0 +1,23 @@
+import { ResultAsync } from "neverthrow";
+import { z } from "zod/v4";
+/**
+ * A utility function to decode and validate data against a given Zod schema.
+ *
+ * @template T - The type of the data to be validated.
+ * @param {z.ZodSchema<T>} schema - The Zod schema used to validate the data.
+ * @returns {(data: unknown) => ResultAsync<T, Error>} - A function that takes unknown data,
+ * validates it asynchronously against the schema, and returns a `ResultAsync` object.
+ *
+ * The `ResultAsync` object:
+ * - Resolves with the validated data of type `T` if the validation succeeds.
+ * - Rejects with an `Error` if the validation fails, including the cause of the failure.
+ *
+ * @example
+ * const schema = z.object({ name: z.string() });
+ * const decodeName = decode(schema);
+ *
+ * decodeName({ name: "John" })
+ *   .map((data) => console.log("Valid data:", data))
+ *   .mapErr((err) => console.error("Validation error:", err));
+ */
+export declare const decode: <T>(schema: z.ZodSchema<T>) => (data: unknown) => ResultAsync<T, Error>;

package/dist/adapters/zod/index.js

@@ -0,0 +1,22 @@
+import { ResultAsync } from "neverthrow";
+/**
+ * A utility function to decode and validate data against a given Zod schema.
+ *
+ * @template T - The type of the data to be validated.
+ * @param {z.ZodSchema<T>} schema - The Zod schema used to validate the data.
+ * @returns {(data: unknown) => ResultAsync<T, Error>} - A function that takes unknown data,
+ * validates it asynchronously against the schema, and returns a `ResultAsync` object.
+ *
+ * The `ResultAsync` object:
+ * - Resolves with the validated data of type `T` if the validation succeeds.
+ * - Rejects with an `Error` if the validation fails, including the cause of the failure.
+ *
+ * @example
+ * const schema = z.object({ name: z.string() });
+ * const decodeName = decode(schema);
+ *
+ * decodeName({ name: "John" })
+ *   .map((data) => console.log("Valid data:", data))
+ *   .mapErr((err) => console.error("Validation error:", err));
+ */
+export const decode = (schema) => (data) => ResultAsync.fromPromise(schema.parseAsync(data), (cause) => new Error("Input is not valid for the given schema", { cause }));

package/dist/config.d.ts

@@ -0,0 +1,6 @@
+export type Config = {
+    minVersions: {
+        turbo: string;
+    };
+};
+export declare const getConfig: () => Config;

package/dist/config.js

@@ -0,0 +1,5 @@
+export const getConfig = () => ({
+    minVersions: {
+        turbo: "2",
+    },
+});

package/dist/domain/__tests__/data.d.ts

@@ -0,0 +1,17 @@
+import { Octokit } from "octokit";
+import { DeepMockProxy, MockProxy } from "vitest-mock-extended";
+import { Config } from "../../config.js";
+import { GitHubService } from "../github.js";
+import { PackageJson, PackageJsonReader } from "../package-json.js";
+import { RepositoryReader } from "../repository.js";
+import { ValidationReporter } from "../validation.js";
+export declare const makeMockPackageJson: (overrides?: Partial<PackageJson>) => PackageJson;
+export declare const makeMockDependencies: () => {
+    gitHubService: MockProxy<GitHubService>;
+    octokit: DeepMockProxy<Octokit>;
+    packageJsonReader: MockProxy<PackageJsonReader>;
+    repositoryReader: MockProxy<RepositoryReader>;
+    validationReporter: MockProxy<ValidationReporter>;
+};
+export declare const makeMockConfig: () => Config;
+export declare const makeMockRepositoryRoot: () => string;

package/dist/domain/__tests__/data.js

@@ -0,0 +1,27 @@
+import { mock, mockDeep } from "vitest-mock-extended";
+export const makeMockPackageJson = (overrides = {}) => {
+    const basePackageJson = {
+        dependencies: new Map(),
+        devDependencies: new Map(),
+        name: "test-package",
+        packageManager: "pnpm",
+        scripts: new Map(),
+    };
+    return {
+        ...basePackageJson,
+        ...overrides,
+    };
+};
+export const makeMockDependencies = () => ({
+    gitHubService: mock(),
+    octokit: mockDeep(),
+    packageJsonReader: mock(),
+    repositoryReader: mock(),
+    validationReporter: mock(),
+});
+export const makeMockConfig = () => ({
+    minVersions: {
+        turbo: "2.5.0",
+    },
+});
+export const makeMockRepositoryRoot = () => "a/repo/root";

package/dist/domain/__tests__/environment.test.d.ts

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