feat: workspace utils

README.md

@@ -125,6 +125,42 @@ import { findWorkspaceDir } from "pkg-types";
 const workspaceDir = await findWorkspaceDir(".");
 ```
 
+### `resolveWorkspace`
+
+Find monorepo workspace config (support: `pnpm`, `yarn`, `npm`, `lerna`), will return `root` path, `type` of monorepo manager, `workspaces` config.
+
+If fails, throws an error.
+
+```js
+import { resolveWorkspace } from 'pkg-types'
+const {
+  root,
+  type,
+  workspaces,
+} = await resolveWorkspace('.')
+```
+
+### `resolveWorkspacePkgs`
+
+Find monorepo workspace packages and read each package `package.json`
+
+```js
+import { resolveWorkspacePkgs } from 'pkg-types'
+const { type, root, packages } = await resolveWorkspacePkgs('.')
+console.log(root) // { dir: 'fully/resolved/root/path', packageJson: { ... } }
+console.log(packages) // [ { dir: 'fully/resolved/foo/path', packageJson: { ... } } ]
+```
+
+### `resolveWorkspacePkgsGraph`
+
+Find monorepo workspace packages graph sort by `devDependency` and `dependency`
+
+```js
+import { resolveWorkspacePkgsGraph } from 'pkg-types'
+const pkgsGraph = await resolveWorkspacePkgsGraph('.')
+console.log(pkgsGraph) // [['foo'], ['bar']]
+```
+
 ## Types
 
 **Note:** In order to make types working, you need to install `typescript` as a devDependency.

package.json

@@ -27,7 +27,8 @@
   "dependencies": {
     "confbox": "^0.1.8",
     "mlly": "^1.7.4",
-    "pathe": "^2.0.2"
+    "pathe": "^2.0.2",
+    "tinyglobby": "^0.2.10"
   },
   "devDependencies": {
     "@types/node": "^22.12.0",

src/index.ts

@@ -1,10 +1,21 @@
 import { promises as fsp } from "node:fs";
 import { dirname, resolve, isAbsolute } from "pathe";
 import { type ResolveOptions as _ResolveOptions, resolvePath } from "mlly";
-import { findFile, type FindFileOptions, findNearestFile } from "./utils";
-import type { PackageJson, TSConfig } from "./types";
-import { parseJSONC, parseJSON, stringifyJSON, stringifyJSONC } from "confbox";
-
+import {
+  findFile,
+  type FindFileOptions,
+  findNearestFile,
+  existsFile,
+} from "./utils";
+import type { PackageJson, TSConfig, Workspace, WorkspaceType } from "./types";
+import {
+  parseJSONC,
+  parseJSON,
+  stringifyJSON,
+  stringifyJSONC,
+  parseYAML,
+} from "confbox";
+import { glob } from "tinyglobby";
 export * from "./types";
 export * from "./utils";
 
@@ -60,7 +71,7 @@
       ? options.cache
       : FileCache;
   if (options.cache && cache.has(resolvedPath)) {
-    return cache.get(resolvedPath)!;
+    return cache.get(resolvedPath) as PackageJson;
   }
   const blob = await fsp.readFile(resolvedPath, "utf8");
   let parsed: PackageJson;
@@ -101,7 +112,7 @@
       ? options.cache
       : FileCache;
   if (options.cache && cache.has(resolvedPath)) {
-    return cache.get(resolvedPath)!;
+    return cache.get(resolvedPath) as TSConfig;
   }
   const text = await fsp.readFile(resolvedPath, "utf8");
   const parsed = parseJSONC(text) as TSConfig;
@@ -229,3 +240,173 @@
 
   throw new Error("Cannot detect workspace root from " + id);
 }
+
+const workspaceConfigFiles = [
+  {
+    type: "pnpm",
+    lockFile: "pnpm-lock.yaml",
+    config: "pnpm-workspace.yaml",
+  },
+  {
+    type: "lerna",
+    lockFile: "lerna.json",
+    config: "lerna.json",
+  },
+  {
+    type: "yarn",
+    lockFile: "yarn.lock",
+    config: "package.json",
+  },
+  {
+    type: "npm",
+    config: "package.json",
+  },
+] as const;
+
+export async function resolveWorkspace(
+  id: string = process.cwd(),
+  options: ResolveOptions = {},
+): Promise<Workspace> {
+  const resolvedPath = isAbsolute(id) ? id : await resolvePath(id, options);
+
+  for (const item of workspaceConfigFiles) {
+    const configFilePath = await findNearestFile(item.config, {
+      startingFrom: resolvedPath,
+      test: (filePath) => {
+        const dir = dirname(filePath);
+        if ("lockFile" in item) {
+          const detectPath = resolve(dir, item.lockFile);
+          if (!existsFile(detectPath)) {
+            return false;
+          }
+        }
+
+        const configPath = resolve(dir, item.config);
+        return existsFile(configPath);
+      },
+      ...options,
+    }).catch(() => undefined);
+
+    if (!configFilePath) {
+      continue;
+    }
+
+    const rootDir = dirname(configFilePath);
+    const configString = await fsp.readFile(configFilePath, "utf8");
+
+    switch (item.type) {
+      case "pnpm": {
+        const content = parseYAML(configString) as any;
+        return {
+          type: item.type,
+          root: rootDir,
+          workspaces: content.packages,
+        };
+      }
+      case "lerna": {
+        const content = JSON.parse(configString);
+        if (content.useWorkspaces === true) {
+          // If lerna set `useWorkspaces`, fallback to yarn or npm
+          continue;
+        }
+        return {
+          type: item.type,
+          root: rootDir,
+          workspaces: content.packages || ["packages/*"], // is lerna default workspaces
+        };
+      }
+      case "yarn":
+      case "npm": {
+        const content = JSON.parse(configString);
+        if (!("workspaces" in content)) {
+          continue;
+        }
+
+        const workspaces = Array.isArray(content.workspaces)
+          ? content.workspaces
+          : content.workspaces.packages;
+
+        if (!Array.isArray(workspaces)) {
+          continue;
+        }
+
+        return {
+          type: item.type,
+          root: rootDir,
+          workspaces,
+        };
+      }
+    }
+  }
+
+  throw new Error(`Cannot dected workspace from ${id}`);
+}
+
+export async function resolveWorkspacePkgs(
+  id: string | Awaited<ReturnType<typeof resolveWorkspace>>,
+  options: ResolveOptions = {},
+): Promise<{
+  type: WorkspaceType;
+  root: {
+    dir: string;
+    packageJson: PackageJson;
+  };
+  packages: {
+    dir: string;
+    packageJson: PackageJson;
+  }[];
+}> {
+  const config =
+    typeof id === "string" ? await resolveWorkspace(id, options) : id;
+  const pkgDirs: string[] = await glob(config.workspaces, {
+    cwd: config.root,
+    onlyDirectories: true,
+    expandDirectories: false,
+    ignore: ["**/node_modules"],
+  });
+  const pkgAbsoluteDirs = pkgDirs.map((p) => resolve(config.root, p)).sort();
+
+  return {
+    type: config.type,
+    root: {
+      dir: config.root,
+      packageJson: await readPackageJSON(config.root, options),
+    },
+    packages: await Promise.all(
+      pkgAbsoluteDirs.map(async (dir) => ({
+        dir,
+        packageJson: await readPackageJSON(dir, options),
+      })),
+    ),
+  };
+}
+
+export async function resolveWorkspacePkgsGraph(
+  id:
+    | string
+    | Awaited<ReturnType<typeof resolveWorkspace>>
+    | Awaited<ReturnType<typeof resolveWorkspacePkgs>>,
+  options: ResolveOptions = {},
+): Promise<string[][]> {
+  const resolvedPkgs =
+    typeof id === "object" && "packages" in id
+      ? id
+      : await resolveWorkspacePkgs(id, options);
+
+  const pkgGraph = {} as any;
+  for (const pkg of resolvedPkgs.packages) {
+    const { name, dependencies, devDependencies } = pkg.packageJson;
+    if (!name) {
+      continue;
+    }
+
+    pkgGraph[name] = {
+      dependencies: [
+        ...Object.keys(dependencies ?? {}),
+        ...Object.keys(devDependencies ?? {}),
+      ],
+    };
+  }
+
+  return pkgGraph;
+}

src/types/index.ts

@@ -1,2 +1,3 @@
 export * from "./tsconfig";
 export * from "./packagejson";
+export * from "./workspace";

src/types/workspace.ts

@@ -0,0 +1,18 @@
+export type WorkspaceType = "npm" | "yarn" | "pnpm" | "lerna";
+
+export interface Workspace {
+  /**
+   * The root directory of the workspace.
+   */
+  root: string;
+
+  /**
+   * The type of the workspace.
+   */
+  type: WorkspaceType;
+
+  /**
+   * Paths to the workspaces.
+   */
+  workspaces: string[];
+}

src/utils.ts

@@ -34,15 +34,7 @@ const defaultFindOptions: Required<FindFileOptions> = {
   startingFrom: ".",
   rootPattern: /^node_modules$/,
   reverse: false,
-  test: (filePath: string) => {
-    try {
-      if (statSync(filePath).isFile()) {
-        return true;
-      }
-    } catch {
-      // Ignore
-    }
-  },
+  test: existsFile,
 };
 
 /**
@@ -125,3 +117,13 @@ export function findFarthestFile(
 ): Promise<string> {
   return findFile(filename, { ..._options, reverse: true });
 }
+
+export function existsFile(filePath: string) {
+  try {
+    if (statSync(filePath).isFile()) {
+      return true;
+    }
+  } catch {
+    // Ignore
+  }
+}

test/fixture/monorepo/lerna-use-npm-workspaces/lerna.json

@@ -0,0 +1,4 @@
+{
+  "useWorkspaces": true,
+  "packages": ["failed-packages/*"]
+}

test/fixture/monorepo/lerna-use-npm-workspaces/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "monorepo-lerna-use-npm-workspaces",
+  "private": true,
+  "workspaces": [
+    "packages/*"
+  ]
+}

test/fixture/monorepo/lerna-use-npm-workspaces/packages/bar/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "bar",
+  "version": "0.1.0",
+  "dependencies": {
+    "foo": "0.1.0"
+  }
+}

test/fixture/monorepo/lerna-use-npm-workspaces/packages/foo/package.json

@@ -0,0 +1,4 @@
+{
+  "name": "foo",
+  "version": "0.1.0"
+}

test/fixture/monorepo/lerna-use-yarn-workspaces/lerna.json

@@ -0,0 +1,4 @@
+{
+  "useWorkspaces": true,
+  "packages": ["failed-packages/*"]
+}

test/fixture/monorepo/lerna-use-yarn-workspaces/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "monorepo-lerna-use-yarn-workspaces",
+  "private": true,
+  "workspaces": [
+    "packages/*"
+  ]
+}

test/fixture/monorepo/lerna-use-yarn-workspaces/packages/bar/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "bar",
+  "version": "0.1.0",
+  "dependencies": {
+    "foo": "0.1.0"
+  }
+}

test/fixture/monorepo/lerna-use-yarn-workspaces/packages/foo/package.json

@@ -0,0 +1,4 @@
+{
+  "name": "foo",
+  "version": "0.1.0"
+}

test/fixture/monorepo/lerna/lerna.json

@@ -0,0 +1,3 @@
+{
+  "packages": ["packages/*"]
+}

test/fixture/monorepo/lerna/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "monorepo-lerna",
+  "private": true,
+  "workspaces": [
+    "packages/*"
+  ]
+}