@pagopa/dx-cli 0.4.1 → 0.4.3

package/bin/index.js

@@ -167,6 +167,40 @@ var checkTurboConfig = async (dependencies, config2) => {
   });
 };
 
+// src/domain/workspace.ts
+import { ok as ok3 } from "neverthrow";
+import { z as z2 } from "zod/v4";
+var WorkspaceName = z2.string().min(1).brand();
+var workspaceSchema = z2.object({
+  name: WorkspaceName,
+  path: z2.string()
+});
+var checkWorkspaces = async (dependencies, monorepoDir) => {
+  const { repositoryReader: repositoryReader2 } = dependencies;
+  const checkName = "Workspaces";
+  const workspacesResult = await repositoryReader2.getWorkspaces(monorepoDir);
+  if (workspacesResult.isErr()) {
+    return ok3({
+      checkName,
+      errorMessage: "Something is wrong with the workspaces configuration. If you need help, please contact the DevEx team.",
+      isValid: false
+    });
+  }
+  const { length: workspaceNumber } = workspacesResult.value;
+  if (workspaceNumber === 0) {
+    return ok3({
+      checkName,
+      errorMessage: "No workspace configuration found. Make sure to configure workspaces in pnpm-workspace.yaml.",
+      isValid: false
+    });
+  }
+  return ok3({
+    checkName,
+    isValid: true,
+    successMessage: `Found ${workspaceNumber} workspace${workspaceNumber === 1 ? "" : "s"}`
+  });
+};
+
 // src/domain/doctor.ts
 var runDoctor = (dependencies, config2) => {
   const doctorChecks = [
@@ -181,6 +215,10 @@ var runDoctor = (dependencies, config2) => {
     ResultAsync3.fromPromise(
       checkMonorepoScripts(dependencies, config2),
       () => new Error("Error checking monorepo scripts")
+    ),
+    ResultAsync3.fromPromise(
+      checkWorkspaces(dependencies, config2.repository.root),
+      () => new Error("Error checking monorepo scripts")
     )
   ];
   return ResultAsync3.combine(doctorChecks).match(
@@ -247,8 +285,9 @@ var detectPackageManager = async (dependencies, config2) => {
   const packageManager = dependencies.packageJson.packageManager ?? await detectFromLockFile(dependencies, config2);
   return packageManager ?? "npm";
 };
-var detectNodeVersion = async ({ repositoryReader: repositoryReader2 }, nodeVersionFilePath) => await repositoryReader2.readFile(nodeVersionFilePath).unwrapOr(void 0);
+var detectNodeVersion = async ({ repositoryReader: repositoryReader2 }, nodeVersionFilePath) => await repositoryReader2.readFile(nodeVersionFilePath).map((nodeVersion) => nodeVersion.trim()).unwrapOr(void 0);
 var detectTerraformVersion = async ({ repositoryReader: repositoryReader2 }, terraformVersionFilePath) => await repositoryReader2.readFile(terraformVersionFilePath).map((tfVersion) => tfVersion.trim()).unwrapOr(void 0);
+var detectTurboVersion = ({ devDependencies }) => devDependencies.get("turbo")?.trim();
 var getInfo = async (dependencies, config2) => ({
   node: await detectNodeVersion(
     { repositoryReader: dependencies.repositoryReader },
@@ -256,9 +295,10 @@ var getInfo = async (dependencies, config2) => ({
   ),
   packageManager: await detectPackageManager(dependencies, config2),
   terraform: await detectTerraformVersion(
-    dependencies,
+    { repositoryReader: dependencies.repositoryReader },
     `${config2.repository.root}/.terraform-version`
-  )
+  ),
+  turbo: detectTurboVersion(dependencies.packageJson)
 });
 var printInfo = (result) => {
   const logger2 = getLogger("json");
@@ -278,7 +318,7 @@ import { Command as Command3 } from "commander";
 import { getLogger as getLogger2 } from "@logtape/logtape";
 function printVersion() {
   const logger2 = getLogger2(["dx-cli", "version"]);
-  logger2.info(`dx CLI version: ${"0.4.1"}`);
+  logger2.info(`dx CLI version: ${"0.4.3"}`);
 }
 
 // src/adapters/commander/commands/version.ts
@@ -287,7 +327,7 @@ var makeVersionCommand = () => new Command3().name("version").alias("v").action(
 // src/adapters/commander/index.ts
 var makeCli = (deps2, config2) => {
   const program2 = new Command4();
-  program2.name("dx").description("The CLI for DX-Platform").version("0.4.1");
+  program2.name("dx").description("The CLI for DX-Platform").version("0.4.3");
   program2.addCommand(makeDoctorCommand(deps2, config2));
   program2.addCommand(makeVersionCommand());
   program2.addCommand(makeInfoCommand(deps2, config2));
@@ -305,18 +345,6 @@ var makeValidationReporter = () => {
       } else {
         logger2.error(`\u274C ${result.errorMessage}`);
       }
-    },
-    reportValidationResult(result) {
-      if (result.isOk()) {
-        const validation = result.value;
-        if (validation.isValid) {
-          logger2.info(`\u2705 ${validation.successMessage}`);
-        } else {
-          logger2.error(`\u274C ${validation.errorMessage}`);
-        }
-      } else {
-        logger2.error(`\u274C ${result.error.message}`);
-      }
     }
   };
 };
@@ -326,26 +354,32 @@ import { join as join2 } from "path";
 import * as process3 from "process";
 
 // src/adapters/node/fs/file-reader.ts
-import { Result, ResultAsync as ResultAsync4 } from "neverthrow";
+import { ResultAsync as ResultAsync5 } from "neverthrow";
 import fs2 from "fs/promises";
-var readFile = (filePath) => ResultAsync4.fromPromise(
+
+// src/adapters/zod/index.ts
+import { ResultAsync as ResultAsync4 } from "neverthrow";
+var decode = (schema) => ResultAsync4.fromThrowable(
+  schema.parseAsync,
+  (cause) => new Error("File content is not valid for the given schema", { cause })
+);
+
+// src/adapters/node/json/index.ts
+import { Result } from "neverthrow";
+var parseJson = Result.fromThrowable(
+  JSON.parse,
+  (cause) => new Error("Failed to parse JSON", { cause })
+);
+
+// src/adapters/node/fs/file-reader.ts
+var readFile = (filePath) => ResultAsync5.fromPromise(
   fs2.readFile(filePath, "utf-8"),
   (cause) => new Error(`Failed to read file: ${filePath}`, { cause })
 );
-var readFileAndDecode = (filePath, schema) => {
-  const decode = ResultAsync4.fromThrowable(
-    schema.parseAsync,
-    () => new Error("File content is not valid for the given schema")
-  );
-  const toJSON = Result.fromThrowable(
-    JSON.parse,
-    () => new Error("Failed to parse JSON")
-  );
-  return readFile(filePath).andThen(toJSON).andThen(decode);
-};
-var fileExists = (path) => ResultAsync4.fromPromise(
-  fs2.stat(path),
-  () => new Error(`${path} not found.`)
+var readFileAndDecode = (filePath, schema) => readFile(filePath).andThen(parseJson).andThen(decode(schema));
+var fileExists = (path2) => ResultAsync5.fromPromise(
+  fs2.stat(path2),
+  () => new Error(`${path2} not found.`)
 ).map(() => true);
 
 // src/adapters/node/package-json.ts
@@ -373,18 +407,73 @@ var makePackageJsonReader = () => ({
 });
 
 // src/adapters/node/repository.ts
-import { join as join3 } from "path";
+import * as glob from "glob";
+import { okAsync, ResultAsync as ResultAsync6 } from "neverthrow";
+import * as path from "path";
+import { z as z3 } from "zod/v4";
+
+// src/adapters/yaml/index.ts
+import { Result as Result2 } from "neverthrow";
+import yaml from "yaml";
+var parseYaml = Result2.fromThrowable(
+  (content) => yaml.parse(content),
+  () => new Error("Failed to parse YAML")
+);
+
+// src/adapters/node/repository.ts
 var findRepositoryRoot = (dir = process.cwd()) => {
-  const gitPath = join3(dir, ".git");
+  const gitPath = path.join(dir, ".git");
   return fileExists(gitPath).mapErr(
     () => new Error(
       "Could not find repository root. Make sure to have the repo initialized."
     )
   ).map(() => dir);
 };
+var resolveWorkspacePattern = (repoRoot2, pattern) => ResultAsync6.fromPromise(
+  // For now it is not possible to use the fs.glob function (from node:fs/promises)
+  // because it is not possible to run it on Node 20.x
+  glob.glob(pattern, { cwd: repoRoot2 }),
+  (cause) => new Error(`Failed to resolve workspace glob: ${pattern}`, {
+    cause
+  })
+).map(
+  (subDirectories) => (
+    // Create the absolute path to the subdirectory
+    subDirectories.map((directory) => path.join(repoRoot2, directory))
+  )
+);
+var getWorkspaces = (repoRoot2) => readFile(path.join(repoRoot2, "pnpm-workspace.yaml")).andThen(parseYaml).andThen(
+  (obj) => (
+    // If no packages are defined, go on with an empty array
+    decode(z3.object({ packages: z3.array(z3.string()) }))(obj).orElse(
+      () => okAsync({ packages: [] })
+    )
+  )
+).andThen(
+  ({ packages }) => (
+    // For every package pattern in the pnpm-workspace.yaml file, get the list of subdirectories
+    ResultAsync6.combine(
+      packages.map((pattern) => resolveWorkspacePattern(repoRoot2, pattern))
+    ).map((workspacesList) => workspacesList.flat()).andThen((workspaceFolders) => {
+      const workspaceResults = workspaceFolders.map(
+        (nodeWorkspaceDirectory) => readFileAndDecode(
+          path.join(nodeWorkspaceDirectory, "package.json"),
+          packageJsonSchema
+        ).map(
+          ({ name }) => (
+            // Create the workspace object using the package.json name and the nodeWorkspaceDirectory
+            workspaceSchema.parse({ name, path: nodeWorkspaceDirectory })
+          )
+        )
+      );
+      return ResultAsync6.combine(workspaceResults);
+    })
+  )
+);
 var makeRepositoryReader = () => ({
   fileExists,
   findRepositoryRoot,
+  getWorkspaces,
   readFile
 });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pagopa/dx-cli",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "type": "module",
   "description": "A CLI useful to manage DX tools.",
   "repository": {
@@ -22,8 +22,10 @@
     "@logtape/logtape": "^1.0.0",
     "commander": "^14.0.0",
     "core-js": "^3.44.0",
+    "glob": "^11.0.3",
     "neverthrow": "^8.2.0",
     "semver": "^7.7.2",
+    "yaml": "^2.8.0",
     "zod": "^3.25.28"
   },
   "devDependencies": {
@@ -31,7 +33,8 @@
     "@types/node": "^22.16.2",
     "@types/semver": "^7.7.0",
     "@vitest/coverage-v8": "^3.2.4",
-    "eslint": "^9.31.0",
+    "eslint": "^9.30.0",
+    "memfs": "^4.23.0",
     "prettier": "3.6.2",
     "tsup": "^8.5.0",
     "typescript": "~5.8.3",