feat(packager): implement a way to determine a package manager

Package manager is now determined by project preference or running environment, npm has priority

issue #2

Author: floydspace

src/index.ts

@@ -4,7 +4,7 @@ import * as es from 'esbuild';
 import * as path from 'path';
 import { mergeRight, union, without } from 'ramda';
 
-import { packExternalModules } from './packExternalModules';
+import { packExternalModules } from './pack-externals';
 import { extractFileName, findProjectRoot, nodeMajorVersion } from './utils';
 
 /**
@@ -46,6 +46,13 @@ export interface NodejsFunctionProps extends lambda.FunctionOptions {
    */
   readonly exclude?: string[];
 
+  /**
+   * Whether to use package manager to pack external modules or explicit name of a well known packager.
+   *
+   * @default = true // Determined based on what preference is set, and whether it's currently running in a yarn/npm script
+   */
+  readonly packager?: Packager | boolean;
+
   /**
    * The esbuild bundler specific options.
    *
@@ -54,6 +61,14 @@ export interface NodejsFunctionProps extends lambda.FunctionOptions {
   readonly esbuildOptions?: es.BuildOptions;
 }
 
+/**
+ * Package manager to pack external modules.
+ */
+export enum Packager {
+  NPM = 'npm',
+  YARN = 'yarn',
+}
+
 const BUILD_FOLDER = '.build';
 const DEFAULT_BUILD_OPTIONS: es.BuildOptions = {
   bundle: true,
@@ -77,6 +92,7 @@ export class NodejsFunction extends lambda.Function {
     const withDefaultOptions = mergeRight(DEFAULT_BUILD_OPTIONS);
     const buildOptions = withDefaultOptions<es.BuildOptions>(props.esbuildOptions ?? {});
     const exclude = union(props.exclude || [], ['aws-sdk']);
+    const packager = props.packager ?? true;
     const handler = props.handler ?? 'index.handler';
     const defaultRunTime = nodeMajorVersion() >= 12
       ? lambda.Runtime.NODEJS_12_X
@@ -92,7 +108,14 @@ export class NodejsFunction extends lambda.Function {
       platform: 'node',
     });
 
-    packExternalModules(without(exclude, buildOptions.external || []), projectRoot, path.join(projectRoot, BUILD_FOLDER));
+    if (packager) {
+      packExternalModules(
+        without(exclude, buildOptions.external || []),
+        projectRoot,
+        path.join(projectRoot, BUILD_FOLDER),
+        packager !== true ? packager : undefined,
+      );
+    }
 
     super(scope, id, {
       ...props,

src/packExternalModules.ts renamed to src/pack-externals.ts

@@ -116,7 +116,7 @@ function getProdModules(externalModules: { external: string }[], packageJsonPath
  * This will utilize the npm cache at its best and give us the needed results
  * and performance.
  */
-export function packExternalModules(externals: string[], cwd: string, compositeModulePath: string) {
+export function packExternalModules(externals: string[], cwd: string, compositeModulePath: string, pkger?: 'npm' | 'yarn') {
   if (!externals || !externals.length) {
     return;
   }
@@ -125,7 +125,7 @@ export function packExternalModules(externals: string[], cwd: string, compositeM
   const packageJsonPath = path.join(cwd, 'package.json');
 
   // Determine and create packager
-  const packager = Packagers.get(Packagers.Installer.NPM);
+  const packager = Packagers.get(cwd, pkger);
 
   // Fetch needed original package.json sections
   const packageJson = fs.readJsonSync(packageJsonPath);

src/packagers/index.ts

@@ -20,26 +20,56 @@
 import { Packager } from './packager';
 import { NPM } from './npm';
 import { Yarn } from './yarn';
+import { getCurrentPackager, getPackagerFromLockfile } from '../utils';
 
 const registeredPackagers = {
   npm: new NPM(),
   yarn: new Yarn()
 };
 
-export enum Installer {
-  NPM = 'npm',
-  YARN = 'yarn',
-}
-
 /**
  * Factory method.
  * @param {string} packagerId - Well known packager id.
  */
-export function get(packagerId: Installer): Packager {
-  if (!(packagerId in registeredPackagers)) {
+export function get(cwd: string, packagerId?: keyof typeof registeredPackagers): Packager {
+  const pkger = findPackager(cwd, packagerId);
+
+  if (!(pkger in registeredPackagers)) {
     const message = `Could not find packager '${packagerId}'`;
     console.log(`ERROR: ${message}`);
     throw new Error(message);
   }
-  return registeredPackagers[packagerId];
+
+  return registeredPackagers[pkger];
+}
+
+/**
+ * Determine what package manager to use based on what preference is set,
+ * and whether it's currently running in a yarn/npm script
+ *
+ * @export
+ * @param {InstallConfig} config
+ * @returns {SupportedPackageManagers}
+ */
+function findPackager(cwd: string, prefer?: keyof typeof registeredPackagers): keyof typeof registeredPackagers {
+  let pkgManager: keyof typeof registeredPackagers | null = prefer || getCurrentPackager();
+
+  if (!pkgManager) {
+    pkgManager = getPackagerFromLockfile(cwd);
+  }
+
+  if (!pkgManager) {
+    for (const pkg in registeredPackagers) {
+      if (registeredPackagers[pkg].isManagerInstalled(cwd)) {
+        pkgManager = pkg as keyof typeof registeredPackagers;
+        break;
+      }
+    }
+  }
+
+  if (!pkgManager) {
+    throw new Error('No supported package manager found');
+  }
+
+  return pkgManager;
 }

src/packagers/npm.ts

@@ -1,4 +1,4 @@
-import { any, isEmpty, replace, split } from 'ramda';
+import { any, isEmpty, replace } from 'ramda';
 
 import { JSONObject } from '../types';
 import { SpawnError, spawnProcess } from '../utils';
@@ -20,6 +20,18 @@ export class NPM implements Packager {
     return true;
   }
 
+  isManagerInstalled(cwd: string) {
+    const command = /^win/.test(process.platform) ? 'npm.cmd' : 'npm';
+    const args = ['--version'];
+
+    try {
+      spawnProcess(command, args, { cwd });
+      return true;
+    } catch (_e) {
+      return false;
+    }
+  }
+
   getProdDependencies(cwd: string, depth: number) {
     // Get first level dependency graph
     const command = /^win/.test(process.platform) ? 'npm.cmd' : 'npm';
@@ -44,7 +56,7 @@ export class NPM implements Packager {
     } catch (err) {
       if (err instanceof SpawnError) {
         // Only exit with an error if we have critical npm errors for 2nd level inside
-        const errors = split('\n', err.stderr);
+        const errors = err.stderr?.split('\n') ?? [];
         const failed = errors.reduce((f, error) => {
           if (f) {
             return true;
@@ -64,15 +76,6 @@ export class NPM implements Packager {
     }
   }
 
-  _rebaseFileReferences(pathToPackageRoot: string, moduleVersion: string) {
-    if (/^file:[^/]{2}/.test(moduleVersion)) {
-      const filePath = replace(/^file:/, '', moduleVersion);
-      return replace(/\\/g, '/', `file:${pathToPackageRoot}/${filePath}`);
-    }
-
-    return moduleVersion;
-  }
-
   /**
    * We should not be modifying 'package-lock.json'
    * because this file should be treated as internal to npm.
@@ -82,7 +85,7 @@ export class NPM implements Packager {
    */
   rebaseLockfile(pathToPackageRoot: string, lockfile: JSONObject) {
     if (lockfile.version) {
-      lockfile.version = this._rebaseFileReferences(pathToPackageRoot, lockfile.version);
+      lockfile.version = this.rebaseFileReferences(pathToPackageRoot, lockfile.version);
     }
 
     if (lockfile.dependencies) {
@@ -117,4 +120,13 @@ export class NPM implements Packager {
       spawnProcess(command, args, { cwd });
     });
   }
+
+  private rebaseFileReferences(pathToPackageRoot: string, moduleVersion: string) {
+    if (/^file:[^/]{2}/.test(moduleVersion)) {
+      const filePath = replace(/^file:/, '', moduleVersion);
+      return replace(/\\/g, '/', `file:${pathToPackageRoot}/${filePath}`);
+    }
+
+    return moduleVersion;
+  }
 }

src/packagers/packager.ts

@@ -4,6 +4,7 @@ export interface Packager {
   lockfileName: string;
   copyPackageSectionNames: Array<string>;
   mustCopyModules: boolean;
+  isManagerInstalled(cwd: string): boolean;
   getProdDependencies(cwd: string, depth: number): JSONObject;
   rebaseLockfile(pathToPackageRoot: string, lockfile: JSONObject): void;
   install(cwd: string): void;

src/packagers/yarn.ts

@@ -24,6 +24,18 @@ export class Yarn implements Packager {
     return false;
   }
 
+  isManagerInstalled(cwd: string) {
+    const command = /^win/.test(process.platform) ? 'yarn.cmd' : 'yarn';
+    const args = ['--version'];
+
+    try {
+      spawnProcess(command, args, { cwd });
+      return true;
+    } catch (_e) {
+      return false;
+    }
+  }
+
   getProdDependencies(cwd, depth) {
     const command = /^win/.test(process.platform) ? 'yarn.cmd' : 'yarn';
     const args = ['list', `--depth=${depth || 1}`, '--json', '--production'];
@@ -37,7 +49,7 @@ export class Yarn implements Packager {
     } catch (err) {
       if (err instanceof SpawnError) {
         // Only exit with an error if we have critical npm errors for 2nd level inside
-        const errors = err.stderr.split('\n');
+        const errors = err.stderr?.split('\n') ?? [];
         const failed = errors.reduce((f, error) => {
           if (f) {
             return true;

src/utils.ts

@@ -23,8 +23,8 @@ export class SpawnError extends Error {
  */
 export function spawnProcess(command: string, args: string[], options: childProcess.SpawnOptionsWithoutStdio) {
   const child = childProcess.spawnSync(command, args, options);
-  const stdout = child.stdout.toString('utf8');
-  const stderr = child.stderr.toString('utf8');
+  const stdout = child.stdout?.toString('utf8');
+  const stderr = child.stderr?.toString('utf8');
 
   if (child.status !== 0) {
     throw new SpawnError(`${command} ${join(' ', args)} failed with code ${child.status}`, stdout, stderr);
@@ -92,3 +92,43 @@ export function findProjectRoot(rootDir?: string): string | undefined {
 export function nodeMajorVersion(): number {
   return parseInt(process.versions.node.split('.')[0], 10);
 }
+
+/**
+ * Returns the package manager currently active if the program is executed
+ * through an npm or yarn script like:
+ * ```bash
+ * yarn run example
+ * npm run example
+ * ```
+ */
+export function getCurrentPackager() {
+  const userAgent = process.env.npm_config_user_agent;
+  if (!userAgent) {
+    return null;
+  }
+
+  if (userAgent.startsWith('npm')) {
+    return 'npm';
+  }
+
+  if (userAgent.startsWith('yarn')) {
+    return 'yarn';
+  }
+
+  return null;
+}
+
+/**
+ * Checks for the presence of package-lock.json or yarn.lock to determine which package manager is being used
+ */
+export function getPackagerFromLockfile(cwd: string) {
+  if (fs.existsSync(path.join(cwd, 'package-lock.json'))) {
+    return 'npm';
+  }
+
+  if (fs.existsSync(path.join(cwd, 'yarn.lock'))) {
+    return 'yarn';
+  }
+
+  return null;
+}

tests/index.test.ts

@@ -1,5 +1,5 @@
 jest.mock('esbuild');
-jest.mock('../src/packExternalModules');
+jest.mock('../src/pack-externals');
 
 import '@aws-cdk/assert/jest';