feat(lambda-nodejs): esbuild bundling

packages/@aws-cdk/aws-lambda-nodejs/README.md

@@ -28,8 +28,7 @@ up the entry file:
 ├── stack.my-handler.ts # exports a function named 'handler'
 ```
 
-This file is used as "entry" for [Parcel](https://parceljs.org/). This means that your code is
-automatically transpiled and bundled whether it's written in JavaScript or TypeScript.
+This file is used as "entry" for [esbbuild](https://esbuild.github.io/). This means that your code is automatically transpiled and bundled whether it's written in JavaScript or TypeScript.
 
 Alternatively, an entry file and handler can be specified:
 
@@ -45,11 +44,11 @@ All other properties of `lambda.Function` are supported, see also the [AWS Lambd
 The `NodejsFunction` construct automatically [reuses existing connections](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/node-reusing-connections.html)
 when working with the AWS SDK for JavaScript. Set the `awsSdkConnectionReuse` prop to `false` to disable it.
 
-Use the `parcelEnvironment` prop to define environments variables when Parcel runs:
+Use the `bundlingEnvironment` prop to define environments variables when esbuild runs:
 
 ```ts
 new lambda.NodejsFunction(this, 'my-handler', {
-  parcelEnvironment: {
+  bundlingEnvironment: {
     NODE_ENV: 'production',
   },
 });
@@ -73,10 +72,10 @@ new lambda.NodejsFunction(this, 'my-handler', {
 });
 ```
 
-This image should have Parcel installed at `/`. If you plan to use `nodeModules` it
+This image should have esbuild installed globally. If you plan to use `nodeModules` it
 should also have `npm` or `yarn` depending on the lock file you're using.
 
-Use the [default image provided by `@aws-cdk/aws-lambda-nodejs`](https://github.com/aws/aws-cdk/blob/master/packages/%40aws-cdk/aws-lambda-nodejs/parcel/Dockerfile)
+Use the [default image provided by `@aws-cdk/aws-lambda-nodejs`](https://github.com/aws/aws-cdk/blob/master/packages/%40aws-cdk/aws-lambda-nodejs/lib/Dockerfile)
 as a source of inspiration.
 
 ### Project root
@@ -97,13 +96,8 @@ Alternatively, you can specify the `projectRoot` prop manually. In this case you
 need to ensure that this path includes `entry` and any module/dependencies used
 by your function. Otherwise bundling will fail.
 
-### Configuring Parcel
-The `NodejsFunction` construct exposes some [Parcel](https://parceljs.org/) options via properties: `minify`, `sourceMaps` and `cacheDir`.
-
-Parcel transpiles your code (every internal module) with [@babel/preset-env](https://babeljs.io/docs/en/babel-preset-env) and uses the
-runtime version of your Lambda function as target.
-
-Configuring Babel with Parcel is possible via a `.babelrc` or a `babel` config in `package.json`.
+### Configuring esbuild
+The `NodejsFunction` construct exposes some [esbuild](https://esbuild.github.io/) options via properties: `minify`, `sourceMaps` and `target`.
 
 ### Working with modules
 
@@ -137,21 +131,21 @@ same version will be used for installation. If a lock file is detected (`package
 `yarn.lock`) it will be used along with the right installer (`npm` or `yarn`).
 
 ### Local bundling
-If Parcel v2.0.0-beta.1 is available it will be used to bundle your code in your environment. Otherwise,
+If esbuild is available it will be used to bundle your code in your environment. Otherwise,
 bundling will happen in a [Lambda compatible Docker container](https://hub.docker.com/r/amazon/aws-sam-cli-build-image-nodejs12.x).
 
-For macOS the recommendend approach is to install Parcel as Docker volume performance is really poor.
+For macOS the recommendend approach is to install esbuild as Docker volume performance is really poor.
 
-Parcel v2.0.0-beta.1 can be installed with:
+esbuild can be installed with:
 
 ```bash
-$ npm install --save-dev --save-exact [email protected]
+$ npm install --save-dev esbuild@0
 ```
 
 OR
 
 ```bash
-$ yarn add --dev --exact [email protected]
+$ yarn add --dev esbuild@0
 ```
 
 To force bundling in a Docker container, set the `forceDockerBundling` prop to `true`. This

packages/@aws-cdk/aws-lambda-nodejs/parcel/Dockerfile → packages/@aws-cdk/aws-lambda-nodejs/lib/Dockerfile

@@ -6,10 +6,10 @@ FROM $IMAGE
 # Install yarn
 RUN npm install --global [email protected]
 
-# Install parcel 2 (fix the version since it's still in beta)
-# install at "/" so that node_modules will be in the path for /asset-input
-ARG PARCEL_VERSION=2.0.0-beta.1
-RUN cd / && npm install parcel@$PARCEL_VERSION --no-package-lock
+# Install esbuild
+# (unsafe-perm because esbuild has a postinstall script)
+ARG ESBUILD_VERSION=0
+RUN npm install --global --unsafe-perm=true esbuild@$ESBUILD_VERSION
 
 # Ensure all users can write to npm cache
 RUN mkdir /tmp/npm-cache && \
@@ -22,4 +22,4 @@ RUN npm config --global set update-notifier false
 # create non root user and change allow execute command for non root user
 RUN /sbin/useradd -u 1000 user && chmod 711 /
 
-CMD [ "parcel" ]
+CMD [ "esbuild" ]

packages/@aws-cdk/aws-lambda-nodejs/lib/bundlers.ts

@@ -5,13 +5,16 @@ import { Runtime } from '@aws-cdk/aws-lambda';
 import * as cdk from '@aws-cdk/core';
 import { exec } from './util';
 
-const PARCEL_VERSION = '2.0.0-beta.1';
+const ESBUILD_VERSION = '0';
 
 interface BundlerProps {
   relativeEntryPath: string;
-  cacheDir?: string;
+  minify?: boolean;
+  sourceMap?: boolean;
+  target?: string;
   environment?: { [key: string]: string };
   dependencies?: { [key: string]: string };
+  externals?: string[];
   installer: Installer;
   lockFile?: LockFile;
 }
@@ -21,51 +24,44 @@ interface LocalBundlerProps extends BundlerProps {
 }
 
 /**
- * Local Parcel bundler
+ * Local esbuild bundler
  */
 export class LocalBundler implements cdk.ILocalBundling {
-  public static runsLocally(resolvePath: string): boolean {
-    if (LocalBundler._runsLocally[resolvePath] !== undefined) {
-      return LocalBundler._runsLocally[resolvePath];
-    }
-    if (os.platform() === 'win32') { // TODO: add Windows support
-      return false;
+  public static get runsLocally(): boolean {
+    if (LocalBundler._runsLocally !== undefined) {
+      return LocalBundler._runsLocally;
     }
     try {
-      const parcel = spawnSync(require.resolve('parcel', { paths: [resolvePath] }), ['--version']);
-      const version = parcel.stdout.toString().trim();
-      LocalBundler._runsLocally[resolvePath] = new RegExp(`^${PARCEL_VERSION}`).test(version); // Cache result to avoid unnecessary spawns
-      if (!LocalBundler._runsLocally[resolvePath]) {
-        process.stderr.write(`Incorrect parcel version detected: ${version} <> ${PARCEL_VERSION}. Switching to Docker bundling.\n`);
+      const esbuild = spawnSync('npx', ['--no-install', 'esbuild', '--version']);
+      const version = esbuild.stdout.toString().trim();
+      LocalBundler._runsLocally = new RegExp(`^${ESBUILD_VERSION}`).test(version); // Cache result to avoid unnecessary spawns
+      if (!LocalBundler._runsLocally) {
+        process.stderr.write(`Incorrect esbuild version detected: ${version} <> ${ESBUILD_VERSION}. Switching to Docker bundling.\n`);
       }
-      return LocalBundler._runsLocally[resolvePath];
+      return LocalBundler._runsLocally;
     } catch (err) {
+      process.stderr.write('Using Docker bundling');
       return false;
     }
   }
 
   public static clearRunsLocallyCache(): void { // for tests
-    LocalBundler._runsLocally = {};
+    LocalBundler._runsLocally = undefined;
   }
 
-  private static _runsLocally: { [key: string]: boolean } = {};
+  private static _runsLocally?: boolean;
 
   constructor(private readonly props: LocalBundlerProps) {}
 
   public tryBundle(outputDir: string) {
-    if (!LocalBundler.runsLocally(this.props.projectRoot)) {
+    if (!LocalBundler.runsLocally) {
       return false;
     }
 
     const localCommand = createBundlingCommand({
-      projectRoot: this.props.projectRoot,
-      relativeEntryPath: this.props.relativeEntryPath,
-      cacheDir: this.props.cacheDir,
+      ...this.props,
       outputDir,
-      dependencies: this.props.dependencies,
-      installer: this.props.installer,
-      lockFile: this.props.lockFile,
-      bundlingEnvironment: BundlingEnvironment.LOCAL,
+      forcePosixPath: os.platform() !== 'win32',
     });
 
     exec('bash', ['-c', localCommand], {
@@ -86,7 +82,7 @@ interface DockerBundlerProps extends BundlerProps {
   buildImage?: boolean;
   buildArgs?: { [key: string]: string };
   runtime: Runtime;
-  parcelVersion?: string;
+  esbuildVersion?: string;
 }
 
 /**
@@ -97,24 +93,19 @@ export class DockerBundler {
 
   constructor(props: DockerBundlerProps) {
     const image = props.buildImage
-      ? props.bundlingDockerImage ?? cdk.BundlingDockerImage.fromAsset(path.join(__dirname, '../parcel'), {
+      ? props.bundlingDockerImage ?? cdk.BundlingDockerImage.fromAsset(path.join(__dirname, '../lib'), {
         buildArgs: {
           ...props.buildArgs ?? {},
           IMAGE: props.runtime.bundlingDockerImage.image,
-          PARCEL_VERSION: props.parcelVersion ?? PARCEL_VERSION,
+          ESBUILD_VERSION: props.esbuildVersion ?? ESBUILD_VERSION,
         },
       })
       : cdk.BundlingDockerImage.fromRegistry('dummy'); // Do not build if we don't need to
 
     const command = createBundlingCommand({
+      ...props,
       projectRoot: cdk.AssetStaging.BUNDLING_INPUT_DIR, // project root is mounted at /asset-input
-      relativeEntryPath: props.relativeEntryPath,
-      cacheDir: props.cacheDir,
       outputDir: cdk.AssetStaging.BUNDLING_OUTPUT_DIR,
-      installer: props.installer,
-      lockFile: props.lockFile,
-      dependencies: props.dependencies,
-      bundlingEnvironment: BundlingEnvironment.DOCKER,
     });
 
     this.bundlingOptions = {
@@ -127,42 +118,37 @@ export class DockerBundler {
 }
 
 interface BundlingCommandOptions extends LocalBundlerProps {
+  forcePosixPath?: boolean;
   outputDir: string;
-  bundlingEnvironment: BundlingEnvironment;
-}
-
-enum BundlingEnvironment {
-  DOCKER = 'docker',
-  LOCAL = 'local',
 }
 
 /**
  * Generates bundling command
  */
 function createBundlingCommand(options: BundlingCommandOptions): string {
-  const entryPath = path.join(options.projectRoot, options.relativeEntryPath);
-  const distFile = path.basename(options.relativeEntryPath).replace(/\.(jsx|tsx?)$/, '.js');
-  const parcelResolvePath = options.bundlingEnvironment === BundlingEnvironment.DOCKER
-    ? '/' // Force using parcel installed at / in the image
-    : entryPath; // Look up starting from entry path
-
-  const parcelCommand: string = chain([
-    [
-      `$(node -p "require.resolve(\'parcel\', { paths: ['${parcelResolvePath}'] })")`, // Parcel is not globally installed, find its "bin"
-      'build', entryPath.replace(/\\/g, '/'), // Always use POSIX paths in the container
-      '--target', 'cdk-lambda',
-      '--dist-dir', options.outputDir, // Output bundle in outputDir (will have the same name as the entry)
-      '--no-autoinstall',
-      '--no-scope-hoist',
-      ...options.cacheDir
-        ? ['--cache-dir', path.join(options.projectRoot, options.cacheDir)]
-        : [],
-    ].join(' '),
-    // Always rename dist file to index.js because Lambda doesn't support filenames
-    // with multiple dots and we can end up with multiple dots when using automatic
-    // entry lookup
-    distFile !== 'index.js' ? `mv ${options.outputDir}/${distFile} ${options.outputDir}/index.js` : '',
-  ]);
+  let entryPath = path.join(options.projectRoot, options.relativeEntryPath);
+
+  if (options.forcePosixPath ?? true) {
+    entryPath = entryPath.replace(/\\/g, '/');
+  }
+
+  const esbuildCommand: string = [
+    'npx',
+    'esbuild',
+    '--bundle', entryPath,
+    `--target=${options.target ?? 'es2017'}`,
+    '--platform=node',
+    `--outfile=${options.outputDir}/index.js`,
+    ...options.minify
+      ? ['--minify']
+      : [],
+    ...options.sourceMap
+      ? ['--sourcemap']
+      : '',
+    ...options.externals
+      ? options.externals.map(external => `--external:${external}`)
+      : [],
+  ].join(' ');
 
   let depsCommand = '';
   if (options.dependencies) {
@@ -175,7 +161,7 @@ function createBundlingCommand(options: BundlingCommandOptions): string {
     ]);
   }
 
-  return chain([parcelCommand, depsCommand]);
+  return chain([esbuildCommand, depsCommand]);
 }
 
 export enum Installer {