Static Build Project Node.js Version

The default Node.js version used is 8.10.x but can be changed to 10.x by defining engines in package.json.

Static Build npm Dependencies

For dependencies listed in the package.json file, the following behavior is used:

• If a package-lock.json file is present in the project, npm install is used.
• Otherwise, yarn is used, by default.

Node.js Version

The default Node.js version used is 8.10.x but can be changed to 10.x by defining engines in package.json.

Node.js Dependencies

For dependencies listed in a package.json file at the root of a project, the following behavior is used:

• If a package-lock.json file is present in the project, npm install is used.
• Otherwise, yarn is used, by default.

Using TypeScript with the Node.js Builder

The Node.js Builder supports files ending with .ts inside of the /api directory as TypeScript files to compile and serve when deploying.

An example TypeScript file that exports a default Node.js function and takes in the standard Node.js Request and Response objects is as follows:

import { NowRequest, NowResponse } from '@now/node'

export default function(req: NowRequest, res: NowResponse) {
  const { name = 'World' } = req.query
  res.send(`Hello ${name}!`)
}

An example serverless Node.js function written in TypeScript, using types from the @now/node module for the helper methods.

The NowRequest and NowResponse imports in the above example are types that we provide for the Request and Response objects, including the helper methods with ZEIT Now. These types can be installed from npm with the following command:

npm install @now/node --save-dev

Installing @now/node for types when using Node.js on ZEIT Now.

You can also use a tsconfig.json file at the root of your project to configure the TypeScript compiler. Most options are supported aside from "Path Mappings" and "Project References".

Node.js Request and Response Objects

Each request to a Node.js Serverless Function gives access to Request and Response objects. These objects are the standard HTTP Request and Response objects from Node.js.

Node.js Helpers

ZEIT Now additionally provides helper methods inside of the Request and Response objects passed to Node.js Serverless Functions. These methods are:

The following Node.js Serverless Function example showcases the use of req.query, req.cookies and req.body helpers:

module.exports = (req, res) => {
  let who = 'anonymous'

  if (req.body && req.body.who) {
    who = req.body.who
  } else if (req.query.who) {
    who = req.query.who
  } else if (req.cookies.who) {
    who = req.cookies.who
  }

  res.status(200).send(`Hello ${who}!`)
}

Example Node.js Serverless Function using the req.query, req.cookies, and req.body helpers. It returns greetings for the user specified using req.send().

req.body

We populate the req.body property with a parsed version of the content sent with the request when possible.

We follow a set of rules on the Content-type header sent by the request to do so:

With the req.body helper, you can build applications without extra dependencies or having to parse the content of the request manually.

Next.js Project Node.js Version

The default Node.js version used is 8.10.x but can be changed to 10.x by defining engines in package.json.

Next.js Project Dependencies

For dependencies listed in a package.json file at the root of a project, the following behavior is used:

• If a package-lock.json file is present in the project, npm install is used.
• Otherwise, yarn is used, by default.

Go Version

Go version 1.x is used for Go projects deployed with ZEIT Now.

Go Dependencies

The Go Builder will automatically detect a go.mod file to install dependencies at the root of a project.

Python Version

Python projects deployed with ZEIT Now use Python version 3.6.

Python Dependencies

You can install dependencies for your Python projects by defining them in a requirements.txt or a Pipfile.lock file.

Ruby Version

Ruby 2.5.5 is used.

Ruby Dependencies

This Builder supports installing dependencies defined in the Gemfile. Alternatively, dependencies can be vendored with the bundler install --deployment command (useful for gems that require native extensions). In this case, dependencies are not built on deployment.

Configuring the Build Output Directory with Static Builds Builder

If you want to configure a directory other than public for your build output, you can pass an optional distDir option in the builder's config:

{
  "version": 2,
  "builds": [
    {
      "src": "package.json",
      "use": "@now/static-build",
      "config": { "distDir": "www" }
    }
  ]
}

An example now.json file that uses the Static Builds Builder with a configured output directory.

Shell File Entry Point for Static Builds

Using a file with a .sh file extension as an entry point for the @now/static-build Builder allows you to define build instructions in a shell file.

For example, creating a shell file, with the name build.sh, with the following contents, will install and build a Hugo project:

curl -L -O https://github.com/gohugoio/hugo/releases/download/v0.55.6/hugo_0.55.6_Linux-64bit.tar.gz
tar -xzf hugo_0.55.6_Linux-64bit.tar.gz

./hugo

An example shell file that installs and builds a Hugo project.

For depencency installation with shell file entry points, yum is available.

Private npm Modules for Static Builds

To install private npm modules, define NPM_TOKEN as a build environment variable in a now.json file.

Alternatively, define NPM_RC as a build environment variable with the contents of ~/.npmrc.

Disabling Helpers for Node.js

Within a now.json configuration file at your project's root, use the following build step with config to disable helpers.

{
  "builds": [
    {
      "src": "my-file.js",
      "use": "@now/node",
      "config": { "helpers": "false" }
    }
  ]
}

An example now.json file that has a build step using the Node.js Builder with configuration.

Private npm Modules for Node.js

To install private npm modules, define NPM_TOKEN as a build environment variable in now.json.

Alternatively, define NPM_RC as a build environment variable with the contents of ~/.npmrc.

Custom Build Step for Node.js

You can run build tasks by creating a now-build script within a package.json file at the entry point's level or higher. For example:

{
  "scripts": {
    "now-build": "node ./build.js"
  }
}

An example package.json file with a now-build script to execute in the build step.

Along with build script named build.js:

const fs = require('fs')
fs.writeFile('built-time.js', (module.exports = '${new Date()}'), err => {
  if (err) throw err
  console.log('Build time file created successfully!')
})

An example Node.js file, executed by the above package.json build script.

And a .js file for the built Serverless Functions, index.js inside the /api directory:

const BuiltTime = require('./built-time')
module.exports = (req, res) => {
  res.setHeader('content-type', 'text/plain')
  res.send(`
    This Serverless Function was built at ${new Date(BuiltTime)}.
    The current time is ${new Date()}
  `)
}

An example Node.js Serverless Function, using information from the created file from the build script.

Legacy Serverful Behavior

A Node.js Builder entrypoint can contain one of the following to retain legacy serverful behavior:

• Default export server, such as module.exports = http.createServer((req, res) => { res.end('hello') }).
• Server listens on a port, such as http.createServer((req, res) => { res.end('hello') }).listen(3000).

AWS Lambda API

The Node.js Builder provides a config.awsLambdaHandler to opt into the AWS Lambda API. This is useful if you have existing functions you wish to deploy to ZEIT Now but do not want to change the API.

exports.handler = async function() {
  return {
    statusCode: 200,
    headers: {},
    body: 'Hello world'
  }
}

A file index.js that exports a handler function.

You can deploy this function with the following now.json configuration file:

{
  "version": 2,
  "builds": [
    {
      "src": "index.js",
      "use": "@now/node",
      "config": { "awsLambdaHandler": "index.handler" }
    }
  ]

The awsLambdaHandler configuration must match the file name followed by the exported function name.

The awsLambdaHandler uses the same syntax as AWS Handler which is the file name and the exported function name.

Private npm Modules for Next.js

To install private npm modules, define NPM_TOKEN as a build environment variable in now.json.

Alternatively, define NPM_RC as a build environment variable with the contents of ~/.npmrc.

Environment Variables with Next.js

To support environment variables, Next.js inlines the provided values into the JavaScript bundle at build.

You can add the env key to the next.config.js file:

module.exports = {
  env: {
    customKey: process.env.customKey,
    mySecret: process.env.mySecret
  }
}

An example next.config.js file.

Then, expose the build env in your now.json:

{
  ...
  "build": {
    "env": {
      "customKey": "value",
      "mySecret": "@my-secret-name"
    }
  }
}

An example now.json file specifying a build environment variable.

This will allow you to use process.env.customKey and process.env.mySecret in your code.

Private Packages for Go

To install private packages with go get, define GIT_CREDENTIALS as a build environment variable in now.json.

All major Git providers are supported including GitHub, GitLab, Bitbucket, as well as a self-hosted Git server.

With GitHub, you will need to create a personal token with permission to access your private repository.

{
  "build": {
    "env": {
      "GIT_CREDENTIALS": "https://username:token@github.com"
    }
  }
}

An example now.json file containing a build environment variable with the value of GitHub credentials.

Web Server Gateway Interface

The Web Server Gateway Interface (WSGI) is a calling convention for web servers to forward requests to web applications written in Python. You can use WSGI with frameworks such as Flask or Django.

Instead of defining a handler, define an app variable in your Python file, when using now.json config. For example, define a index.py file inside your project as follows:

from flask import Flask, Response
app = Flask(__name__)

@app.route('/', defaults={'path': ''})
@app.route('/<path:path>')
def catch_all(path):
    return Response("<h1>Flask on Now</h1><p>You visited: /%s</p>" % (path), mimetype="text/html")

An example index.py file, using Flask for a WSGI application.

Inside requirements.txt define:

flask==1.0.2

An example requirements.txt file, listing flask as a dependency.

Asynchronous Server Gateway Interface

The Asynchronous Server Gateway Interface (ASGI) is a calling convention for web servers to forward requests to asynchronous web applications written in Python. You can use ASGI with frameworks such as Sanic.

Instead of defining a handler, define an app variable in your Python file.

For example, define a index.py file inside a folder as follows:

from sanic import Sanic
from sanic.response import json
app = Sanic()


@app.route('/')
@app.route('/<path:path>')
async def index(request, path=""):
    return json({'hello': path})

An example index.py file, using Sanic for a ASGI application.

Inside requirements.txt define:

sanic==19.6.0

An example requirements.txt file, listing sanic as a dependency.

Rack Interface

Many Ruby frameworks interface with Rack for forwarding HTTP requests to web applications written in Ruby. You can use Rack with frameworks such as Sinatra or Rails.

Instead of defining a handler, write the application as usual, like this Sinatra application:

require 'sinatra'

get '/*' do
    'Hello world'
end

An example Sinatra application.

Inside Gemfile define:

source "https://rubygems.org"

gem "sinatra", "~> 2.0"
gem "rack", "~> 2.0"

An example Gemfile file.

Add a Rack config file at index.ru to start the application:

require './app'

run Sinatra::Application

An example index.ru file.

Caching Data

A builder can retain an archive of up to 100mb of the filesystem at build time. The cache key is generated as a combination of:

• Project name.
• Team id or user id.
• Entrypoint path (e.g., api/users/index.go).
• Builder identifier including version (e.g.: @now/go@0.0.1).

The cache will be invalidated if any of those items changes. The user can bypass the cache by running now -f.

Limits

• Builders can run for a maximum of 5 minutes before the execution times out.
• The maximum cache archive size of a Builder is 100mb.
• The cache TTL is 7 days.

Including Additional Files

Most Builders use static analysis to determine which source files should be included in the Serverless Function output based on the build src input. Any unused code or assets is ignored to ensure your Serverless Function is as small as possible.

For example, the Node Builder looks at calls to require() or fs.readFile() in order to determine which files to include automatically.

// index.js
const { readFileSync } = require('fs');
const { join } = require('path');
const file = readFileSync(join(__dirname, 'config', 'ci.yml'), 'utf8');

In some cases, you may wish to include templates or views that are not able to be statically analyzed. Builders provide a configuration for includeFiles that accepts an array of globs that will always be included in the Serverless Functions output.

{
  "builds": [
    {
      "src": "index.js",
      "use": "@now/node",
      "config": {
        "includeFiles": [
          "templates/**",
          "views/**"
        ]
      }
    }
  ]
}