feat: support-pnpm-package-manager [ZEND-6808]

michaelpineirocontentful · michaelpineirocontentful · commit bde44f791081 · 2025-08-22T15:54:13.000-06:00
Based on [this PR](#2631) , with minor tweaks.
diff --git a/packages/contentful--create-contentful-app/src/getTemplateSource.ts b/packages/contentful--create-contentful-app/src/getTemplateSource.ts
@@ -45,11 +45,10 @@ async function promptExampleSelection(): Promise<string> {
     // get available templates from examples
     const availableTemplates = await getGithubFolderNames();
     // filter out the ignored ones that are listed as templates instead of examples
-    const filteredTemplates = availableTemplates
-      .filter(
-        (template) =>
-          !IGNORED_EXAMPLE_FOLDERS.includes(template as (typeof IGNORED_EXAMPLE_FOLDERS)[number])
-      )
+    const filteredTemplates = availableTemplates.filter(
+      (template) =>
+        !IGNORED_EXAMPLE_FOLDERS.includes(template as (typeof IGNORED_EXAMPLE_FOLDERS)[number])
+    );
     console.log(availableTemplates.length, filteredTemplates.length);
 
     // ask user to select a template from the available examples
diff --git a/packages/contentful--create-contentful-app/src/utils.ts b/packages/contentful--create-contentful-app/src/utils.ts
@@ -1,5 +1,5 @@
 import { spawn, SpawnOptionsWithoutStdio } from 'child_process';
-import { existsSync, rmSync } from 'fs';
+import { existsSync, readFileSync, rmSync } from 'fs';
 import { basename } from 'path';
 import { choice, highlight, warn } from './logger';
 import { CLIOptions, ContentfulExample, PackageManager } from './types';
@@ -27,6 +27,21 @@ export function rmIfExists(path: string) {
 }
 
 export function detectActivePackageManager(): PackageManager {
+  if (existsSync('pnpm-lock.yaml')) return 'pnpm';
+  if (existsSync('yarn.lock')) return 'yarn';
+  if (existsSync('package-lock.json')) return 'npm';
+  warn('No lock files found, we will try to detect the active package manager from package.json.');
+  try {
+    const pkg = JSON.parse(readFileSync('package.json', 'utf8'));
+    if (pkg.packageManager?.startsWith('pnpm')) return 'pnpm';
+    if (pkg.packageManager?.startsWith('yarn')) return 'yarn';
+    if (pkg.packageManager?.startsWith('npm')) return 'npm';
+  } catch {
+    warn(
+      `Unable to determine active package manager from package.json. We will try to detect it from npm_execpath.`
+    );
+  }
+
   switch (basename(process.env.npm_execpath || '')) {
     case 'yarn.js':
       return 'yarn';
@@ -70,7 +85,9 @@ export function normalizeOptions(options: CLIOptions): CLIOptions {
 
   if (selectedPackageManagers.length > 1) {
     warn(
-      `Too many package manager flags were provided, we will use ${choice(`--${activePackageManager}`)}.`
+      `Too many package manager flags were provided, we will use ${choice(
+        `--${activePackageManager}`
+      )}.`
     );
 
     // Delete all package manager options
@@ -79,12 +96,12 @@ export function normalizeOptions(options: CLIOptions): CLIOptions {
     });
 
     // Select active package manager
-    (normalizedOptions as Record<string, boolean>)[activePackageManager] = true;
+    (normalizedOptions as CLIOptions)[activePackageManager] = true;
   }
 
   // No package manager flags were provided, use active package manager
   if (selectedPackageManagers.length === 0) {
-    (normalizedOptions as Record<string, boolean>)[activePackageManager] = true;
+    (normalizedOptions as CLIOptions)[activePackageManager] = true;
   }
 
   let fallbackOption = '--typescript';
diff --git a/packages/contentful--create-contentful-app/test/utils.spec.ts b/packages/contentful--create-contentful-app/test/utils.spec.ts
@@ -1,3 +1,5 @@
+/// <reference types="node" />
+// The above directive tells TypeScript to include Node.js type definitions (i.e. process)
 import { expect } from 'chai';
 import {
   detectActivePackageManager,
@@ -11,44 +13,166 @@ describe('utils', () => {
 
   describe('detectActivePackageManager', () => {
     let originalNpmExecpath: string | undefined;
+    let originalCwd: string;
+    let tempDir: string;
 
     beforeEach(() => {
       originalNpmExecpath = process.env.npm_execpath;
+      originalCwd = process.cwd();
+
+      // Create temporary directory for each test
+      const fs = require('fs');
+      const os = require('os');
+      const path = require('path');
+      tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pm-test-'));
+      process.chdir(tempDir);
     });
 
     afterEach(() => {
+      // Restore environment
       if (originalNpmExecpath) {
         process.env.npm_execpath = originalNpmExecpath;
       } else {
         delete process.env.npm_execpath;
       }
+
+      // Restore working directory and cleanup
+      process.chdir(originalCwd);
+      try {
+        const fs = require('fs');
+        fs.rmSync(tempDir, { recursive: true, force: true });
+      } catch (error) {
+        // Ignore cleanup errors
+      }
     });
 
-    [
-      ['yarn', '/path/to/yarn.js'],
-      ['pnpm', '/path/to/pnpm.cjs'],
-      ['npm', '/path/to/npx-cli.js'],
-      ['npm', '/path/to/npm-cli.js'],
-    ].forEach(([packageManager, npmExecpath]) => {
-      it(`should detect ${packageManager} when npm_execpath contains ${npmExecpath}`, () => {
-        process.env.npm_execpath = npmExecpath;
-        expect(detectActivePackageManager()).to.equal(packageManager);
+    describe('lock file detection', () => {
+      it('should detect pnpm from pnpm-lock.yaml', () => {
+        const fs = require('fs');
+        fs.writeFileSync('pnpm-lock.yaml', 'lockfileVersion: 5.4');
+        expect(detectActivePackageManager()).to.equal('pnpm');
+      });
+
+      it('should detect yarn from yarn.lock', () => {
+        const fs = require('fs');
+        fs.writeFileSync('yarn.lock', '# yarn lockfile v1');
+        expect(detectActivePackageManager()).to.equal('yarn');
+      });
+
+      it('should detect npm from package-lock.json', () => {
+        const fs = require('fs');
+        fs.writeFileSync('package-lock.json', '{"lockfileVersion": 2}');
+        expect(detectActivePackageManager()).to.equal('npm');
+      });
+
+      it('should prioritize pnpm-lock.yaml over other lock files', () => {
+        const fs = require('fs');
+        fs.writeFileSync('pnpm-lock.yaml', 'lockfileVersion: 5.4');
+        fs.writeFileSync('yarn.lock', '# yarn lockfile v1');
+        fs.writeFileSync('package-lock.json', '{"lockfileVersion": 2}');
+        expect(detectActivePackageManager()).to.equal('pnpm');
+      });
+
+      it('should prioritize yarn.lock over package-lock.json', () => {
+        const fs = require('fs');
+        fs.writeFileSync('yarn.lock', '# yarn lockfile v1');
+        fs.writeFileSync('package-lock.json', '{"lockfileVersion": 2}');
+        expect(detectActivePackageManager()).to.equal('yarn');
       });
     });
 
-    it('should default to npm when npm_execpath is undefined', () => {
-      delete process.env.npm_execpath;
-      expect(detectActivePackageManager()).to.equal('npm');
+    describe('package.json packageManager field detection', () => {
+      it('should detect pnpm from package.json packageManager field', () => {
+        const fs = require('fs');
+        const packageJson = { packageManager: 'pnpm@8.6.0' };
+        fs.writeFileSync('package.json', JSON.stringify(packageJson));
+        expect(detectActivePackageManager()).to.equal('pnpm');
+      });
+
+      it('should detect yarn from package.json packageManager field', () => {
+        const fs = require('fs');
+        const packageJson = { packageManager: 'yarn@1.22.19' };
+        fs.writeFileSync('package.json', JSON.stringify(packageJson));
+        expect(detectActivePackageManager()).to.equal('yarn');
+      });
+
+      it('should detect npm from package.json packageManager field', () => {
+        const fs = require('fs');
+        const packageJson = { packageManager: 'npm@9.8.0' };
+        fs.writeFileSync('package.json', JSON.stringify(packageJson));
+        expect(detectActivePackageManager()).to.equal('npm');
+      });
+
+      it('should prioritize lock files over package.json packageManager field', () => {
+        const fs = require('fs');
+        fs.writeFileSync('yarn.lock', '# yarn lockfile v1');
+        const packageJson = { packageManager: 'pnpm@8.6.0' };
+        fs.writeFileSync('package.json', JSON.stringify(packageJson));
+        expect(detectActivePackageManager()).to.equal('yarn');
+      });
     });
 
-    it('should default to npm when npm_execpath is empty string', () => {
-      process.env.npm_execpath = '';
-      expect(detectActivePackageManager()).to.equal('npm');
+    describe('npm_execpath fallback detection', () => {
+      [
+        ['yarn', '/path/to/yarn.js'],
+        ['pnpm', '/path/to/pnpm.cjs'],
+        ['npm', '/path/to/npx-cli.js'],
+        ['npm', '/path/to/npm-cli.js'],
+      ].forEach(([packageManager, npmExecpath]) => {
+        it(`should detect ${packageManager} when npm_execpath contains ${npmExecpath}`, () => {
+          process.env.npm_execpath = npmExecpath;
+          expect(detectActivePackageManager()).to.equal(packageManager);
+        });
+      });
+
+      it('should default to npm when npm_execpath is undefined', () => {
+        delete process.env.npm_execpath;
+        expect(detectActivePackageManager()).to.equal('npm');
+      });
+
+      it('should default to npm when npm_execpath is empty string', () => {
+        process.env.npm_execpath = '';
+        expect(detectActivePackageManager()).to.equal('npm');
+      });
+
+      it('should default to npm for unknown execpath', () => {
+        process.env.npm_execpath = '/path/to/unknown-package-manager.js';
+        expect(detectActivePackageManager()).to.equal('npm');
+      });
+
+      it('should fall back to npm_execpath when package.json is invalid', () => {
+        const fs = require('fs');
+        fs.writeFileSync('package.json', 'invalid json');
+        process.env.npm_execpath = '/path/to/yarn.js';
+        expect(detectActivePackageManager()).to.equal('yarn');
+      });
+
+      it('should fall back to npm_execpath when package.json has no packageManager field', () => {
+        const fs = require('fs');
+        const packageJson = { name: 'test-app', version: '1.0.0' };
+        fs.writeFileSync('package.json', JSON.stringify(packageJson));
+        process.env.npm_execpath = '/path/to/pnpm.cjs';
+        expect(detectActivePackageManager()).to.equal('pnpm');
+      });
     });
 
-    it('should default to npm for unknown execpath', () => {
-      process.env.npm_execpath = '/path/to/unknown-package-manager.js';
-      expect(detectActivePackageManager()).to.equal('npm');
+    describe('priority and edge cases', () => {
+      it('should prioritize lock files over package.json over npm_execpath', () => {
+        const fs = require('fs');
+        fs.writeFileSync('yarn.lock', '# yarn lockfile v1');
+        const packageJson = { packageManager: 'pnpm@8.6.0' };
+        fs.writeFileSync('package.json', JSON.stringify(packageJson));
+        process.env.npm_execpath = '/path/to/npm-cli.js';
+        expect(detectActivePackageManager()).to.equal('yarn');
+      });
+
+      it('should prioritize package.json over npm_execpath when no lock files exist', () => {
+        const fs = require('fs');
+        const packageJson = { packageManager: 'pnpm@8.6.0' };
+        fs.writeFileSync('package.json', JSON.stringify(packageJson));
+        process.env.npm_execpath = '/path/to/yarn.js';
+        expect(detectActivePackageManager()).to.equal('pnpm');
+      });
     });
   });
 
@@ -96,17 +220,37 @@ describe('utils', () => {
 
   describe('normalizeOptions', () => {
     let originalNpmExecpath: string | undefined;
+    let originalCwd: string;
+    let tempDir: string;
 
     beforeEach(() => {
       originalNpmExecpath = process.env.npm_execpath;
+      originalCwd = process.cwd();
+
+      // Create temporary directory for each test
+      const fs = require('fs');
+      const os = require('os');
+      const path = require('path');
+      tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'normalize-test-'));
+      process.chdir(tempDir);
     });
 
     afterEach(() => {
+      // Restore environment
       if (originalNpmExecpath) {
         process.env.npm_execpath = originalNpmExecpath;
       } else {
         delete process.env.npm_execpath;
       }
+
+      // Restore working directory and cleanup
+      process.chdir(originalCwd);
+      try {
+        const fs = require('fs');
+        fs.rmSync(tempDir, { recursive: true, force: true });
+      } catch (error) {
+        // Ignore cleanup errors
+      }
     });
 
     describe('no package manager options are provided', () => {
@@ -116,6 +260,7 @@ describe('utils', () => {
         ['npm', '/path/to/npx-cli.js'],
       ].forEach(([activePackageManager, npmExecpath]) => {
         it(`falls back to ${activePackageManager} when that is the active package manager`, () => {
+          // Set npm_execpath to force detection to use fallback
           process.env.npm_execpath = npmExecpath;
           const options: CLIOptions = {};
           const result = normalizeOptions(options);
@@ -128,6 +273,31 @@ describe('utils', () => {
           });
         });
       });
+
+      it('falls back to detected package manager from lock files', () => {
+        const fs = require('fs');
+        fs.writeFileSync('yarn.lock', '# yarn lockfile v1');
+
+        const options: CLIOptions = {};
+        const result = normalizeOptions(options);
+
+        expect(result.yarn).to.be.true;
+        expect(result.npm).to.be.undefined;
+        expect(result.pnpm).to.be.undefined;
+      });
+
+      it('falls back to detected package manager from package.json', () => {
+        const fs = require('fs');
+        const packageJson = { packageManager: 'pnpm@8.6.0' };
+        fs.writeFileSync('package.json', JSON.stringify(packageJson));
+
+        const options: CLIOptions = {};
+        const result = normalizeOptions(options);
+
+        expect(result.pnpm).to.be.true;
+        expect(result.npm).to.be.undefined;
+        expect(result.yarn).to.be.undefined;
+      });
     });
 
     describe('one package manager option is provided', () => {
