runtime: nodejs6.10

description: AWS Lambda supports Node.js 6.10 and so to use async/await and other ES6/ES7 features in our Serverless Framework project we need to use Babel and Webpack 4 to transpile our code. We can do this by adding the serverless-webpack plugin to our project and setting it up to automatically transpile our handler functions.

By default, AWS Lambda only supports a specific version of JavaScript. It doesn't have an up-to-date Node.js engine. And looking a bit further ahead, we'll be using a more advanced flavor of JavaScript with ES6/ES7 features. So it would make sense to follow the same syntax on the backend and have a transpiler convert it to the target syntax. This would mean that we won't need to worry about writing different types of code on the backend or the frontend.

In this chapter, we are going to enable ES6/ES7 for AWS Lambda using the Serverless Framework. We will do this by setting up [Babel](https://babeljs.io) and [Webpack](https://webpack.github.io) 4 to transpile and package our project. If you would like to code with AWS Lambda's default JavaScript version, you can skip this chapter. But you will not be able to directly use the sample code in the later chapters, as they are written in ES6 syntax.

<img class="code-marker" src="/assets/s.png" />At the root of the project, run.

``` bash

$ npm install --save-dev \

babel-core \

babel-loader \

babel-plugin-transform-runtime \

babel-preset-env \

babel-preset-stage-3 \

serverless-webpack \

webpack \

webpack-node-externals

$ npm install --save babel-runtime

Most of the above packages are only needed while we are building our project and they won't be deployed to our Lambda functions. We are using the `serverless-webpack` plugin to help trigger the Webpack build when we run our Serverless commands. The `webpack-node-externals` is necessary because we do not want Webpack to bundle our `aws-sdk` module, since it is not compatible.

<img class="code-marker" src="/assets/s.png" />Create a file called `webpack.config.js` in the root with the following.

``` javascript

This is the configuration Webpack will use to package our app. The main part of this config is the `entry` attribute that we are automatically generating using the `slsw.lib.entries` that is a part of the `serverless-webpack` plugin. This automatically picks up all our handler functions and packages them.

Note that, you won't have to do this for your new projects, we created a [starter project]({% link _chapters/serverless-nodejs-starter.md %}) for you to use without any of the configuration.

<img class="code-marker" src="/assets/s.png" />Next create a file called `.babelrc` in the root with the following.

"plugins": ["transform-runtime"],

["env", { "node": "6.10" }],

The presets are telling Babel the type of JavaScript we are going to be using.

<img class="code-marker" src="/assets/s.png" />Open `serverless.yml` and replace it with the following.

``` yaml

service: notes-app-api

plugins:

- serverless-webpack

custom:

webpack:

webpackConfig: ./webpack.config.js

includeModules: true

provider:

name: aws

runtime: nodejs6.10

stage: prod

region: us-east-1

<img class="code-marker" src="/assets/s.png" />Create a new project in directory separate from the backend. Run the following command.

``` bash

$ npm install -g create-react-app

This installs the Create React App NPM package globally.

<img class="code-marker" src="/assets/s.png" />From your working directory, run the following command to create the client for our notes app.

$ create-react-app notes-app-client

description: A Serverless Node.js starter project that adds support for ES6/ES7 async/await methods and unit tests to your Serverless Framework project.

Now that we know how to set our Serverless projects up, it makes sense that we have a good starting point for our future projects. For this we created a couple of Serverless starter projects that you can use called, [Serverless Node.js Starter](https://github.com/AnomalyInnovations/serverless-nodejs-starter). We also have a Python version called [Serverless Python Starter](https://github.com/AnomalyInnovations/serverless-python-starter). Our starter projects also work really well with [Seed](https://seed.run); a fully-configured CI/CD pipeline for Serverless Framework.

- **Use async/await in your handler functions**

To create a new Serverless project with ES7 support.

<img class="code-marker" src="/assets/s.png" />Create a directory for our API backend.

``` bash

$ mkdir notes-app-api

$ cd notes-app-api

<img class="code-marker" src="/assets/s.png" />At the root of the project; create an AWS Node.js service.

$ serverless create --template aws-nodejs

Now the directory should contain the two following files, namely **handler.js** and **serverless.yml**.

$ ls

handler.js serverless.yml

$ npm init -y

This creates a new Node.js project for you. This will help us manage any dependencies our project might have.

<img class="code-marker" src="/assets/s.png" />Next, install these two packages.

Now the directory should contain three files and one directory.

``` bash

$ ls

handler.js node_modules package.json serverless.yml

- **node_modules** contains the Node.js dependencies that we just installed.

- **package.json** contains the Node.js configuration for our project.

Next, we are going to set up a standard JavaScript environment for us by adding support for ES6.

You can install it by running the following.

$ npm install -g aws-api-gateway-cli-test

$ apig-test \

$ apig-test --username [email protected] --password Passw0rd! --user-pool-id YOUR_COGNITO_USER_POOL_ID --app-client-id YOUR_COGNITO_APP_CLIENT_ID --cognito-region YOUR_COGNITO_REGION --identity-pool-id YOUR_IDENTITY_POOL_ID --invoke-url YOUR_API_GATEWAY_URL --api-gateway-region YOUR_API_GATEWAY_REGION --path-template /notes --method POST --body "{\"content\":\"hello world\",\"attachment\":\"hello.jpg\"}"