@pagopa/dx-cli 0.18.13 → 0.19.1

package/dist/adapters/commander/commands/__tests__/{init.test.js → add.test.js}

@@ -5,7 +5,7 @@ import { errAsync, okAsync } from "neverthrow";
 import { describe, expect, it } from "vitest";
 import { mock } from "vitest-mock-extended";
 import { AuthorizationError, AuthorizationResult, IdentityAlreadyExistsError, } from "../../../../domain/authorization.js";
-import { authorizeCloudAccounts } from "../init.js";
+import { authorizeCloudAccounts } from "../add.js";
 const makeEnvPayload = (overrides = {}) => ({
     env: {
         cloudAccounts: [

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

@@ -8,4 +8,14 @@
  * - environment: Add a new deployment environment to the project
  */
 import { Command } from "commander";
-export declare const makeAddCommand: () => Command;
+import { ResultAsync } from "neverthrow";
+import type { Payload as EnvironmentPayload } from "../../plop/generators/environment/index.js";
+import { AuthorizationResult, AuthorizationService } from "../../../domain/authorization.js";
+/**
+ * Authorize a Cloud Account (Azure Subscription, AWS Account, ...), creating a Pull Request for each account that requires authorization.
+ */
+export declare const authorizeCloudAccounts: (authorizationService: AuthorizationService) => (envPayload: EnvironmentPayload) => ResultAsync<AuthorizationResult[], never>;
+export type AddCommandDependencies = {
+    authorizationService: AuthorizationService;
+};
+export declare const makeAddCommand: (deps: AddCommandDependencies) => Command;

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

@@ -1,3 +1,5 @@
+import { getLogger } from "@logtape/logtape";
+import chalk from "chalk";
 /**
  * Add command - Scaffold new components into existing workspaces
  *
@@ -8,20 +10,82 @@
  * - environment: Add a new deployment environment to the project
  */
 import { Command } from "commander";
-import { ResultAsync } from "neverthrow";
+import { okAsync, ResultAsync } from "neverthrow";
+import { requestAuthorizationInputSchema, } from "../../../domain/authorization.js";
+import { environmentShort } from "../../../domain/environment.js";
+import { isAzureLocation, locationShort } from "../../azure/locations.js";
 import { getPlopInstance, runDeploymentEnvironmentGenerator, } from "../../plop/index.js";
 import { checkPreconditions } from "./init.js";
-const addEnvironmentAction = () => checkPreconditions()
+/**
+ * Authorize a Cloud Account (Azure Subscription, AWS Account, ...), creating a Pull Request for each account that requires authorization.
+ */
+export const authorizeCloudAccounts = (authorizationService) => (envPayload) => {
+    const accountsToInitialize = envPayload.init?.cloudAccountsToInitialize ?? [];
+    if (accountsToInitialize.length === 0) {
+        return okAsync([]);
+    }
+    const logger = getLogger(["dx-cli", "add-environment"]);
+    const { name, prefix } = envPayload.env;
+    const envShort = environmentShort[name];
+    const requestAll = async () => {
+        const results = [];
+        for (const account of accountsToInitialize) {
+            if (!isAzureLocation(account.defaultLocation)) {
+                logger.warn("Skipping authorization for {account}: unsupported location", { account: account.displayName });
+                continue;
+            }
+            const locShort = locationShort[account.defaultLocation];
+            const input = requestAuthorizationInputSchema.safeParse({
+                bootstrapIdentityId: `${prefix}-${envShort}-${locShort}-bootstrap-id-01`,
+                repoName: envPayload.github.repo,
+                subscriptionName: account.displayName,
+            });
+            if (!input.success) {
+                logger.warn("Skipping authorization for {account}: invalid input", {
+                    account: account.displayName,
+                });
+                continue;
+            }
+            const result = await authorizationService.requestAuthorization(input.data);
+            result.match((authResult) => results.push(authResult), (error) => logger.warn("Authorization request failed for {account}: {error}", {
+                account: account.displayName,
+                error: error.message,
+            }));
+        }
+        return results;
+    };
+    return ResultAsync.fromPromise(requestAll(), () => []).orElse(() => okAsync([]));
+};
+const displaySummary = (result) => {
+    const { authorizationPrs } = result;
+    console.log(chalk.green.bold("\nCloud environment created successfully!"));
+    let step = 1;
+    console.log(chalk.green.bold("\nNext Steps:"));
+    if (authorizationPrs.length > 0) {
+        console.log(`${step++}. Review the Azure authorization Pull Request(s):`);
+        for (const authPr of authorizationPrs) {
+            console.log(`   - ${chalk.underline(authPr.url)}`);
+        }
+    }
+    console.log(`${step}. Visit ${chalk.underline("https://dx.pagopa.it/getting-started")} to deploy your first project\n`);
+};
+const addEnvironmentAction = (authorizationService) => checkPreconditions()
     .andThen(() => ResultAsync.fromPromise(getPlopInstance(), () => new Error("Failed to initialize plop")))
-    .andThen((plop) => ResultAsync.fromPromise(runDeploymentEnvironmentGenerator(plop), () => new Error("Failed to run the deployment environment generator")));
-export const makeAddCommand = () => new Command()
+    .andThen((plop) => ResultAsync.fromPromise(runDeploymentEnvironmentGenerator(plop), () => new Error("Failed to run the deployment environment generator")))
+    .andThen((payload) => authorizeCloudAccounts(authorizationService)(payload).map((authorizationPrs) => ({
+    authorizationPrs,
+})));
+export const makeAddCommand = (deps) => new Command()
     .name("add")
     .description("Add a new component to your workspace")
     .addCommand(new Command("environment")
     .description("Add a new deployment environment")
     .action(async function () {
-    const result = await addEnvironmentAction();
+    const result = await addEnvironmentAction(deps.authorizationService);
     if (result.isErr()) {
         this.error(result.error.message);
     }
+    else {
+        displaySummary(result.value);
+    }
 }));

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

@@ -1,7 +1,5 @@
 import { Command } from "commander";
 import { ResultAsync } from "neverthrow";
-import type { Payload as EnvironmentPayload } from "../../plop/generators/environment/index.js";
-import { AuthorizationResult, AuthorizationService } from "../../../domain/authorization.js";
 import { GitHubService } from "../../../domain/github.js";
 export declare const checkPreconditions: () => ResultAsync<import("execa").Result<{
     environment: {
@@ -11,13 +9,8 @@ export declare const checkPreconditions: () => ResultAsync<import("execa").Resul
     };
     shell: true;
 }>, Error>;
-/**
- * Authorize a Cloud Account (Azure Subscription, AWS Account, ...), creating a Pull Request for each account that requires authorization.
- */
-export declare const authorizeCloudAccounts: (authorizationService: AuthorizationService) => (envPayload: EnvironmentPayload) => ResultAsync<AuthorizationResult[], never>;
 type InitCommandDependencies = {
-    authorizationService: AuthorizationService;
     gitHubService: GitHubService;
 };
-export declare const makeInitCommand: ({ authorizationService, gitHubService, }: InitCommandDependencies) => Command;
+export declare const makeInitCommand: ({ gitHubService, }: InitCommandDependencies) => Command;
 export {};

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

@@ -6,12 +6,9 @@ import { okAsync, ResultAsync } from "neverthrow";
 import * as path from "node:path";
 import { oraPromise } from "ora";
 import { z } from "zod";
-import { requestAuthorizationInputSchema, } from "../../../domain/authorization.js";
-import { environmentShort } from "../../../domain/environment.js";
 import { Repository, } from "../../../domain/github.js";
-import { isAzureLocation, locationShort } from "../../azure/locations.js";
 import { tf$ } from "../../execa/terraform.js";
-import { getPlopInstance, runDeploymentEnvironmentGenerator, runMonorepoGenerator, } from "../../plop/index.js";
+import { getPlopInstance, runMonorepoGenerator } from "../../plop/index.js";
 import { exitWithError } from "../index.js";
 const withSpinner = (text, successText, failText, promise) => ResultAsync.fromPromise(oraPromise(promise, {
     failText,
@@ -19,7 +16,7 @@ const withSpinner = (text, successText, failText, promise) => ResultAsync.fromPr
     text,
 }), (cause) => new Error(failText, { cause }));
 const displaySummary = (initResult) => {
-    const { authorizationPrs, pr, repository } = initResult;
+    const { pr, repository } = initResult;
     console.log(chalk.green.bold("\nWorkspace created successfully!"));
     if (repository) {
         console.log(`- Name: ${chalk.cyan(repository.name)}`);
@@ -32,12 +29,6 @@ const displaySummary = (initResult) => {
         let step = 1;
         console.log(chalk.green.bold("\nNext Steps:"));
         console.log(`${step++}. Review the Pull Request in the GitHub repository: ${chalk.underline(pr.url)}`);
-        if (authorizationPrs.length > 0) {
-            console.log(`${step++}. Review the Azure authorization Pull Request(s):`);
-            for (const authPr of authorizationPrs) {
-                console.log(`   - ${chalk.underline(authPr.url)}`);
-            }
-        }
         console.log(`${step}. Visit ${chalk.underline("https://dx.pagopa.it/getting-started")} to deploy your first project\n`);
     }
     else {
@@ -123,65 +114,16 @@ const handleGeneratorError = (err) => {
     }
     return new Error("Failed to run the generator");
 };
-/**
- * Authorize a Cloud Account (Azure Subscription, AWS Account, ...), creating a Pull Request for each account that requires authorization.
- */
-export const authorizeCloudAccounts = (authorizationService) => (envPayload) => {
-    const accountsToInitialize = envPayload.init?.cloudAccountsToInitialize ?? [];
-    if (accountsToInitialize.length === 0) {
-        return okAsync([]);
-    }
-    const logger = getLogger(["dx-cli", "init"]);
-    const { name, prefix } = envPayload.env;
-    const envShort = environmentShort[name];
-    const requestAll = async () => {
-        const results = [];
-        for (const account of accountsToInitialize) {
-            if (!isAzureLocation(account.defaultLocation)) {
-                logger.warn("Skipping authorization for {account}: unsupported location", { account: account.displayName });
-                continue;
-            }
-            const locShort = locationShort[account.defaultLocation];
-            const input = requestAuthorizationInputSchema.safeParse({
-                bootstrapIdentityId: `${prefix}-${envShort}-${locShort}-bootstrap-id-01`,
-                repoName: envPayload.github.repo,
-                subscriptionName: account.displayName,
-            });
-            if (!input.success) {
-                logger.warn("Skipping authorization for {account}: invalid input", {
-                    account: account.displayName,
-                });
-                continue;
-            }
-            const result = await authorizationService.requestAuthorization(input.data);
-            result.match((authResult) => results.push(authResult), (error) => logger.warn("Authorization request failed for {account}: {error}", {
-                account: account.displayName,
-                error: error.message,
-            }));
-        }
-        return results;
-    };
-    return ResultAsync.fromPromise(requestAll(), () => []).orElse(() => okAsync([]));
-};
-export const makeInitCommand = ({ authorizationService, gitHubService, }) => new Command()
+export const makeInitCommand = ({ gitHubService, }) => new Command()
     .name("init")
     .description("Initialize a new DX workspace")
     .action(async function () {
     await checkPreconditions()
-        .andTee(() => {
-        console.log(chalk.blue.bold("\nWorkspace Info"));
-    })
         .andThen(() => ResultAsync.fromPromise(getPlopInstance(), () => new Error("Failed to initialize plop")))
-        .andThen((plop) => ResultAsync.fromPromise(runMonorepoGenerator(plop, gitHubService), handleGeneratorError)
+        .andThen((plop) => ResultAsync.fromPromise(runMonorepoGenerator(plop, gitHubService), handleGeneratorError))
         .andTee((payload) => {
         process.chdir(payload.repoName);
-        console.log(chalk.blue.bold("\nCloud Environment"));
     })
-        .andThen((monorepoPayload) => ResultAsync.fromPromise(runDeploymentEnvironmentGenerator(plop, {
-        owner: monorepoPayload.repoOwner,
-        repo: monorepoPayload.repoName,
-    }), handleGeneratorError).map((envPayload) => ({ envPayload, monorepoPayload }))))
-        .andTee(() => console.log()) // Print a new line before the gh repo creation logs
-        .andThen(({ envPayload, monorepoPayload }) => handleNewGitHubRepository(gitHubService)(monorepoPayload).andThen((repoPr) => authorizeCloudAccounts(authorizationService)(envPayload).map((authorizationPrs) => ({ ...repoPr, authorizationPrs }))))
+        .andThen((payload) => handleNewGitHubRepository(gitHubService)(payload))
         .match(displaySummary, exitWithError(this));
 });

package/dist/adapters/commander/index.js

@@ -13,7 +13,7 @@ export const makeCli = (deps, config, cliDeps, version) => {
     program.addCommand(makeInitCommand(deps));
     program.addCommand(makeSavemoneyCommand());
     program.addCommand(makeInfoCommand(deps));
-    program.addCommand(makeAddCommand());
+    program.addCommand(makeAddCommand(deps));
     return program;
 };
 export const exitWithError = (command) => (error) => {

package/dist/adapters/plop/actions/setup-pnpm.js

@@ -1,4 +1,4 @@
-import { $ } from "execa";
+import { $ as $_ } from "execa";
 import path from "node:path";
 import { payloadSchema } from "../generators/monorepo/prompts.js";
 export default function (plop) {
@@ -12,16 +12,16 @@ export default function (plop) {
             .filter(([key]) => !key.startsWith("npm_config_"))
             // Disable corepack download prompt
             .concat([["COREPACK_ENABLE_DOWNLOAD_PROMPT", "0"]]));
-        const pnpm$ = $({
+        const $ = $_({
             cwd,
             env,
             extendEnv: false, // Don't include process.env variables
         });
-        await pnpm$ `corepack enable`;
-        await pnpm$ `corepack use pnpm@latest`;
-        await pnpm$ `pnpm -w add -D turbo @changesets/cli @devcontainers/cli`;
-        await pnpm$ `pnpm changeset init`;
-        await pnpm$ `pnpm devcontainer templates apply -t ghcr.io/pagopa/devcontainer-templates/node:1`;
+        await $ `corepack enable`;
+        await $ `corepack use pnpm@latest`;
+        await $ `npx --yes nx@latest init --interactive=false --aiAgents=copilot`;
+        await $ `pnpm -w add -D @devcontainers/cli @nx/js @nx/eslint @nx/vitest`;
+        await $ `pnpm devcontainer templates apply -t ghcr.io/pagopa/devcontainer-templates/node:1`;
         return "Monorepo bootstrapped";
     });
 }

package/dist/config.d.ts

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

package/dist/config.js

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

package/dist/domain/__tests__/data.js

@@ -22,7 +22,7 @@ export const makeMockDependencies = () => ({
 });
 export const makeMockConfig = () => ({
     minVersions: {
-        turbo: "2.5.0",
+        nx: "22",
     },
 });
 export const makeMockRepositoryRoot = () => "a/repo/root";

package/dist/domain/__tests__/repository.test.js

@@ -1,6 +1,6 @@
 import { errAsync, ok, okAsync } from "neverthrow";
 import { describe, expect, it } from "vitest";
-import { checkPreCommitConfig, checkTurboConfig } from "../repository.js";
+import { checkNxConfig, checkPreCommitConfig } from "../repository.js";
 import { makeMockConfig, makeMockDependencies, makeMockRepositoryRoot, } from "./data.js";
 describe("checkPreCommitConfig", () => {
     it("should return ok result with successful validation when .pre-commit-config.yaml exists", async () => {
@@ -28,74 +28,84 @@ describe("checkPreCommitConfig", () => {
         }));
     });
 });
-describe("checkTurboConfig", () => {
+describe("checkNxConfig", () => {
     const config = makeMockConfig();
     const repositoryRoot = makeMockRepositoryRoot();
-    it("should return ok result with successful validation when turbo.json exists and turbo dependency is present", async () => {
+    it("should return ok result with successful validation when nx.json exists and nx dependency is present", async () => {
         const deps = makeMockDependencies();
         deps.repositoryReader.fileExists.mockReturnValueOnce(okAsync(true));
-        deps.packageJsonReader.getDependencies.mockReturnValueOnce(okAsync(new Map().set("turbo", "^2.5.2")));
-        const result = await checkTurboConfig(deps, repositoryRoot, config);
+        deps.packageJsonReader.getDependencies.mockReturnValueOnce(okAsync(new Map().set("nx", "^22.6.1")));
+        const result = await checkNxConfig(deps, repositoryRoot, config);
         expect(result).toStrictEqual(ok({
-            checkName: "Turbo Configuration",
+            checkName: "Nx Configuration",
             isValid: true,
-            successMessage: "Turbo configuration is present in the monorepo root and turbo dependency is installed",
+            successMessage: "Nx configuration is present in the monorepo root and Nx dependency is installed",
         }));
-        expect(deps.repositoryReader.fileExists).toHaveBeenCalledWith("a/repo/root/turbo.json");
+        expect(deps.repositoryReader.fileExists).toHaveBeenCalledWith("a/repo/root/nx.json");
     });
-    it("should return ok result with failed validation when turbo.json exists but turbo dependency is missing", async () => {
+    it("should return ok result with failed validation when nx.json exists but Nx dependency is missing", async () => {
         const deps = makeMockDependencies();
         deps.repositoryReader.fileExists.mockReturnValueOnce(okAsync(true));
         deps.packageJsonReader.getDependencies.mockReturnValueOnce(okAsync(new Map().set("eslint", "^8.0.0")));
-        const result = await checkTurboConfig(deps, repositoryRoot, config);
+        const result = await checkNxConfig(deps, repositoryRoot, config);
         expect(result).toStrictEqual(ok({
-            checkName: "Turbo Configuration",
-            errorMessage: "Turbo dependency not found in devDependencies. Please add 'turbo' to your devDependencies.",
+            checkName: "Nx Configuration",
+            errorMessage: "Nx dependency not found in devDependencies. Please add 'nx' to your devDependencies.",
             isValid: false,
         }));
     });
-    it("should return ok result with failed validation when turbo.json does not exist", async () => {
+    it("should return ok result with failed validation when nx.json does not exist", async () => {
         const deps = makeMockDependencies();
-        const errorMessage = "turbo.json not found in repository root. Make sure to have Turbo configured for the monorepo.";
+        const errorMessage = "nx.json not found in repository root. Make sure to have Nx configured for the monorepo.";
         deps.repositoryReader.fileExists.mockReturnValueOnce(errAsync(new Error(errorMessage)));
-        const result = await checkTurboConfig(deps, repositoryRoot, config);
+        const result = await checkNxConfig(deps, repositoryRoot, config);
         expect(result).toStrictEqual(ok({
-            checkName: "Turbo Configuration",
+            checkName: "Nx Configuration",
             errorMessage,
             isValid: false,
         }));
     });
-    it("should return the error message when turbo is not listed in devDependencies", async () => {
+    it("should return ok result with failed validation when fileExists returns ok(false)", async () => {
+        const deps = makeMockDependencies();
+        deps.repositoryReader.fileExists.mockReturnValueOnce(okAsync(false));
+        const result = await checkNxConfig(deps, repositoryRoot, config);
+        expect(result).toStrictEqual(ok({
+            checkName: "Nx Configuration",
+            errorMessage: "nx.json not found in repository root. Make sure to have Nx configured for the monorepo.",
+            isValid: false,
+        }));
+    });
+    it("should return the error message when nx is not listed in devDependencies", async () => {
         const deps = makeMockDependencies();
         deps.repositoryReader.fileExists.mockReturnValueOnce(okAsync(true));
         deps.packageJsonReader.getDependencies.mockReturnValueOnce(okAsync(new Map().set("eslint", "^8.0.0")));
-        const result = await checkTurboConfig(deps, repositoryRoot, config);
+        const result = await checkNxConfig(deps, repositoryRoot, config);
         expect(result).toStrictEqual(ok({
-            checkName: "Turbo Configuration",
-            errorMessage: "Turbo dependency not found in devDependencies. Please add 'turbo' to your devDependencies.",
+            checkName: "Nx Configuration",
+            errorMessage: "Nx dependency not found in devDependencies. Please add 'nx' to your devDependencies.",
             isValid: false,
         }));
     });
-    it("should return the error message when turbo version is less than minimum", async () => {
+    it("should return the error message when nx version is less than minimum", async () => {
         const deps = makeMockDependencies();
         deps.repositoryReader.fileExists.mockReturnValueOnce(okAsync(true));
-        deps.packageJsonReader.getDependencies.mockReturnValueOnce(okAsync(new Map().set("turbo", "1.0.0")));
-        const result = await checkTurboConfig(deps, repositoryRoot, config);
+        deps.packageJsonReader.getDependencies.mockReturnValueOnce(okAsync(new Map().set("nx", "1.0.0")));
+        const result = await checkNxConfig(deps, repositoryRoot, config);
         expect(result).toStrictEqual(ok({
-            checkName: "Turbo Configuration",
-            errorMessage: `Turbo version (1.0.0) is too low. Minimum required version is ${config.minVersions.turbo}.`,
+            checkName: "Nx Configuration",
+            errorMessage: `Nx version (1.0.0) is too low. Minimum required version is ${config.minVersions.nx}.`,
             isValid: false,
         }));
     });
-    it("should return the success message when turbo version is ok", async () => {
+    it("should return the success message when nx version is ok", async () => {
         const deps = makeMockDependencies();
         deps.repositoryReader.fileExists.mockReturnValueOnce(okAsync(true));
-        deps.packageJsonReader.getDependencies.mockReturnValueOnce(okAsync(new Map().set("turbo", config.minVersions.turbo)));
-        const result = await checkTurboConfig(deps, repositoryRoot, config);
+        deps.packageJsonReader.getDependencies.mockReturnValueOnce(okAsync(new Map().set("nx", config.minVersions.nx)));
+        const result = await checkNxConfig(deps, repositoryRoot, config);
         expect(result).toStrictEqual(ok({
-            checkName: "Turbo Configuration",
+            checkName: "Nx Configuration",
             isValid: true,
-            successMessage: "Turbo configuration is present in the monorepo root and turbo dependency is installed",
+            successMessage: "Nx configuration is present in the monorepo root and Nx dependency is installed",
         }));
     });
 });

package/dist/domain/doctor.js

@@ -1,7 +1,6 @@
 import { ResultAsync } from "neverthrow";
 import { checkMonorepoScripts } from "./package-json.js";
-import { checkPreCommitConfig } from "./repository.js";
-import { checkTurboConfig } from "./repository.js";
+import { checkNxConfig, checkPreCommitConfig } from "./repository.js";
 import { checkWorkspaces } from "./workspace.js";
 export const runDoctor = async (dependencies, config) => {
     // Get repository root - doctor command requires being in a repository
@@ -21,9 +20,9 @@ export const runDoctor = async (dependencies, config) => {
     const repositoryRoot = repoRootResult.value;
     const doctorChecks = [
         ResultAsync.fromPromise(checkPreCommitConfig(dependencies, repositoryRoot), () => new Error("Error checking pre-commit configuration")),
-        ResultAsync.fromPromise(checkTurboConfig(dependencies, repositoryRoot, config), () => new Error("Error checking Turbo configuration")),
+        ResultAsync.fromPromise(checkNxConfig(dependencies, repositoryRoot, config), () => new Error("Error checking Nx configuration")),
         ResultAsync.fromPromise(checkMonorepoScripts(dependencies, repositoryRoot), () => new Error("Error checking monorepo scripts")),
-        ResultAsync.fromPromise(checkWorkspaces(dependencies, repositoryRoot), () => new Error("Error checking monorepo scripts")),
+        ResultAsync.fromPromise(checkWorkspaces(dependencies, repositoryRoot), () => new Error("Error checking workspaces")),
     ];
     return ResultAsync.combine(doctorChecks).match(toDoctorResult, () => ({
         checks: [],

package/dist/domain/repository.d.ts

@@ -10,4 +10,4 @@ export type RepositoryReader = {
     readFile(path: string): ResultAsync<string, Error>;
 };
 export declare const checkPreCommitConfig: (dependencies: Pick<Dependencies, "repositoryReader">, repositoryRoot: string) => Promise<ValidationCheckResult>;
-export declare const checkTurboConfig: (dependencies: Pick<Dependencies, "packageJsonReader" | "repositoryReader">, repositoryRoot: string, config: Config) => Promise<ValidationCheckResult>;
+export declare const checkNxConfig: (dependencies: Pick<Dependencies, "packageJsonReader" | "repositoryReader">, repositoryRoot: string, config: Config) => Promise<ValidationCheckResult>;

package/dist/domain/repository.js

@@ -30,14 +30,21 @@ export const checkPreCommitConfig = async (dependencies, repositoryRoot) => {
         isValid: false,
     });
 };
-export const checkTurboConfig = async (dependencies, repositoryRoot, config) => {
+export const checkNxConfig = async (dependencies, repositoryRoot, config) => {
     const { packageJsonReader, repositoryReader } = dependencies;
-    const checkName = "Turbo Configuration";
-    const turboResult = await repositoryReader.fileExists(fs.join(repositoryRoot, "turbo.json"));
-    if (turboResult.isErr()) {
+    const checkName = "Nx Configuration";
+    const nxResult = await repositoryReader.fileExists(fs.join(repositoryRoot, "nx.json"));
+    if (nxResult.isErr()) {
         return ok({
             checkName,
-            errorMessage: turboResult.error.message,
+            errorMessage: nxResult.error.message,
+            isValid: false,
+        });
+    }
+    if (!nxResult.value) {
+        return ok({
+            checkName,
+            errorMessage: "nx.json not found in repository root. Make sure to have Nx configured for the monorepo.",
             isValid: false,
         });
     }
@@ -49,24 +56,24 @@ export const checkTurboConfig = async (dependencies, repositoryRoot, config) =>
             isValid: false,
         });
     }
-    const turboVersion = dependenciesResult.value.get("turbo");
-    if (!turboVersion) {
+    const nxVersion = dependenciesResult.value.get("nx");
+    if (!nxVersion) {
         return ok({
             checkName,
-            errorMessage: "Turbo dependency not found in devDependencies. Please add 'turbo' to your devDependencies.",
+            errorMessage: "Nx dependency not found in devDependencies. Please add 'nx' to your devDependencies.",
             isValid: false,
         });
     }
-    if (!isVersionValid(turboVersion, config.minVersions.turbo)) {
+    if (!isVersionValid(nxVersion, config.minVersions.nx)) {
         return ok({
             checkName,
-            errorMessage: `Turbo version (${turboVersion}) is too low. Minimum required version is ${config.minVersions.turbo}.`,
+            errorMessage: `Nx version (${nxVersion}) is too low. Minimum required version is ${config.minVersions.nx}.`,
             isValid: false,
         });
     }
     return ok({
         checkName,
         isValid: true,
-        successMessage: "Turbo configuration is present in the monorepo root and turbo dependency is installed",
+        successMessage: "Nx configuration is present in the monorepo root and Nx dependency is installed",
     });
 };

package/package.json

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

package/templates/environment/bootstrapper/{{env.name}}/main.tf.hbs

@@ -1,3 +1,9 @@
+locals {
+  bootstrapper_tags = merge(local.tags, {
+    Source = "https://github.com/{{@root.github.owner}}/{{@root.github.repo}}/blob/main/infra/bootstrapper/{{@root.env.name}}"
+  })
+}
+
 {{#each cloudAccountsByCsp.azure}}
 {{#if (eq displayName "PROD-IO")}}
 module "azure-{{displayName}}_bootstrap" {
@@ -45,7 +51,7 @@ module "azure-{{displayName}}_bootstrap" {
   nat_gateway_resource_group_id      = data.azurerm_resource_group.common_itn_01.id
   opex_resource_group_id             = data.azurerm_resource_group.dashboards.id
 
-  tags = local.tags
+  tags = local.bootstrapper_tags
 }
 {{else}}
 module "azure-{{displayName}}_core_values" {
@@ -112,7 +118,7 @@ module "azure-{{displayName}}_bootstrap" {
   private_dns_zone_resource_group_id = module.azure-{{displayName}}_core_values.network_resource_group_id
   opex_resource_group_id             = module.azure-{{displayName}}_core_values.opex_resource_group_id
 
-  tags = local.tags
+  tags = local.bootstrapper_tags
 }
 {{/if}}
 {{/each}}

package/templates/environment/core/{{env.name}}/main.tf.hbs

@@ -12,7 +12,9 @@ module "azure-{{displayName}}_core" {
     app_name = "core"
   })
 
-  tags = local.tags
+  tags = merge(local.tags, {
+    Source = "https://github.com/{{@root.github.owner}}/{{@root.github.repo}}/blob/main/infra/core/{{@root.env.name}}"
+  })
 }
 
 {{/each}}

package/templates/monorepo/README.md.hbs

@@ -48,49 +48,38 @@ cd {{ repoName }}
 nodenv install
 ```
 
-3. Build all the workspaces contained by this repo
-```bash
-pnpm build
-```
-
-## Release management
+3. Install dependencies using `pnpm`
 
-We use [changesets](https://github.com/changesets/changesets) to automate package versioning and releases.
-
-Each Pull Request that includes changes that require a version bump must include a _changeset file_ that describes the introduced changes.
-
-To create a _changeset file_ run the following command and follow the instructions.
+```bashbash
+pnpm install
+```
 
+4. Build all the workspaces contained by this repo
 ```bash
-pnpm changeset
+pnpm nx run-many -t build
 ```
 
 ## Useful commands
 
-This project uses `pnpm` and `turbo` with workspaces to manage projects and dependencies. Here is a list of useful commands to work in this repo.
+This project uses `pnpm` and `nx` with workspaces to manage projects and dependencies. Here is a list of useful commands to work in this repo.
 
 ### Work with workspaces
 
 ```bash
-# build all the workspaces using turbo
-pnpm build
-# or
-pnpm turbo build
+# build all the workspaces using Nx
+pnpm nx run-many -t build
 
 # to execute COMMAND on WORKSPACE_NAME
 pnpm --filter WORKSPACE_NAME COMMAND
 # to execute COMMAND on all workspaces
 pnpm -r COMMAND
-
-# run the typecheck script on all workspaces
-pnpm -r typecheck
 ```
 
 ### Add dependencies
 
 ```bash
 # add a dependency to the workspace root
-pnpm -w add turbo
+pnpm -w add vitest
 
 # add vitest as devDependency on citizen-func
 pnpm --filter citizen-func add -D vitest
@@ -128,15 +117,22 @@ User documentation doesn't usually go in here. For public packages, it must go i
 
 ## Releases
 
-Releases are handled using [Changeset](https://github.com/changesets/changesets).
-Changeset takes care of bumping packages, updating the changelog, and tagging the repository accordingly.
+We use [Nx Release](https://nx.dev/features/manage-releases) to automate package versioning and releases.
+
+Each Pull Request that includes changes that require a version bump must include a _version plan file_ that describes the introduced changes.
+
+To create a _version plan file_ run the following command and follow the instructions.
+
+```bash
+pnpm nx release plan
+```
 
 #### How it works
 
-- When opening a Pull Request with a change intended to be published, [add a changeset file](https://github.com/changesets/changesets/blob/main/docs/adding-a-changeset.md) to the proposed changes.
-- Once the Pull Request is merged, a new Pull Request named `Version Packages` will be automatically opened with all the release changes such as version bumping for each involved app or package and changelog update; if an open `Version Packages` PR already exists, it will be updated and the package versions calculated accordingly (see https://github.com/changesets/changesets/blob/main/docs/decisions.md#how-changesets-are-combined).
-Only apps and packages mentioned in the changeset files will be bumped.
-- Review the `Version Packages` PR and merge it when ready. Changeset files will be deleted.
+- When opening a Pull Request with a change intended to be published, add a version plan file that describes the change and the version bump type (patch, minor, major) for each involved app or package.
+- Once the Pull Request is merged, a new Pull Request named `Version Packages` will be automatically opened with all the release changes such as version bumping for each involved app or package and changelog update; if an open `Version Packages` PR already exists, it will be updated and the package versions calculated accordingly.
+Only apps and packages mentioned in the version plan files will be bumped.
+- Review the `Version Packages` PR and merge it when ready. Version plan files will be deleted.
 - A Release entry is created for each app or package whose version has been bumped.
 
 ### Folder structure

package/templates/monorepo/nx.json

@@ -0,0 +1,79 @@
+{
+  "$schema": "./node_modules/nx/schemas/nx-schema.json",
+  "parallel": 10,
+  "targetDefaults": {
+    "lint": {
+      "dependsOn": ["^build"],
+      "options": {
+        "fix": true
+      },
+      "configurations": {
+        "ci": {
+          "fix": false
+        }
+      }
+    },
+    "test": {
+      "configurations": {
+        "ci": {
+          "coverage": true
+        }
+      }
+    }
+  },
+  "release": {
+    "versionPlans": true,
+    "projectsRelationship": "independent",
+    "version": {},
+    "changelog": {
+      "projectChangelogs": {
+        "createRelease": false,
+        "file": "{projectRoot}/CHANGELOG.md",
+        "renderOptions": {
+          "authors": true,
+          "applyUsernameToAuthors": true,
+          "commitReferences": true,
+          "versionTitleDate": true
+        }
+      }
+    },
+    "git": {
+      "commit": false,
+      "tag": true,
+      "stageChanges": false
+    },
+    "releaseTag": {
+      "pattern": "{projectName}@{version}"
+    }
+  },
+  "plugins": [
+    {
+      "plugin": "@nx/vitest",
+      "options": {
+        "testTargetName": "test"
+      },
+      "include": ["apps/**", "packages/**"]
+    },
+    {
+      "plugin": "@nx/eslint/plugin",
+      "options": {
+        "targetName": "lint"
+      }
+    },
+    {
+      "plugin": "@nx/js/typescript",
+      "options": {
+        "typecheck": {
+          "targetName": "typecheck"
+        },
+        "build": {
+          "targetName": "build",
+          "configName": "tsconfig.json",
+          "buildDepsName": "build-deps",
+          "watchDepsName": "watch-deps"
+        }
+      }
+    }
+  ],
+  "analytics": false
+}

package/templates/monorepo/pnpm-workspace.yaml

@@ -5,3 +5,6 @@ packages:
 linkWorkspacePackages: true
 packageImportMethod: "clone-or-copy"
 cleanupUnusedCatalogs: true
+
+onlyBuiltDependencies:
+  - nx

package/templates/monorepo/turbo.json

@@ -1,29 +0,0 @@
-{
-  "$schema": "https://turbo.build/schema.json",
-  "tasks": {
-    "build": {
-      "dependsOn": ["^build"],
-      "inputs": [],
-      "outputs": []
-    },
-    "typecheck": {
-      "dependsOn": ["^build"],
-      "inputs": []
-    },
-    "lint:check": {
-      "inputs": []
-    },
-    "format:check": {},
-    "test": {
-      "dependsOn": ["^build"],
-      "inputs": [],
-      "outputLogs": "errors-only"
-    },
-    "test:coverage": {
-      "dependsOn": ["^build"],
-      "inputs": [],
-      "outputs": ["coverage"],
-      "outputLogs": "errors-only"
-    }
-  }
-}