feat: add support for pnpm

Signed-off-by: Emilien Escalle <emilien.escalle@escemi.com>

Author: neilime

README.md

@@ -14,6 +14,8 @@
 
 ## Opinionated and advisable packages to configure tools to develop a Typescript project
 
+> ✨ Works with npm, yarn, and pnpm package managers
+
 ---
 
 ## Why **ts-dev-tools** ?

packages/core/README.md

@@ -38,7 +38,6 @@
 - Install and configure [eslint](https://eslint.org/) with recommended [rules](https://eslint.org/docs/rules/)
 - Configure Eslint to works with [typescript](https://github.com/typescript-eslint/typescript-eslint#readme)
 - Install and configure the following Eslint plugins:
-
   - [eslint-plugin-import](https://github.com/benmosher/eslint-plugin-import): ES2015+ (ES6+) import/export syntax
   - [eslint-plugin-jest](https://github.com/jest-community/eslint-plugin-jest#readme): Rules for Jest
   - [eslint-plugin-node](https://github.com/mysticatea/eslint-plugin-node#readme): Additional ESLint's rules for Node.js
@@ -74,13 +73,13 @@ npm install --save-dev @ts-dev-tools/core
 Or
 
 ```sh
-yarn add --dev @ts-dev-tools/core
+pnpm add -D @ts-dev-tools/core
 ```
 
 Or
 
 ```sh
-pnpm add -D @ts-dev-tools/core
+yarn add --dev @ts-dev-tools/core
 ```
 
 ### _2_. Enable ts-dev-tools
@@ -92,13 +91,13 @@ npm exec ts-dev-tools install
 Or
 
 ```sh
-yarn ts-dev-tools install
+pnpm ts-dev-tools install
 ```
 
 Or
 
 ```sh
-pnpm ts-dev-tools install
+yarn ts-dev-tools install
 ```
 
 ⚠️ If your package is using yarn, is not private and you're publishing it on a registry like npmjs.com, you need to disable postinstall script using [pinst](https://github.com/typicode/pinst). Otherwise, postinstall will run when someone installs your package and result in an error.

packages/core/__tests__/test-project/package-lock.json

@@ -1,3 +1,4 @@
+import { existsSync, writeFileSync } from "fs";
 import { safeExec } from "../tests/cli";
 import { createProjectForTestFile, deleteTestProject } from "../tests/test-project";
 import { PackageJson } from "./PackageJson";
@@ -31,14 +32,14 @@ describe("PackageManagerService", () => {
       }
     });
 
-    it("should retrieve the default package manager when no one is detectable", () => {
-      const packageManager = PackageManagerService.detectPackageManager(testProjectDir);
-
-      expect(packageManager).toEqual(PackageManagerType.npm);
+    it("should throws an error when no package manager is detectable", () => {
+      expect(() => {
+        PackageManagerService.detectPackageManager(testProjectDir);
+      }).toThrow(`Could not detect package manager in directory: ${testProjectDir}. No lock file found.`);
     });
   });
 
-  describe.each([PackageManagerType.npm, PackageManagerType.yarn])(
+  describe.each([PackageManagerType.npm, PackageManagerType.yarn, PackageManagerType.pnpm])(
     `with package manager %s`,
     (packageManagerType) => {
       const packageTypeTestFileName = __filename.replace(
@@ -48,8 +49,23 @@ describe("PackageManagerService", () => {
 
       beforeEach(async () => {
         testProjectDir = await createProjectForTestFile(packageTypeTestFileName, useCache);
-        await safeExec(testProjectDir, `${packageManagerType} init --yes`);
-        await safeExec(testProjectDir, `${packageManagerType} install --silent`);
+
+        if (packageManagerType === PackageManagerType.pnpm) {
+          // pnpm init fails if package.json already exists, so we need to handle this differently
+          const packageJsonPath = `${testProjectDir}/package.json`;
+          if (!existsSync(packageJsonPath)) {
+            await safeExec(testProjectDir, `${packageManagerType} init`);
+          }
+          // Create pnpm-lock.yaml to indicate pnpm usage
+          writeFileSync(`${testProjectDir}/pnpm-lock.yaml`, 'lockfileVersion: \'6.0\'\n');
+        } else {
+          await safeExec(testProjectDir, `${packageManagerType} init --yes`);
+        }
+
+        const installCommand = packageManagerType === PackageManagerType.npm
+          ? `${packageManagerType} install --silent`
+          : `${packageManagerType} install`;
+        await safeExec(testProjectDir, installCommand);
       });
 
       afterEach(async () => {
@@ -104,7 +120,18 @@ describe("PackageManagerService", () => {
           const testPackageDir = `${testProjectDir}/packages/test-package`;
 
           await safeExec(testProjectDir, `mkdir -p ${testPackageDir}`);
-          await safeExec(testPackageDir, `${packageManagerType} init --yes`);
+
+          if (packageManagerType === PackageManagerType.pnpm) {
+            // For pnpm, also create a pnpm-workspace.yaml file
+            writeFileSync(`${testProjectDir}/pnpm-workspace.yaml`, 'packages:\n  - "packages/*"\n');
+            const packageJsonPath = `${testPackageDir}/package.json`;
+            if (!existsSync(packageJsonPath)) {
+              await safeExec(testPackageDir, `${packageManagerType} init`);
+            }
+          } else {
+            await safeExec(testPackageDir, `${packageManagerType} init --yes`);
+          }
+
           await safeExec(testProjectDir, `${packageManagerType} install`);
 
           const isMonorepo = await PackageManagerService.isMonorepo(testProjectDir);

packages/core/src/services/PackageManagerService.spec.ts

@@ -2,17 +2,28 @@ import { spawn } from "child_process";
 import { existsSync } from "fs";
 import { join } from "path";
 
+import { PackageJson } from "./PackageJson";
+
 export enum PackageManagerType {
   yarn = "yarn",
   npm = "npm",
+  pnpm = "pnpm",
 }
 
 export class PackageManagerService {
   static detectPackageManager(dirPath: string): PackageManagerType {
+    if (existsSync(join(dirPath, "pnpm-lock.yaml"))) {
+      return PackageManagerType.pnpm;
+    }
     if (existsSync(join(dirPath, "yarn.lock"))) {
       return PackageManagerType.yarn;
     }
-    return PackageManagerType.npm;
+
+    if (existsSync(join(dirPath, "package-lock.json"))) {
+      return PackageManagerType.npm;
+    }
+
+    throw new Error(`Could not detect package manager in directory: ${dirPath}. No lock file found.`);
   }
 
   static async addDevPackage(packageName: string, dirPath: string): Promise<void> {
@@ -37,6 +48,13 @@ export class PackageManagerService {
           args.push("--no-workspaces");
         }
         break;
+      case PackageManagerType.pnpm:
+        args.push("add", "--save-dev");
+
+        if (isMonorepo) {
+          args.push("--workspace-root");
+        }
+        break;
     }
 
     args.push(packageName);
@@ -47,37 +65,69 @@ export class PackageManagerService {
   static async isMonorepo(dirPath: string) {
     const packageManager = PackageManagerService.detectPackageManager(dirPath);
 
-    const args: string[] = [packageManager];
-
     switch (packageManager) {
-      case PackageManagerType.yarn:
-        args.push("workspaces", "info");
-        break;
-
-      case PackageManagerType.npm:
-        args.push("--workspaces", "list");
-        break;
-    }
-
-    args.push("> /dev/null 2>&1 && echo true || echo false;");
+      case PackageManagerType.yarn: {
+        const args = [packageManager, "workspaces", "info"];
+        args.push("> /dev/null 2>&1 && echo true || echo false;");
+        const output = await PackageManagerService.execCommand(args, dirPath, true);
+        return output.trim() === "true";
+      }
 
-    const output = await PackageManagerService.execCommand(args, dirPath, true);
+      case PackageManagerType.npm: {
+        const args = [packageManager, "--workspaces", "list"];
+        args.push("> /dev/null 2>&1 && echo true || echo false;");
+        const output = await PackageManagerService.execCommand(args, dirPath, true);
+        return output.trim() === "true";
+      }
 
-    return output.trim() === "true";
+      case PackageManagerType.pnpm: {
+        // For pnpm, check if pnpm-workspace.yaml exists or if workspaces are defined in package.json
+        const pnpmWorkspaceFile = join(dirPath, "pnpm-workspace.yaml");
+        if (existsSync(pnpmWorkspaceFile)) {
+          return true;
+        }
+        // Check package.json for workspace field (though pnpm prefers pnpm-workspace.yaml)
+        try {
+          const packageJson = PackageJson.fromDirPath(dirPath);
+          const content = packageJson.getContent();
+          return !!(content.workspaces);
+        } catch {
+          return false;
+        }
+      }
+    }
   }
 
   static async isPackageInstalled(packageName: string, dirPath: string): Promise<boolean> {
     const packageManager = PackageManagerService.detectPackageManager(dirPath);
 
-    const args = [
-      packageManager,
-      "list",
-      "--depth=1",
-      "--json",
-      "--no-progress",
-      `--pattern="${packageName}"`,
-      "--non-interactive",
-    ];
+    let args: string[];
+
+    switch (packageManager) {
+      case PackageManagerType.yarn:
+      case PackageManagerType.npm:
+        args = [
+          packageManager,
+          "list",
+          "--depth=1",
+          "--json",
+          "--no-progress",
+          `--pattern="${packageName}"`,
+          "--non-interactive",
+        ];
+        break;
+      case PackageManagerType.pnpm:
+        args = [
+          packageManager,
+          "list",
+          packageName,
+          "--json",
+          "--depth=1",
+        ];
+        break;
+      default:
+        throw new Error(`Unsupported package manager: ${packageManager}`);
+    }
 
     const output = await PackageManagerService.execCommand(args, dirPath, true);
 
@@ -92,6 +142,16 @@ export class PackageManagerService {
         return installedPackages.dependencies
           ? Object.prototype.hasOwnProperty.call(installedPackages.dependencies, packageName)
           : false;
+      case PackageManagerType.pnpm:
+        // pnpm returns an array of package objects
+        if (Array.isArray(installedPackages) && installedPackages.length > 0) {
+          const pkg = installedPackages[0];
+          return (pkg.dependencies && Object.prototype.hasOwnProperty.call(pkg.dependencies, packageName)) ||
+            (pkg.devDependencies && Object.prototype.hasOwnProperty.call(pkg.devDependencies, packageName));
+        }
+        return false;
+      default:
+        throw new Error(`Unsupported package manager: ${packageManager}`);
     }
   }
 
@@ -112,6 +172,17 @@ export class PackageManagerService {
           )
         ).trim();
         break;
+      case PackageManagerType.pnpm:
+        nodeModulesPath = (
+          await PackageManagerService.execCommand(
+            [packageManager, "root"],
+            dirPath,
+            true
+          )
+        ).trim();
+        break;
+      default:
+        throw new Error(`Unsupported package manager: ${packageManager}`);
     }
 
     if (nodeModulesPath) {

packages/core/src/services/PackageManagerService.ts

@@ -9,6 +9,7 @@ const rootDirPath = resolve(__dirname, "../../../..");
 const corePackageDirPath = resolve(__dirname, "..", "..");
 const testProjectDir = resolve("__tests__/test-project");
 const defaultPackageJsonPath = join(testProjectDir, "package.json");
+const defaultPackageJsonLockPath = join(testProjectDir, "package-lock.json");
 
 export const getPackageNameFromFilepath = (filepath: string): string => {
   const relativeFilepath = relative(rootDirPath, filepath);
@@ -45,6 +46,7 @@ async function defaultProjectGenerator(testProjectDirPath: string): Promise<void
   symlinkSync(resolve(__dirname, ".."), tsDevToolsDistPath);
 
   copyFileSync(defaultPackageJsonPath, join(testProjectDirPath, "package.json"));
+  copyFileSync(defaultPackageJsonLockPath, join(testProjectDirPath, "package-lock.json"));
 }
 
 export type TestProjectGenerator = (testProjectDir: string) => Promise<void>;

packages/core/src/tests/test-project.ts

@@ -42,6 +42,12 @@ npm install --save-dev @ts-dev-tools/react
 
 Or
 
+```sh
+pnpm add --save-dev @ts-dev-tools/react
+```
+
+Or
+
 ```sh
 yarn add --dev @ts-dev-tools/react
 ```
@@ -54,6 +60,12 @@ npm exec ts-dev-tools install
 
 Or
 
+```sh
+pnpm ts-dev-tools install
+```
+
+Or
+
 ```sh
 yarn ts-dev-tools install
 ```