Publish

- @now/go@0.5.10
 - @now/next@0.6.0
 - @now/node@0.12.6
 - @now/python@0.2.15
 - @now/static-build@0.9.7

.eslintignore

@@ -7,11 +7,11 @@
 /packages/now-build-utils/src/fs/*.js
 /packages/now-node/dist/*
 /packages/now-next/dist/*
+/packages/now-next/test/fixtures/**
 /packages/now-node-bridge/*
 /packages/now-python/dist/*
-/packages/now-optipng/dist/*
 /packages/now-go/*
-/packages/now-rust/dist/*
 /packages/now-ruby/dist/*
 /packages/now-static-build/dist/*
 /packages/now-static-build/test/fixtures/**
+/packages/now-routing-utils/dist/*

.github/CODEOWNERS

@@ -2,10 +2,12 @@
 # https://help.github.com/en/articles/about-code-owners
 
 *                         @styfle
+/packages/now-build-utils @styfle @AndyBitz
 /packages/now-node        @styfle @tootallnate @lucleray
 /packages/now-node-bridge @styfle @tootallnate @lucleray
 /packages/now-next        @timer
 /packages/now-go          @styfle @sophearak
 /packages/now-python      @styfle @sophearak
-/packages/now-rust        @styfle @mike-engel @anmonteiro
 /packages/now-ruby        @styfle @coetry @nathancahill
+/packages/now-static-build @styfle @AndyBitz
+/packages/now-routing-utils @dav-is

.kodiak.toml

@@ -0,0 +1,16 @@
+version = 1
+
+[merge]
+automerge_label = "automerge"
+blacklist_title_regex = "^WIP.*"
+blacklist_labels = ["work in progress"]
+method = "squash"
+delete_branch_on_merge = true
+block_on_reviews_requested = false
+notify_on_conflict = true
+optimistic_updates = true
+
+[merge.message]
+title = "pull_request_title"
+include_pr_number = true
+body_type = "markdown"

DEVELOPING_A_BUILDER.md

@@ -0,0 +1,447 @@
+# Builders Developer Reference
+
+The following page is a reference for how to create a Builder using the available Builder's API.
+
+A Builder is an npm module that exposes a `build` function and optionally an `analyze` function and `prepareCache` function.
+Official Builders are published to [npmjs.com](https://npmjs.com) as a package and referenced in the `use` property of the `now.json` configuration file.
+However, the `use` property will work with any [npm install argument](https://docs.npmjs.com/cli/install) such as a git repo url which is useful for testing your Builder.
+
+See the [Builders Documentation](https://zeit.co/docs/v2/advanced/builders) to view example usage.
+
+## Builder Exports
+
+### `version`
+
+A **required** exported constant that decides which version of the Builder API to use.
+
+The latest and suggested version is `2`.
+
+### `analyze`
+
+An **optional** exported function that returns a unique fingerprint used for the purpose of [build de-duplication](https://zeit.co/docs/v2/advanced/concepts/immutability#deduplication-algorithm). If the `analyze` function is not supplied, a random fingerprint is assigned to each build.
+
+```js
+export analyze({
+  files: Files,
+  entrypoint: String,
+  workPath: String,
+  config: Object
+}) : String fingerprint
+```
+
+If you are using TypeScript, you should use the following types:
+
+```ts
+import { AnalyzeOptions } from '@now/build-utils'
+
+export analyze(options: AnalyzeOptions) {
+  return 'fingerprint goes here'
+}
+```
+
+### `build`
+
+A **required** exported function that returns a [Files](#files) data structure that contains the Build outputs, which can be a [Static File](#file) or a [Serverless Function](#serverless-function).
+
+What's a Serverless Function? Read about [Serverless Function concepts](https://zeit.co/docs/v2/deployments/concepts/lambdas) to learn more.
+
+```js
+build({
+  files: Files,
+  entrypoint: String,
+  workPath: String,
+  config: Object,
+  meta?: {
+    isDev?: Boolean,
+    requestPath?: String,
+    filesChanged?: Array<String>,
+    filesRemoved?: Array<String>
+  }
+}) : {
+  watch: Array<String>,
+  output: Files output,
+  routes: Object
+}
+```
+
+If you are using TypeScript, you should use the following types:
+
+```ts
+import { BuildOptions } from '@now/build-utils'
+
+export build(options: BuildOptions) {
+  // Build the code here
+
+  return {
+    output: {
+      'path-to-file': File,
+      'path-to-lambda': Lambda
+    },
+    watch: [],
+    routes: {}
+  }
+}
+```
+
+### `prepareCache`
+
+An **optional** exported function that is equivalent to [`build`](#build), but it executes the instructions necessary to prepare a cache for the next run.
+
+```js
+prepareCache({
+  files: Files,
+  entrypoint: String,
+  workPath: String,
+  cachePath: String,
+  config: Object
+}) : Files cacheOutput
+```
+
+If you are using TypeScript, you can import the types for each of these functions by using the following:
+
+```ts
+import { PrepareCacheOptions } from '@now/build-utils'
+
+export prepareCache(options: PrepareCacheOptions) {
+  return { 'path-to-file': File }
+}
+```
+
+### `shouldServe`
+
+An **optional** exported function that is only used by `now dev` in [Now CLI](https:///download) and indicates whether a [Builder](https://zeit.co/docs/v2/advanced/builders) wants to be responsible for building a certain request path.
+
+```js
+shouldServe({
+  entrypoint: String,
+  files: Files,
+  config: Object,
+  requestPath: String,
+  workPath: String
+}) : Boolean
+```
+
+If you are using TypeScript, you can import the types for each of these functions by using the following:
+
+```ts
+import { ShouldServeOptions } from '@now/build-utils'
+
+export shouldServe(options: ShouldServeOptions) {
+  return Boolean
+}
+```
+
+If this method is not defined, Now CLI will default to [this function](https://github.com/zeit/now-builders/blob/52994bfe26c5f4f179bdb49783ee57ce19334631/packages/now-build-utils/src/should-serve.ts).
+
+### Builder Options
+
+The exported functions [`analyze`](#analyze), [`build`](#build), and [`prepareCache`](#preparecache) receive one argument with the following properties.
+
+**Properties:**
+
+- `files`: All source files of the project as a [Files](#files) data structure.
+- `entrypoint`: Name of entrypoint file for this particular build job. Value `files[entrypoint]` is guaranteed to exist and be a valid [File](#files) reference. `entrypoint` is always a discrete file and never a glob, since globs are expanded into separate builds at deployment time.
+- `workPath`: A writable temporary directory where you are encouraged to perform your build process. This directory will be populated with the restored cache from the previous run (if any) for [`analyze`](#analyze) and [`build`](#build).
+- `cachePath`: A writable temporary directory where you can build a cache for the next run. This is only passed to `prepareCache`.
+- `config`: An arbitrary object passed from by the user in the [Build definition](#defining-the-build-step) in `now.json`.
+
+## Example: html-minifier
+
+Let's walk through what it takes to create a simple builder that takes in a HTML source file and yields a minified HTML static file as its build output.
+
+While this is a very simple builder, the approach demonstrated here can be used to return anything: one or more static files and/or one or more lambdas.
+
+## Setting up the module
+
+### Defining the analyze step
+
+The `analyze` hook is optional. Its goal is to give the developer a tool to avoid wasting time _re-computing a build_ that has already occurred.
+
+The return value of `analyze` is a _fingerprint_: a simple string that uniquely identifies the build process.
+
+If `analyze` is not specified, its behavior is to use as the fingerprint the combined checksums of **all the files in the same directory level as the entrypoint**. This is a default that errs on making sure that we re-execute builds when files _other than the entrypoint_ (like dependencies, manifest files, etc) have changed.
+
+For our `html-minify` example, we know that HTML files don't have dependencies. Therefore, our analyze step can just return the `digest` of the entrypoint.
+
+Our `index.js` file looks as follows:
+
+```js
+exports.analyze = function({ files, entrypoint }) {
+  return files[entrypoint].digest
+}
+```
+
+This means that we will only re-minify and re-create the build output _only if the file contents (and therefore its digest) change._
+
+### Defining the build step
+
+Your module will need some utilities to manipulate the data structures we pass you, create new ones and alter the filesystem.
+
+To that end, we expose our API as part of a `@now/build-utils` package. This package is always loaded on your behalf, so make sure it's only included as `peerDependencies` in your `package.json`.
+
+Builders can include dependencies of their liking:
+
+```js
+const htmlMinifier = require('html-minifier')
+
+exports.version = 2
+
+exports.analyze = ({ files, entrypoint }) => files[entrypoint].digest
+
+exports.build = async ({ files, entrypoint, config }) => {
+  const stream = files[entrypoint].toStream()
+  const options = Object.assign({}, config || {})
+  const { data } = await FileBlob.fromStream({ stream })
+  const content = data.toString()
+  const minified = htmlMinifier(content, options)
+  const result = new FileBlob({ data: minified })
+
+  return {
+    output: {
+      [entrypoint]: result
+    },
+    watch: [],
+    routes: {}
+  }
+}
+```
+
+### Defining a `prepareCache` step
+
+If our builder had performed work that could be re-used in the next build invocation, we could define a `prepareCache` step.
+
+In this case, there are not intermediate artifacts that we can cache, and our `analyze` step already takes care of caching the full output based on the fingerprint of the input.
+
+## Technical Details
+
+### Execution Context
+
+A [Serverless Function](https://zeit.co/docs/v2/advanced/concepts/lambdas) is created where the builder logic is executed. The lambda is run using the Node.js 8 runtime. A brand new sandbox is created for each deployment, for security reasons. The sandbox is cleaned up between executions to ensure no lingering temporary files are shared from build to build.
+
+All the APIs you export ([`analyze`](#analyze), [`build`](#build) and [`prepareCache`](#preparecache)) are not guaranteed to be run in the same process, but the filesystem we expose (e.g.: `workPath` and the results of calling [`getWriteableDirectory`](#getWriteableDirectory) ) is retained.
+
+If you need to share state between those steps, use the filesystem.
+
+### Directory and Cache Lifecycle
+
+When a new build is created, we pre-populate the `workPath` supplied to `analyze` with the results of the `prepareCache` step of the previous build.
+
+The `analyze` step can modify that directory, and it will not be re-created when it's supplied to `build` and `prepareCache`.
+
+To learn how the cache key is computed and invalidated, refer to the [overview](https://zeit.co/docs/v2/advanced/builders#technical-details).
+
+### Accessing Environment and Secrets
+
+The env and secrets specified by the user as `build.env` are passed to the builder process. This means you can access user env via `process.env` in Node.js.
+
+### Utilities as peerDependencies
+
+When you publish your builder to npm, make sure to not specify `@now/build-utils` (as seen below in the API definitions) as a dependency, but rather as part of `peerDependencies`.
+
+## Types
+
+### `Files`
+
+```ts
+import { File } from '@now/build-utils'
+type Files = { [filePath: string]: File }
+```
+
+This is an abstract type that is implemented as a plain [JavaScript Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object). It's helpful to think of it as a virtual filesystem representation.
+
+When used as an input, the `Files` object will only contain `FileRefs`. When `Files` is an output, it may consist of `Lambda` (Serverless Functions) types as well as `FileRefs`.
+
+An example of a valid output `Files` object is:
+
+```json
+{
+  "index.html": FileRef,
+  "api/index.js": Lambda
+}
+```
+
+### `File`
+
+This is an abstract type that can be imported if you are using TypeScript.
+
+```ts
+import { File } from '@now/build-utils'
+```
+
+Valid `File` types include:
+
+- [`FileRef`](#fileref)
+- [`FileFsRef`](#filefsref)
+- [`FileBlob`](#fileblob)
+
+### `FileRef`
+
+```ts
+import { FileRef } from '@now/build-utils'
+```
+
+This is a [JavaScript class](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes) that represents an abstract file instance stored in our platform, based on the file identifier string (its checksum). When a `Files` object is passed as an input to `analyze` or `build`, all its values will be instances of `FileRef`.
+
+**Properties:**
+
+- `mode : Number` file mode
+- `digest : String` a checksum that represents the file
+
+**Methods:**
+
+- `toStream() : Stream` creates a [Stream](https://nodejs.org/api/stream.html) of the file body
+
+### `FileFsRef`
+
+```ts
+import { FileFsRef } from '@now/build-utils'
+```
+
+This is a [JavaScript class](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes) that represents an abstract instance of a file present in the filesystem that the build process is executing in.
+
+**Properties:**
+
+- `mode : Number` file mode
+- `fsPath : String` the absolute path of the file in file system
+
+**Methods:**
+
+- `static async fromStream({ mode : Number, stream : Stream, fsPath : String }) : FileFsRef` creates an instance of a [FileFsRef](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object) from `Stream`, placing file at `fsPath` with `mode`
+- `toStream() : Stream` creates a [Stream](https://nodejs.org/api/stream.html) of the file body
+
+### `FileBlob`
+
+```ts
+import { FileBlob } from '@now/build-utils'
+```
+
+This is a [JavaScript class](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes) that represents an abstract instance of a file present in memory.
+
+**Properties:**
+
+- `mode : Number` file mode
+- `data : String | Buffer` the body of the file
+
+**Methods:**
+
+- `static async fromStream({ mode : Number, stream : Stream }) :FileBlob` creates an instance of a [FileBlob](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object) from [`Stream`](https://nodejs.org/api/stream.html) with `mode`
+- `toStream() : Stream` creates a [Stream](https://nodejs.org/api/stream.html) of the file body
+
+### `Lambda`
+
+```ts
+import { Lambda } from '@now/build-utils'
+```
+
+This is a [JavaScript class](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes), called a Serverless Function, that can be created by supplying `files`, `handler`, `runtime`, and `environment` as an object to the [`createLambda`](#createlambda) helper. The instances of this class should not be created directly. Instead use a call to [`createLambda`](#createlambda).
+
+**Properties:**
+
+- `files : Files` the internal filesystem of the lambda
+- `handler : String` path to handler file and (optionally) a function name it exports
+- `runtime : LambdaRuntime` the name of the lambda runtime
+- `environment : Object` key-value map of handler-related (aside of those passed by user) environment variables
+
+### `LambdaRuntime`
+
+This is an abstract enumeration type that is implemented by one of the following possible `String` values:
+
+- `nodejs10.x`
+- `nodejs8.10`
+- `go1.x`
+- `java-1.8.0-openjdk`
+- `python3.6`
+- `python2.7`
+- `dotnetcore2.1`
+- `dotnetcore2.0`
+- `dotnetcore1.0`
+
+## JavaScript API
+
+The following is exposed by `@now/build-utils` to simplify the process of writing Builders, manipulating the file system, using the above types, etc.
+
+### `createLambda`
+
+Signature: `createLambda(Object spec) : Lambda`
+
+```ts
+import { createLambda } from '@now/build-utils'
+```
+
+Constructor for the [`Lambda`](#lambda) type.
+
+```js
+const { createLambda, FileBlob } = require('@now/build-utils')
+await createLambda({
+  runtime: 'nodejs8.10',
+  handler: 'index.main',
+  files: {
+    'index.js': new FileBlob({ data: 'exports.main = () => {}' })
+  }
+})
+```
+
+### `download`
+
+Signature: `download() : Files`
+
+```ts
+import { download } from '@now/build-utils'
+```
+
+This utility allows you to download the contents of a [`Files`](#files) data structure, therefore creating the filesystem represented in it.
+
+Since `Files` is an abstract way of representing files, you can think of `download` as a way of making that virtual filesystem _real_.
+
+If the **optional** `meta` property is passed (the argument for [build](#build)), only the files that have changed are downloaded. This is decided using `filesRemoved` and `filesChanged` inside that object.
+
+```js
+await download(files, workPath, meta)
+```
+
+### `glob`
+
+Signature: `glob() : Files`
+
+```ts
+import { glob } from '@now/build-utils'
+```
+
+This utility allows you to _scan_ the filesystem and return a [`Files`](#files) representation of the matched glob search string. It can be thought of as the reverse of [`download`](#download).
+
+The following trivial example downloads everything to the filesystem, only to return it back (therefore just re-creating the passed-in [`Files`](#files)):
+
+```js
+const { glob, download } = require('@now/build-utils')
+
+exports.build = ({ files, workPath }) => {
+  await download(files, workPath)
+  return glob('**', workPath)
+}
+```
+
+### `getWriteableDirectory`
+
+Signature: `getWriteableDirectory() : String`
+
+```ts
+import { getWriteableDirectory } from '@now/build-utils'
+```
+
+In some occasions, you might want to write to a temporary directory.
+
+### `rename`
+
+Signature: `rename(Files) : Files`
+
+```ts
+import { rename } from '@now/build-utils'
+```
+
+Renames the keys of the [`Files`](#files) object, which represent the paths. For example, to remove the `*.go` suffix you can use:
+
+```js
+const rename = require('@now/build-utils')
+const originalFiles = { 'one.go': fileFsRef1, 'two.go': fileFsRef2 }
+const renamedFiles = rename(originalFiles, path => path.replace(/\.go$/, '')
+```

PUBLISHING.md

@@ -0,0 +1,40 @@
+# Publishing to npm
+
+Always publish to the Canary Channel as soon as a PR is merged into the `canary` branch.
+
+```
+yarn publish-canary
+```
+
+Publish the Stable Channel weekly.
+
+- Cherry pick each commit from `canary` to `master` branch
+- Verify that you are _in-sync_ with canary (with the exception of the `version` line in `package.json`)
+- Deploy the modified Builders
+
+```
+# View differences excluding "Publish" commits
+git checkout canary && git pull
+git log --pretty=format:"$ad- %s [%an]" | grep -v Publish > ~/Desktop/canary.txt
+git checkout master && git pull
+git log --pretty=format:"$ad- %s [%an]" | grep -v Publish > ~/Desktop/master.txt
+diff ~/Desktop/canary.txt ~/Desktop/master.txt
+
+# Cherry pick all PRs from canary into master ...
+git cherry-pick <PR501_COMMIT_SHA>
+git cherry-pick <PR502_COMMIT_SHA>
+git cherry-pick <PR503_COMMIT_SHA>
+git cherry-pick <PR504_COMMIT_SHA>
+
+# Verify the only difference is "version" in package.json
+git diff origin/canary
+
+# Ship it
+yarn publish-stable
+```
+
+After running this publish step, GitHub Actions will take care of publishing the modified Builder packages to npm.
+
+If for some reason GitHub Actions fails to publish the npm package, you may do so
+manually by running `npm publish` from the package directory. Make sure to
+use `npm publish --tag canary` if you are publishing a canary release!

README.md

@@ -1,61 +1,19 @@
 # now-builders
 
-This is a monorepo containing the [Official Builders](https://zeit.co/docs/v2/deployments/builders/overview) provided by the ZEIT team.
+This is a monorepo containing the [Official Builders](https://zeit.co/docs/v2/advanced/builders) provided by the ZEIT team.
 
-## Channels
+## Versioning and advanced usage
 
-There are two Channels:
+See [VERSIONING.md](VERSIONING.md).
 
-| Channel | Git Branch                                                    | npm dist-tag | use example        |
-| ------- | ------------------------------------------------------------- | ------------ | ------------------ |
-| Canary  | [canary](https://github.com/zeit/now-builders/commits/canary) | `@canary`    | `@now/node@canary` |
-| Stable  | [master](https://github.com/zeit/now-builders/commits/master) | `@latest`    | `@now/node@latest` |
+## Publishing to npm
 
-All PRs should be submitted to the `canary` branch.
+See [PUBLISHING.md](PUBLISHING.md).
 
-Once a PR is merged into the `canary` branch, it should be published to npm immediately using the Canary Channel.
+## Contributing
 
-### Publishing to npm
+See [CONTRIBUTING.md](CONTRIBUTING.md).
 
-For the Canary Channel, publish the modified Builders to npm with the following:
+### Creating Your Own Builder
 
-```
-yarn publish-canary
-```
-
-For the Stable Channel, you must do the following:
-
-- Cherry pick each commit from canary to master
-- Verify that you are _in-sync_ with canary (with the exception of the `version` line in `package.json`)
-- Deploy the modified Builders
-
-```
-# View differences excluding "Publish" commits
-git checkout canary && git pull
-git log --pretty=format:"$ad- %s [%an]" | grep -v Publish > ~/Desktop/canary.txt
-git checkout master && git pull
-git log --pretty=format:"$ad- %s [%an]" | grep -v Publish > ~/Desktop/master.txt
-diff ~/Desktop/canary.txt ~/Desktop/master.txt
-
-# Cherry pick all PRs from canary into master ...
-git cherry-pick <PR501_COMMIT_SHA>
-git cherry-pick <PR502_COMMIT_SHA>
-git cherry-pick <PR503_COMMIT_SHA>
-git cherry-pick <PR504_COMMIT_SHA>
-
-# Verify the only difference is "version" in package.json
-git diff origin/canary
-
-# Ship it
-yarn publish-stable
-```
-
-After running this publish step, GitHub Actions will take care of publishing the modified Builder packages to npm.
-
-If for some reason GitHub Actions fails to publish the npm package, you may do so
-manually by running `npm publish` from the package directory. Make sure to
-use `npm publish --tag canary` if you are publishing a canary release!
-
-### Contributing
-
-See the [Contribution guidelines for this project](CONTRIBUTING.md), it also contains guidance on interpreting tests failures.
+See [DEVELOPING_A_BUILDER.md](DEVELOPING_A_BUILDER.md).

VERSIONING.md

@@ -0,0 +1,25 @@
+# Versioning
+
+Builders are released to two different channels.
+
+## Channels
+
+| Channel | Git Branch                                                    | npm dist-tag | use example        |
+| ------- | ------------------------------------------------------------- | ------------ | ------------------ |
+| Canary  | [canary](https://github.com/zeit/now-builders/commits/canary) | `@canary`    | `@now/node@canary` |
+| Stable  | [master](https://github.com/zeit/now-builders/commits/master) | `@latest`    | `@now/node@latest` |
+
+All PRs are submitted to the `canary` branch. Once a PR is merged into the `canary` branch, it should be published to npm immediately using the Canary Channel.
+
+## Version Selection
+
+Since Builders are published to [npmjs.com](https://npmjs.com), this makes versioning works the same for Builders as it does for any npm package. The `use` statement in [now.json](https://zeit.co/docs/v2/advanced/configuration#builds) has a similar syntax to `npm install`.
+
+The following are valid examples [@now/node](https://www.npmjs.com/package/@now/node?activeTab=versions):
+
+- `@now/node`
+- `@now/node@0.7.3`
+- `@now/node@canary`
+- `@now/node@0.7.2-canary.2`
+
+We always recommend using the latest version by leaving off the dist-tag suffix, `@now/node` for example.

package.json

@@ -44,6 +44,7 @@
   },
   "devDependencies": {
     "@types/node": "*",
+    "@zeit/ncc": "0.20.4",
     "async-retry": "1.2.3",
     "buffer-replace": "1.0.0",
     "codecov": "3.2.0",

packages/now-bash/.editorconfig

@@ -1,32 +0,0 @@
-root = true
-
-[*]
-indent_style = tab
-indent_size = 4
-tab_width = 4
-end_of_line = lf
-charset = utf-8
-trim_trailing_whitespace = true
-insert_final_newline = true
-
-[{*.json,*.json.example,*.gyp,*.yml}]
-indent_style = space
-indent_size = 2
-
-[*.py]
-indent_style = space
-indent_size = 4
-
-[*.md]
-trim_trailing_whitespace = false
-
-# Ideal settings - some plugins might support these.
-[*.js]
-quote_type = single
-
-[{*.c,*.cc,*.h,*.hh,*.cpp,*.hpp,*.m,*.mm,*.mpp,*.js,*.java,*.go,*.rs,*.php,*.ng,*.jsx,*.ts,*.d,*.cs,*.swift}]
-curly_bracket_next_line = false
-spaces_around_operators = true
-spaces_around_brackets = outside
-# close enough to 1TB
-indent_brace_style = K&R

packages/now-bash/.gitignore

@@ -1,2 +0,0 @@
-node_modules
-handler

packages/now-bash/bootstrap

@@ -1,16 +0,0 @@
-#!/bin/bash
-set -euo pipefail
-cd "$LAMBDA_TASK_ROOT"
-
-# Configure `import`
-export IMPORT_CACHE="$LAMBDA_TASK_ROOT/.import-cache"
-export PATH="$IMPORT_CACHE/bin:$PATH"
-
-# Load `import` and runtime
-# shellcheck disable=SC1090
-. "$(which import)"
-# shellcheck disable=SC1090
-. "$IMPORT_CACHE/runtime.sh"
-
-# Load user code and process events in a loop forever
-_lambda_runtime_init

packages/now-bash/builder.sh

@@ -1,40 +0,0 @@
-#!/bin/bash
-set -euo pipefail
-
-# `import` debug logs are always enabled during build
-export IMPORT_DEBUG=1
-
-# Install `import`
-IMPORT_BIN="$IMPORT_CACHE/bin/import"
-mkdir -p "$(dirname "$IMPORT_BIN")"
-curl -sfLS https://import.pw > "$IMPORT_BIN"
-chmod +x "$IMPORT_BIN"
-
-# For now only the entrypoint file is copied into the lambda
-mkdir -p "$(dirname "$DIST/$ENTRYPOINT")"
-cp "$ENTRYPOINT" "$DIST/$ENTRYPOINT"
-
-# Copy in the runtime
-cp "$BUILDER/runtime.sh" "$IMPORT_CACHE"
-cp "$BUILDER/bootstrap" "$DIST"
-
-# Load `import`
-. "$(which import)"
-
-# Cache runtime and user dependencies
-echo "Caching imports in \"$ENTRYPOINT\"…"
-. "$IMPORT_CACHE/runtime.sh"
-. "$DIST/$ENTRYPOINT"
-echo "Done caching imports"
-
-# Run user build script
-if declare -f build > /dev/null; then
-	echo "Running \`build\` function in \"$ENTRYPOINT\"…"
-	build "$@"
-fi
-
-# Ensure the entrypoint defined a `handler` function
-if ! declare -f handler > /dev/null; then
-	echo "ERROR: A \`handler\` function must be defined in \"$ENTRYPOINT\"!" >&2
-	exit 1
-fi

packages/now-bash/index.js

@@ -1,79 +0,0 @@
-const execa = require('execa');
-const { join } = require('path');
-const snakeCase = require('snake-case');
-const {
-  glob,
-  download,
-  createLambda,
-  shouldServe,
-} = require('@now/build-utils'); // eslint-disable-line import/no-extraneous-dependencies
-
-// From this list: https://import.pw/importpw/import/docs/config.md
-const allowedConfigImports = new Set([
-  'CACHE',
-  'CURL_OPTS',
-  'DEBUG',
-  'RELOAD',
-  'SERVER',
-]);
-
-exports.analyze = ({ files, entrypoint }) => files[entrypoint].digest;
-
-exports.build = async ({
-  workPath, files, entrypoint, meta, config,
-}) => {
-  console.log('downloading files...');
-  await download(files, workPath, meta);
-
-  const distPath = join(workPath, 'dist');
-
-  const configEnv = Object.keys(config).reduce((o, v) => {
-    const name = snakeCase(v).toUpperCase();
-
-    if (allowedConfigImports.has(name)) {
-      o[`IMPORT_${name}`] = config[v]; // eslint-disable-line no-param-reassign
-    }
-
-    return o;
-  }, {});
-
-  if (config && config.import) {
-    Object.keys(config.import).forEach((key) => {
-      const name = snakeCase(key).toUpperCase();
-      // eslint-disable-next-line no-param-reassign
-      configEnv[`IMPORT_${name}`] = config.import[key];
-    });
-  }
-
-  const IMPORT_CACHE = `${distPath}/.import-cache`;
-  const env = Object.assign({}, process.env, configEnv, {
-    PATH: `${IMPORT_CACHE}/bin:${process.env.PATH}`,
-    IMPORT_CACHE,
-    DIST: distPath,
-    BUILDER: __dirname,
-    ENTRYPOINT: entrypoint,
-  });
-
-  const builderPath = join(__dirname, 'builder.sh');
-
-  await execa(builderPath, [entrypoint], {
-    env,
-    cwd: workPath,
-    stdio: 'inherit',
-  });
-
-  const lambda = await createLambda({
-    files: await glob('**', distPath),
-    handler: entrypoint, // not actually used in `bootstrap`
-    runtime: 'provided',
-    environment: Object.assign({}, configEnv, {
-      SCRIPT_FILENAME: entrypoint,
-    }),
-  });
-
-  return {
-    [entrypoint]: lambda,
-  };
-};
-
-exports.shouldServe = shouldServe;

packages/now-bash/package.json

@@ -1,28 +0,0 @@
-{
-  "name": "@now/bash",
-  "version": "1.0.3",
-  "description": "Now 2.0 builder for HTTP endpoints written in Bash",
-  "main": "index.js",
-  "author": "Nathan Rajlich <nate@zeit.co>",
-  "license": "MIT",
-  "homepage": "https://zeit.co/docs/v2/deployments/official-builders/bash-now-bash",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/zeit/now-builders.git",
-    "directory": "packages/now-bash"
-  },
-  "files": [
-    "builder.sh",
-    "runtime.sh",
-    "bootstrap",
-    "index.js",
-    "package.json"
-  ],
-  "dependencies": {
-    "execa": "^1.0.0",
-    "snake-case": "^2.1.0"
-  },
-  "scripts": {
-    "test": "jest"
-  }
-}

packages/now-bash/runtime.sh

@@ -1,119 +0,0 @@
-#!/bin/bash
-import "static-binaries@1.0.0"
-static_binaries jq
-
-# These get reset upon each request
-_STATUS_CODE="$(mktemp)"
-_HEADERS="$(mktemp)"
-
-_lambda_runtime_api() {
-	local endpoint="$1"
-	shift
-	curl -sfLS "http://$AWS_LAMBDA_RUNTIME_API/2018-06-01/runtime/$endpoint" "$@"
-}
-
-_lambda_runtime_init() {
-	# Initialize user code
-	# shellcheck disable=SC1090
-	. "$SCRIPT_FILENAME" || {
-		local exit_code="$?"
-		local error_message="Initialization failed for '$SCRIPT_FILENAME' (exit code $exit_code)"
-		echo "$error_message" >&2
-		local error='{"errorMessage":"'"$error_message"'"}'
-		_lambda_runtime_api "init/error" -X POST -d "$error"
-		exit "$exit_code"
-	}
-
-	# Process events
-	while true; do _lambda_runtime_next; done
-}
-
-_lambda_runtime_next() {
-	echo 200 > "$_STATUS_CODE"
-	echo '{"content-type":"text/plain; charset=utf8"}' > "$_HEADERS"
-
-	local headers
-	headers="$(mktemp)"
-
-	# Get an event
-	local event
-	event="$(mktemp)"
-	_lambda_runtime_api invocation/next -D "$headers" | jq --raw-output --monochrome-output '.body' > "$event"
-
-	local request_id
-	request_id="$(grep -Fi Lambda-Runtime-Aws-Request-Id "$headers" | tr -d '[:space:]' | cut -d: -f2)"
-	rm -f "$headers"
-
-	# Execute the handler function from the script
-	local body
-	body="$(mktemp)"
-
-	# Stdin of the `handler` function is the HTTP request body.
-	# Need to use a fifo here instead of bash <() because Lambda
-	# errors with "/dev/fd/63 not found" for some reason :/
-	local stdin
-	stdin="$(mktemp -u)"
-	mkfifo "$stdin"
-	_lambda_runtime_body < "$event" > "$stdin" &
-
-	local exit_code=0
-	handler "$event" < "$stdin" > "$body" || exit_code="$?"
-
-	rm -f "$event" "$stdin"
-
-	if [ "$exit_code" -eq 0 ]; then
-		# Send the response
-		jq --raw-input --raw-output --compact-output --slurp --monochrome-output \
-			--arg statusCode "$(cat "$_STATUS_CODE")" \
-			--argjson headers "$(cat "$_HEADERS")" \
-			'{statusCode:$statusCode|tonumber, headers:$headers, encoding:"base64", body:.|@base64}' < "$body" \
-			| _lambda_runtime_api "invocation/$request_id/response" -X POST -d @- > /dev/null
-		rm -f "$body" "$_HEADERS"
-	else
-		local error_message="Invocation failed for 'handler' function in '$SCRIPT_FILENAME' (exit code $exit_code)"
-		echo "$error_message" >&2
-		_lambda_runtime_api "invocation/$request_id/error" -X POST -d '{"errorMessage":"'"$error_message"'"}' > /dev/null
-	fi
-}
-
-_lambda_runtime_body() {
-	local event
-	event="$(cat)"
-	if [ "$(jq --raw-output '.body | type' <<< "$event")" = "string" ]; then
-		if [ "$(jq --raw-output '.encoding' <<< "$event")" = "base64" ]; then
-			jq --raw-output '.body' <<< "$event" | base64 --decode
-		else
-			# assume plain-text body
-			jq --raw-output '.body' <<< "$event"
-		fi
-	fi
-}
-
-
-# Set the response status code.
-http_response_code() {
-	echo "$1" > "$_STATUS_CODE"
-}
-
-# Sets a response header.
-# Overrides existing header if it has already been set.
-http_response_header() {
-	local name="$1"
-	local value="$2"
-	local tmp
-	tmp="$(mktemp)"
-	jq \
-		--arg name "$name" \
-		--arg value "$value" \
-		'.[$name] = $value' < "$_HEADERS" > "$tmp"
-	mv -f "$tmp" "$_HEADERS"
-}
-
-http_response_redirect() {
-	http_response_code "${2:-302}"
-	http_response_header "location" "$1"
-}
-
-http_response_json() {
-	http_response_header "content-type" "application/json; charset=utf8"
-}

packages/now-bash/test/fixtures/01-cowsay/index.sh

@@ -1,3 +0,0 @@
-handler() {
-  echo "cow:RANDOMNESS_PLACEHOLDER"
-}

packages/now-bash/test/fixtures/01-cowsay/now.json

@@ -1,11 +0,0 @@
-{
-  "version": 2,
-  "builds": [
-    { "src": "index.sh", "use": "@now/bash" },
-    { "src": "subdirectory/index.sh", "use": "@now/bash" }
-  ],
-  "probes": [
-    { "path": "/", "mustContain": "cow:RANDOMNESS_PLACEHOLDER" },
-    { "path": "/subdirectory/", "mustContain": "yoda:RANDOMNESS_PLACEHOLDER" }
-  ]
-}

packages/now-bash/test/fixtures/01-cowsay/subdirectory/index.sh

@@ -1,3 +0,0 @@
-handler() {
-  echo "yoda:RANDOMNESS_PLACEHOLDER"
-}

packages/now-build-utils/build.sh

@@ -0,0 +1,6 @@
+tsc
+
+rm dist/index.js
+ncc build src/index.ts -o dist/main
+mv dist/main/index.js dist/index.js
+rm -rf dist/main

packages/now-build-utils/fs/download.js

@@ -1 +1 @@
-module.exports = require('../dist/fs/download').default;
+module.exports = require('../dist/index').download;

packages/now-build-utils/fs/get-writable-directory.js

@@ -1 +1 @@
-module.exports = require('../dist/fs/get-writable-directory').default;
+module.exports = require('../dist/index').getWriteableDirectory;

packages/now-build-utils/fs/glob.js

@@ -1 +1 @@
-module.exports = require('../dist/fs/glob').default;
+module.exports = require('../dist/index').glob;

packages/now-build-utils/fs/rename.js

@@ -1 +1 @@
-module.exports = require('../dist/fs/rename').default;
+module.exports = require('../dist/index').rename;

packages/now-build-utils/fs/run-user-scripts.js

@@ -1 +1 @@
-module.exports = require('../dist/fs/run-user-scripts');
+module.exports = require('../dist/index');

packages/now-build-utils/fs/stream-to-buffer.js

@@ -1 +1 @@
-module.exports = require('../dist/fs/stream-to-buffer').default;
+module.exports = require('../dist/index').streamToBuffer;

packages/now-build-utils/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@now/build-utils",
-  "version": "0.9.0",
+  "version": "0.9.12",
   "license": "MIT",
   "main": "./dist/index.js",
   "types": "./dist/index.d.js",
@@ -11,23 +11,9 @@
     "directory": "packages/now-build-utils"
   },
   "scripts": {
-    "build": "tsc",
-    "test": "tsc && jest",
-    "prepublishOnly": "tsc"
-  },
-  "dependencies": {
-    "async-retry": "1.2.3",
-    "async-sema": "2.1.4",
-    "cross-spawn": "6.0.5",
-    "end-of-stream": "1.4.1",
-    "fs-extra": "7.0.0",
-    "glob": "7.1.3",
-    "into-stream": "5.0.0",
-    "minimatch": "3.0.4",
-    "multistream": "2.1.1",
-    "node-fetch": "2.2.0",
-    "semver": "6.1.1",
-    "yazl": "2.4.3"
+    "build": "./build.sh",
+    "test": "./build.sh && jest",
+    "prepublishOnly": "./build.sh"
   },
   "devDependencies": {
     "@types/async-retry": "^1.2.1",
@@ -39,7 +25,19 @@
     "@types/node-fetch": "^2.1.6",
     "@types/semver": "6.0.0",
     "@types/yazl": "^2.4.1",
+    "async-retry": "1.2.3",
+    "async-sema": "2.1.4",
+    "cross-spawn": "6.0.5",
+    "end-of-stream": "1.4.1",
     "execa": "^1.0.0",
-    "typescript": "3.5.2"
+    "fs-extra": "7.0.0",
+    "glob": "7.1.3",
+    "into-stream": "5.0.0",
+    "minimatch": "3.0.4",
+    "multistream": "2.1.1",
+    "node-fetch": "2.2.0",
+    "semver": "6.1.1",
+    "typescript": "3.5.2",
+    "yazl": "2.4.3"
   }
 }

packages/now-build-utils/src/debug.ts

@@ -0,0 +1,7 @@
+export default function debug(message: string, ...additional: any[]) {
+  if (process.env.NOW_BUILDER_DEBUG) {
+    console.log(message, ...additional);
+  } else if (process.env.NOW_BUILDER_ANNOTATE) {
+    console.log(`[now-builder-debug] ${message}`, ...additional);
+  }
+}

packages/now-build-utils/src/detect-builders.ts

@@ -1,11 +1,15 @@
 import { PackageJson, Builder, Config } from './types';
 import minimatch from 'minimatch';
 
-interface Warning {
+interface ErrorResponse {
   code: string;
   message: string;
 }
 
+interface Options {
+  tag?: 'canary' | 'latest';
+}
+
 const src: string = 'package.json';
 const config: Config = { zeroConfig: true };
 
@@ -15,20 +19,18 @@ const BUILDERS = new Map<string, Builder>([
 ]);
 
 const API_BUILDERS: Builder[] = [
-  { src: 'api/**/*.js', use: '@now/node@canary', config },
-  { src: 'api/**/*.ts', use: '@now/node@canary', config },
-  { src: 'api/**/*.rs', use: '@now/rust', config },
+  { src: 'api/**/*.js', use: '@now/node', config },
+  { src: 'api/**/*.ts', use: '@now/node', config },
   { src: 'api/**/*.go', use: '@now/go', config },
-  { src: 'api/**/*.php', use: '@now/php', config },
   { src: 'api/**/*.py', use: '@now/python', config },
   { src: 'api/**/*.rb', use: '@now/ruby', config },
-  { src: 'api/**/*.sh', use: '@now/bash', config },
 ];
 
-const MISSING_BUILD_SCRIPT_WARNING: Warning = {
+const MISSING_BUILD_SCRIPT_ERROR: ErrorResponse = {
   code: 'missing_build_script',
   message:
-    'Your `package.json` file is missing a `build` property inside the `script` property',
+    'Your `package.json` file is missing a `build` property inside the `script` property.' +
+    '\nMore details: https://zeit.co/docs/v2/advanced/platform/frequently-asked-questions#missing-build-script',
 };
 
 function hasPublicDirectory(files: string[]) {
@@ -64,6 +66,10 @@ export function ignoreApiFilter(file: string) {
     return false;
   }
 
+  if (file.endsWith('.d.ts')) {
+    return false;
+  }
+
   // If the file does not match any builder we also
   // don't want to create a route e.g. `package.json`
   if (API_BUILDERS.every(({ src }) => !minimatch(file, src))) {
@@ -99,39 +105,42 @@ async function detectApiBuilders(files: string[]): Promise<Builder[]> {
 // to determine what builders to use
 export async function detectBuilders(
   files: string[],
-  pkg?: PackageJson | undefined | null
+  pkg?: PackageJson | undefined | null,
+  options?: Options
 ): Promise<{
   builders: Builder[] | null;
-  warnings: Warning[] | null;
+  errors: ErrorResponse[] | null;
 }> {
-  const warnings: Warning[] = [];
+  const errors: ErrorResponse[] = [];
 
   // Detect all builders for the `api` directory before anything else
-  const builders = await detectApiBuilders(files);
+  let builders = await detectApiBuilders(files);
 
   if (pkg && hasBuildScript(pkg)) {
     builders.push(await detectBuilder(pkg));
-  } else if (builders.length > 0) {
-    // We only want to match this if there
-    // are already builds for `api`, since
-    // we'd add builds even though we shouldn't otherwise
-
-    if (pkg) {
-      warnings.push(MISSING_BUILD_SCRIPT_WARNING);
+  } else {
+    if (pkg && builders.length === 0) {
+      // We only show this error when there are no api builders
+      // since the dependencies of the pkg could be used for those
+      errors.push(MISSING_BUILD_SCRIPT_ERROR);
+      return { errors, builders: null };
     }
 
+    // We allow a `public` directory
+    // when there are no build steps
     if (hasPublicDirectory(files)) {
       builders.push({
         use: '@now/static',
         src: 'public/**/*',
         config,
       });
-    } else {
+    } else if (builders.length > 0) {
       // We can't use pattern matching, since `!(api)` and `!(api)/**/*`
       // won't give the correct results
       builders.push(
         ...files
           .filter(name => !name.startsWith('api/'))
+          .filter(name => !(name === 'package.json'))
           .map(name => ({
             use: '@now/static',
             src: name,
@@ -141,8 +150,24 @@ export async function detectBuilders(
     }
   }
 
+  // Change the tag for the builders
+  if (builders && builders.length) {
+    const tag = options && options.tag;
+
+    if (tag) {
+      builders = builders.map((builder: Builder) => {
+        // @now/static has no canary builder
+        if (builder.use !== '@now/static') {
+          builder.use = `${builder.use}@${tag}`;
+        }
+
+        return builder;
+      });
+    }
+  }
+
   return {
     builders: builders.length ? builders : null,
-    warnings: warnings.length ? warnings : null,
+    errors: errors.length ? errors : null,
   };
 }

packages/now-build-utils/src/detect-routes.ts

@@ -2,6 +2,16 @@ import { Route, Builder } from './types';
 import { parse as parsePath } from 'path';
 import { ignoreApiFilter, sortFiles } from './detect-builders';
 
+function escapeName(name: string) {
+  const special = '[]^$.|?*+()'.split('');
+
+  for (const char of special) {
+    name = name.replace(new RegExp(`\\${char}`, 'g'), `\\${char}`);
+  }
+
+  return name;
+}
+
 function joinPath(...segments: string[]) {
   const joinedPath = segments.join('/');
   return joinedPath.replace(/\/{2,}/g, '/');
@@ -46,15 +56,32 @@ function createRouteFromPath(filePath: string): Route {
         query.push(`${name}=$${counter++}`);
         return `([^\\/]+)`;
       } else if (isLast) {
-        const { name: fileName } = parsePath(segment);
-        return fileName;
+        const { name: fileName, ext } = parsePath(segment);
+        const isIndex = fileName === 'index';
+        const prefix = isIndex ? '\\/' : '';
+
+        const names = [
+          prefix,
+          prefix + escapeName(fileName),
+          prefix + escapeName(fileName) + escapeName(ext),
+        ].filter(Boolean);
+
+        // Either filename with extension, filename without extension
+        // or nothing when the filename is `index`
+        return `(${names.join('|')})${isIndex ? '?' : ''}`;
       }
 
       return segment;
     }
   );
 
-  const src = `^/${srcParts.join('/')}$`;
+  const { name: fileName } = parsePath(filePath);
+  const isIndex = fileName === 'index';
+
+  const src = isIndex
+    ? `^/${srcParts.slice(0, -1).join('/')}${srcParts.slice(-1)[0]}$`
+    : `^/${srcParts.join('/')}$`;
+
   const dest = `/${filePath}${query.length ? '?' : ''}${query.join('&')}`;
 
   return { src, dest };
@@ -232,6 +259,14 @@ async function detectApiRoutes(files: string[]): Promise<RoutesResult> {
     defaultRoutes.push(createRouteFromPath(file));
   }
 
+  // 404 Route to disable directory listing
+  if (defaultRoutes.length) {
+    defaultRoutes.push({
+      status: 404,
+      src: '/api(\\/.*)?$',
+    });
+  }
+
   return { defaultRoutes, error: null };
 }
 

packages/now-build-utils/src/fs/run-user-scripts.ts

@@ -4,7 +4,7 @@ import path from 'path';
 import spawn from 'cross-spawn';
 import { SpawnOptions } from 'child_process';
 import { deprecate } from 'util';
-import { Meta, PackageJson, NodeVersion } from '../types';
+import { Meta, PackageJson, NodeVersion, Config } from '../types';
 import { getSupportedNodeVersion } from './node-version';
 
 function spawnAsync(
@@ -75,13 +75,23 @@ export function getSpawnOptions(
 
 export async function getNodeVersion(
   destPath: string,
-  minNodeVersion?: string
+  minNodeVersion?: string,
+  config?: Config
 ): Promise<NodeVersion> {
   const { packageJson } = await scanParentDirs(destPath, true);
-  const range =
-    (packageJson && packageJson.engines && packageJson.engines.node) ||
-    minNodeVersion;
-  return getSupportedNodeVersion(range, typeof minNodeVersion !== 'undefined');
+  let range: string | undefined;
+  let silent = false;
+  if (packageJson && packageJson.engines && packageJson.engines.node) {
+    range = packageJson.engines.node;
+  } else if (minNodeVersion) {
+    range = minNodeVersion;
+    silent = true;
+  } else if (config && config.zeroConfig) {
+    // Use latest node version zero config detected
+    range = '10.x';
+    silent = true;
+  }
+  return getSupportedNodeVersion(range, silent);
 }
 
 async function scanParentDirs(destPath: string, readPackageJson = false) {

packages/now-build-utils/src/index.ts

@@ -18,6 +18,7 @@ import streamToBuffer from './fs/stream-to-buffer';
 import shouldServe from './should-serve';
 import { detectBuilders } from './detect-builders';
 import { detectRoutes } from './detect-routes';
+import debug from './debug';
 
 export {
   FileBlob,
@@ -40,6 +41,7 @@ export {
   shouldServe,
   detectBuilders,
   detectRoutes,
+  debug,
 };
 
 export * from './types';

packages/now-build-utils/src/types.ts

@@ -23,6 +23,8 @@ export interface Route {
   headers?: {
     [key: string]: string;
   };
+  continue?: boolean;
+  status?: number;
 }
 
 export interface Config {

packages/now-build-utils/test/fixtures/01-zero-config-api/.gitignore

@@ -0,0 +1 @@
+now.json

packages/now-build-utils/test/fixtures/01-zero-config-api/api/[endpoint].js

@@ -0,0 +1,3 @@
+module.exports = (req, res) => {
+  res.end(req.query.endpoint);
+};

packages/now-build-utils/test/fixtures/01-zero-config-api/api/[endpoint]/[id].js

@@ -0,0 +1,3 @@
+module.exports = (req, res) => {
+  res.end(`${req.query.endpoint}/${req.query.id}`);
+};

packages/now-build-utils/test/fixtures/01-zero-config-api/package.json

@@ -0,0 +1,5 @@
+{
+  "scripts": {
+    "build": "mkdir -p public && echo 'hello from index.txt' > public/index.txt"
+  }
+}

packages/now-build-utils/test/fixtures/02-zero-config-api/.gitignore

@@ -0,0 +1 @@
+now.json

packages/now-build-utils/test/fixtures/02-zero-config-api/api/date.js

@@ -0,0 +1,3 @@
+module.exports = (req, res) => {
+  res.end('hello from api/date.js');
+};

packages/now-build-utils/test/fixtures/02-zero-config-api/api/date/index.js

@@ -0,0 +1,3 @@
+module.exports = (req, res) => {
+  res.end('hello from api/date/index.js');
+};

packages/now-build-utils/test/fixtures/02-zero-config-api/api/index.js

@@ -0,0 +1,3 @@
+module.exports = (req, res) => {
+  res.end('hello from api/index.js');
+};

packages/now-build-utils/test/fixtures/02-zero-config-api/package.json

@@ -0,0 +1,5 @@
+{
+  "scripts": {
+    "build": "mkdir -p public && echo 'hello from index.txt' > public/index.txt"
+  }
+}

packages/now-build-utils/test/test.js

@@ -4,21 +4,21 @@ const fs = require('fs-extra');
 // eslint-disable-next-line import/no-extraneous-dependencies
 const execa = require('execa');
 const assert = require('assert');
-const { glob, download } = require('../');
 const { createZip } = require('../dist/lambda');
+const {
+  glob, download, detectBuilders, detectRoutes,
+} = require('../');
 const {
   getSupportedNodeVersion,
   defaultSelection,
 } = require('../dist/fs/node-version');
-
 const {
   packAndDeploy,
   testDeployment,
-} = require('../../../test/lib/deployment/test-deployment.js');
-
-const { detectBuilders, detectRoutes } = require('../dist');
+} = require('../../../test/lib/deployment/test-deployment');
 
 jest.setTimeout(4 * 60 * 1000);
+
 const builderUrl = '@canary';
 let buildUtilsUrl;
 
@@ -116,12 +116,47 @@ it('should match all semver ranges', () => {
   );
 });
 
+it('should support require by path for legacy builders', () => {
+  const index = require('@now/build-utils');
+
+  const download2 = require('@now/build-utils/fs/download.js');
+  const getWriteableDirectory2 = require('@now/build-utils/fs/get-writable-directory.js');
+  const glob2 = require('@now/build-utils/fs/glob.js');
+  const rename2 = require('@now/build-utils/fs/rename.js');
+  const {
+    runNpmInstall: runNpmInstall2,
+  } = require('@now/build-utils/fs/run-user-scripts.js');
+  const streamToBuffer2 = require('@now/build-utils/fs/stream-to-buffer.js');
+
+  const FileBlob2 = require('@now/build-utils/file-blob.js');
+  const FileFsRef2 = require('@now/build-utils/file-fs-ref.js');
+  const FileRef2 = require('@now/build-utils/file-ref.js');
+  const { Lambda: Lambda2 } = require('@now/build-utils/lambda.js');
+
+  expect(download2).toBe(index.download);
+  expect(getWriteableDirectory2).toBe(index.getWriteableDirectory);
+  expect(glob2).toBe(index.glob);
+  expect(rename2).toBe(index.rename);
+  expect(runNpmInstall2).toBe(index.runNpmInstall);
+  expect(streamToBuffer2).toBe(index.streamToBuffer);
+
+  expect(FileBlob2).toBe(index.FileBlob);
+  expect(FileFsRef2).toBe(index.FileFsRef);
+  expect(FileRef2).toBe(index.FileRef);
+  expect(Lambda2).toBe(index.Lambda);
+});
+
 // own fixtures
 
 const fixturesPath = path.resolve(__dirname, 'fixtures');
 
 // eslint-disable-next-line no-restricted-syntax
 for (const fixture of fs.readdirSync(fixturesPath)) {
+  if (fixture.includes('zero-config')) {
+    // Those have separate tests
+    continue; // eslint-disable-line no-continue
+  }
+
   // eslint-disable-next-line no-loop-func
   it(`should build ${fixture}`, async () => {
     await expect(
@@ -135,7 +170,7 @@ for (const fixture of fs.readdirSync(fixturesPath)) {
 
 // few foreign tests
 
-const buildersToTestWith = ['now-node', 'now-static-build'];
+const buildersToTestWith = ['now-next', 'now-node', 'now-static-build'];
 
 // eslint-disable-next-line no-restricted-syntax
 for (const builder of buildersToTestWith) {
@@ -147,7 +182,7 @@ for (const builder of buildersToTestWith) {
   // eslint-disable-next-line no-restricted-syntax
   for (const fixture of fs.readdirSync(fixturesPath2)) {
     // don't run all foreign fixtures, just some
-    if (['01-cowsay', '03-env-vars'].includes(fixture)) {
+    if (['01-cowsay', '01-cache-headers', '03-env-vars'].includes(fixture)) {
       // eslint-disable-next-line no-loop-func
       it(`should build ${builder}/${fixture}`, async () => {
         await expect(
@@ -165,10 +200,10 @@ it('Test `detectBuilders`', async () => {
   {
     // package.json + no build
     const pkg = { dependencies: { next: '9.0.0' } };
-    const files = ['package.json', 'pages/index.js'];
-    const { builders, warnings } = await detectBuilders(files, pkg);
+    const files = ['package.json', 'pages/index.js', 'public/index.html'];
+    const { builders, errors } = await detectBuilders(files, pkg);
     expect(builders).toBe(null);
-    expect(warnings).toBe(null);
+    expect(errors.length).toBe(1);
   }
 
   {
@@ -178,9 +213,9 @@ it('Test `detectBuilders`', async () => {
       dependencies: { next: '9.0.0' },
     };
     const files = ['package.json', 'pages/index.js'];
-    const { builders, warnings } = await detectBuilders(files, pkg);
+    const { builders, errors } = await detectBuilders(files, pkg);
     expect(builders[0].use).toBe('@now/next');
-    expect(warnings).toBe(null);
+    expect(errors).toBe(null);
   }
 
   {
@@ -190,60 +225,60 @@ it('Test `detectBuilders`', async () => {
       devDependencies: { next: '9.0.0' },
     };
     const files = ['package.json', 'pages/index.js'];
-    const { builders, warnings } = await detectBuilders(files, pkg);
+    const { builders, errors } = await detectBuilders(files, pkg);
     expect(builders[0].use).toBe('@now/next');
-    expect(warnings).toBe(null);
+    expect(errors).toBe(null);
   }
 
   {
     // package.json + no build
     const pkg = {};
     const files = ['package.json'];
-    const { builders, warnings } = await detectBuilders(files, pkg);
+    const { builders, errors } = await detectBuilders(files, pkg);
     expect(builders).toBe(null);
-    expect(warnings).toBe(null);
+    expect(errors.length).toBe(1);
   }
 
   {
-    // no package.json + public
-    const files = ['public/index.html'];
-    const { builders, warnings } = await detectBuilders(files);
+    // static file
+    const files = ['index.html'];
+    const { builders, errors } = await detectBuilders(files);
     expect(builders).toBe(null);
-    expect(warnings).toBe(null);
+    expect(errors).toBe(null);
   }
 
   {
     // no package.json + public
     const files = ['api/users.js', 'public/index.html'];
-    const { builders, warnings } = await detectBuilders(files);
+    const { builders, errors } = await detectBuilders(files);
     expect(builders[1].use).toBe('@now/static');
-    expect(warnings).toBe(null);
+    expect(errors).toBe(null);
   }
 
   {
     // no package.json + no build + raw static + api
     const files = ['api/users.js', 'index.html'];
-    const { builders, warnings } = await detectBuilders(files);
-    expect(builders[0].use).toBe('@now/node@canary');
+    const { builders, errors } = await detectBuilders(files);
+    expect(builders[0].use).toBe('@now/node');
     expect(builders[0].src).toBe('api/users.js');
     expect(builders[1].use).toBe('@now/static');
     expect(builders[1].src).toBe('index.html');
     expect(builders.length).toBe(2);
-    expect(warnings).toBe(null);
+    expect(errors).toBe(null);
   }
 
   {
     // package.json + no build + root + api
     const files = ['index.html', 'api/[endpoint].js', 'static/image.png'];
-    const { builders, warnings } = await detectBuilders(files);
-    expect(builders[0].use).toBe('@now/node@canary');
+    const { builders, errors } = await detectBuilders(files);
+    expect(builders[0].use).toBe('@now/node');
     expect(builders[0].src).toBe('api/[endpoint].js');
     expect(builders[1].use).toBe('@now/static');
     expect(builders[1].src).toBe('index.html');
     expect(builders[2].use).toBe('@now/static');
     expect(builders[2].src).toBe('static/image.png');
     expect(builders.length).toBe(3);
-    expect(warnings).toBe(null);
+    expect(errors).toBe(null);
   }
 
   {
@@ -255,7 +290,7 @@ it('Test `detectBuilders`', async () => {
     ];
 
     const { builders } = await detectBuilders(files);
-    expect(builders[0].use).toBe('@now/node@canary');
+    expect(builders[0].use).toBe('@now/node');
     expect(builders[0].src).toBe('api/[endpoint]/[id].js');
     expect(builders.length).toBe(1);
   }
@@ -269,7 +304,7 @@ it('Test `detectBuilders`', async () => {
     const files = ['package.json', 'api/endpoint.js', 'public/index.html'];
 
     const { builders } = await detectBuilders(files, pkg);
-    expect(builders[0].use).toBe('@now/node@canary');
+    expect(builders[0].use).toBe('@now/node');
     expect(builders[0].src).toBe('api/endpoint.js');
     expect(builders[1].use).toBe('@now/next');
     expect(builders[1].src).toBe('package.json');
@@ -285,7 +320,7 @@ it('Test `detectBuilders`', async () => {
     const files = ['package.json', 'api/endpoint.js', 'index.html'];
 
     const { builders } = await detectBuilders(files, pkg);
-    expect(builders[0].use).toBe('@now/node@canary');
+    expect(builders[0].use).toBe('@now/node');
     expect(builders[0].src).toBe('api/endpoint.js');
     expect(builders[1].use).toBe('@now/next');
     expect(builders[1].src).toBe('package.json');
@@ -297,7 +332,7 @@ it('Test `detectBuilders`', async () => {
     const files = ['api/endpoint.js', 'index.html', 'favicon.ico'];
 
     const { builders } = await detectBuilders(files);
-    expect(builders[0].use).toBe('@now/node@canary');
+    expect(builders[0].use).toBe('@now/node');
     expect(builders[0].src).toBe('api/endpoint.js');
     expect(builders[1].use).toBe('@now/static');
     expect(builders[1].src).toBe('favicon.ico');
@@ -316,13 +351,22 @@ it('Test `detectBuilders`', async () => {
     ];
 
     const { builders } = await detectBuilders(files);
-    expect(builders[0].use).toBe('@now/node@canary');
+    expect(builders[0].use).toBe('@now/node');
     expect(builders[0].src).toBe('api/endpoint.js');
     expect(builders[1].use).toBe('@now/static');
     expect(builders[1].src).toBe('public/**/*');
     expect(builders.length).toBe(2);
   }
 
+  {
+    // just public
+    const files = ['public/index.html', 'public/favicon.ico', 'README.md'];
+
+    const { builders } = await detectBuilders(files);
+    expect(builders[0].src).toBe('public/**/*');
+    expect(builders.length).toBe(1);
+  }
+
   {
     // next + public
     const pkg = {
@@ -336,6 +380,77 @@ it('Test `detectBuilders`', async () => {
     expect(builders[0].src).toBe('package.json');
     expect(builders.length).toBe(1);
   }
+
+  {
+    // nuxt
+    const pkg = {
+      scripts: { build: 'nuxt build' },
+      dependencies: { nuxt: '2.8.1' },
+    };
+    const files = ['package.json', 'pages/index.js'];
+
+    const { builders } = await detectBuilders(files, pkg);
+    expect(builders[0].use).toBe('@now/static-build');
+    expect(builders[0].src).toBe('package.json');
+    expect(builders.length).toBe(1);
+  }
+
+  {
+    // package.json with no build + api
+    const pkg = { dependencies: { next: '9.0.0' } };
+    const files = ['package.json', 'api/[endpoint].js'];
+
+    const { builders } = await detectBuilders(files, pkg);
+    expect(builders[0].use).toBe('@now/node');
+    expect(builders[0].src).toBe('api/[endpoint].js');
+    expect(builders.length).toBe(1);
+  }
+
+  {
+    // package.json with no build + public directory
+    const pkg = { dependencies: { next: '9.0.0' } };
+    const files = ['package.json', 'public/index.html'];
+
+    const { builders, errors } = await detectBuilders(files, pkg);
+    expect(builders).toBe(null);
+    expect(errors.length).toBe(1);
+  }
+
+  {
+    // no package.json + api
+    const files = ['api/[endpoint].js', 'api/[endpoint]/[id].js'];
+
+    const { builders } = await detectBuilders(files);
+    expect(builders.length).toBe(2);
+  }
+
+  {
+    // no package.json + no api
+    const files = ['index.html'];
+
+    const { builders, errors } = await detectBuilders(files);
+    expect(builders).toBe(null);
+    expect(errors).toBe(null);
+  }
+
+  {
+    // package.json + api + canary
+    const pkg = {
+      scripts: { build: 'next build' },
+      dependencies: { next: '9.0.0' },
+    };
+    const files = [
+      'pages/index.js',
+      'api/[endpoint].js',
+      'api/[endpoint]/[id].js',
+    ];
+
+    const { builders } = await detectBuilders(files, pkg, { tag: 'canary' });
+    expect(builders[0].use).toBe('@now/node@canary');
+    expect(builders[1].use).toBe('@now/node@canary');
+    expect(builders[2].use).toBe('@now/next@canary');
+    expect(builders.length).toBe(3);
+  }
 });
 
 it('Test `detectRoutes`', async () => {
@@ -344,9 +459,11 @@ it('Test `detectRoutes`', async () => {
 
     const { builders } = await detectBuilders(files);
     const { defaultRoutes } = await detectRoutes(files, builders);
-    expect(defaultRoutes.length).toBe(2);
+    expect(defaultRoutes.length).toBe(3);
     expect(defaultRoutes[0].dest).toBe('/api/team.js');
     expect(defaultRoutes[1].dest).toBe('/api/user.go');
+    expect(defaultRoutes[2].dest).not.toBeDefined();
+    expect(defaultRoutes[2].status).toBe(404);
   }
 
   {
@@ -373,12 +490,21 @@ it('Test `detectRoutes`', async () => {
     expect(error.code).toBe('conflicting_path_segment');
   }
 
+  {
+    const files = ['api/date/index.js', 'api/date/index.go'];
+
+    const { builders } = await detectBuilders(files);
+    const { defaultRoutes, error } = await detectRoutes(files, builders);
+    expect(defaultRoutes).toBe(null);
+    expect(error.code).toBe('conflicting_file_path');
+  }
+
   {
     const files = ['api/[endpoint].js', 'api/[endpoint]/[id].js'];
 
     const { builders } = await detectBuilders(files);
     const { defaultRoutes } = await detectRoutes(files, builders);
-    expect(defaultRoutes.length).toBe(2);
+    expect(defaultRoutes.length).toBe(3);
   }
 
   {
@@ -390,9 +516,11 @@ it('Test `detectRoutes`', async () => {
 
     const { builders } = await detectBuilders(files);
     const { defaultRoutes } = await detectRoutes(files, builders);
-    expect(defaultRoutes[2].src).toBe('/(.*)');
-    expect(defaultRoutes[2].dest).toBe('/public/$1');
-    expect(defaultRoutes.length).toBe(3);
+    expect(defaultRoutes[2].status).toBe(404);
+    expect(defaultRoutes[2].src).toBe('/api(\\/.*)?$');
+    expect(defaultRoutes[3].src).toBe('/(.*)');
+    expect(defaultRoutes[3].dest).toBe('/public/$1');
+    expect(defaultRoutes.length).toBe(4);
   }
 
   {
@@ -404,6 +532,210 @@ it('Test `detectRoutes`', async () => {
 
     const { builders } = await detectBuilders(files, pkg);
     const { defaultRoutes } = await detectRoutes(files, builders);
+    expect(defaultRoutes[1].status).toBe(404);
+    expect(defaultRoutes[1].src).toBe('/api(\\/.*)?$');
+    expect(defaultRoutes.length).toBe(2);
+  }
+
+  {
+    const files = ['public/index.html'];
+
+    const { builders } = await detectBuilders(files);
+    const { defaultRoutes } = await detectRoutes(files, builders);
+
     expect(defaultRoutes.length).toBe(1);
   }
+
+  {
+    const files = ['api/date/index.js', 'api/date.js'];
+
+    const { builders } = await detectBuilders(files);
+    const { defaultRoutes } = await detectRoutes(files, builders);
+
+    expect(defaultRoutes.length).toBe(3);
+    expect(defaultRoutes[0].src).toBe(
+      '^/api/date(\\/|\\/index|\\/index\\.js)?$',
+    );
+    expect(defaultRoutes[0].dest).toBe('/api/date/index.js');
+    expect(defaultRoutes[1].src).toBe('^/api/(date|date\\.js)$');
+    expect(defaultRoutes[1].dest).toBe('/api/date.js');
+  }
+
+  {
+    const files = ['api/date.js', 'api/[date]/index.js'];
+
+    const { builders } = await detectBuilders(files);
+    const { defaultRoutes } = await detectRoutes(files, builders);
+
+    expect(defaultRoutes.length).toBe(3);
+    expect(defaultRoutes[0].src).toBe(
+      '^/api/([^\\/]+)(\\/|\\/index|\\/index\\.js)?$',
+    );
+    expect(defaultRoutes[0].dest).toBe('/api/[date]/index.js?date=$1');
+    expect(defaultRoutes[1].src).toBe('^/api/(date|date\\.js)$');
+    expect(defaultRoutes[1].dest).toBe('/api/date.js');
+  }
+
+  {
+    const files = [
+      'api/index.ts',
+      'api/index.d.ts',
+      'api/users/index.ts',
+      'api/users/index.d.ts',
+      'api/food.ts',
+      'api/ts/gold.ts',
+    ];
+    const { builders } = await detectBuilders(files);
+    const { defaultRoutes } = await detectRoutes(files, builders);
+
+    expect(builders.length).toBe(4);
+    expect(builders[0].use).toBe('@now/node');
+    expect(builders[1].use).toBe('@now/node');
+    expect(builders[2].use).toBe('@now/node');
+    expect(builders[3].use).toBe('@now/node');
+    expect(defaultRoutes.length).toBe(5);
+  }
+});
+
+it('Test `detectBuilders` and `detectRoutes`', async () => {
+  const fixture = path.join(__dirname, 'fixtures', '01-zero-config-api');
+  const pkg = await fs.readJSON(path.join(fixture, 'package.json'));
+  const fileList = await glob('**', fixture);
+  const files = Object.keys(fileList);
+
+  const probes = [
+    {
+      path: '/api/my-endpoint',
+      mustContain: 'my-endpoint',
+      status: 200,
+    },
+    {
+      path: '/api/other-endpoint',
+      mustContain: 'other-endpoint',
+      status: 200,
+    },
+    {
+      path: '/api/team/zeit',
+      mustContain: 'team/zeit',
+      status: 200,
+    },
+    {
+      path: '/api/user/myself',
+      mustContain: 'user/myself',
+      status: 200,
+    },
+    {
+      path: '/api/not-okay/',
+      status: 404,
+    },
+    {
+      path: '/api',
+      status: 404,
+    },
+    {
+      path: '/api/',
+      status: 404,
+    },
+    {
+      path: '/',
+      mustContain: 'hello from index.txt',
+    },
+  ];
+
+  const { builders } = await detectBuilders(files, pkg);
+  const { defaultRoutes } = await detectRoutes(files, builders);
+
+  const nowConfig = { builds: builders, routes: defaultRoutes, probes };
+  await fs.writeFile(
+    path.join(fixture, 'now.json'),
+    JSON.stringify(nowConfig, null, 2),
+  );
+
+  const deployment = await testDeployment(
+    { builderUrl, buildUtilsUrl },
+    fixture,
+  );
+  expect(deployment).toBeDefined();
+});
+
+it('Test `detectBuilders` and `detectRoutes` with `index` files', async () => {
+  const fixture = path.join(__dirname, 'fixtures', '02-zero-config-api');
+  const pkg = await fs.readJSON(path.join(fixture, 'package.json'));
+  const fileList = await glob('**', fixture);
+  const files = Object.keys(fileList);
+
+  const probes = [
+    {
+      path: '/api/not-okay',
+      status: 404,
+    },
+    {
+      path: '/api',
+      mustContain: 'hello from api/index.js',
+      status: 200,
+    },
+    {
+      path: '/api/',
+      mustContain: 'hello from api/index.js',
+      status: 200,
+    },
+    {
+      path: '/api/index',
+      mustContain: 'hello from api/index.js',
+      status: 200,
+    },
+    {
+      path: '/api/index.js',
+      mustContain: 'hello from api/index.js',
+      status: 200,
+    },
+    {
+      path: '/api/date.js',
+      mustContain: 'hello from api/date.js',
+      status: 200,
+    },
+    {
+      // Someone might expect this to be `date.js`,
+      // but I doubt that there is any case were both
+      // `date/index.js` and `date.js` exists,
+      // so it is not special cased
+      path: '/api/date',
+      mustContain: 'hello from api/date/index.js',
+      status: 200,
+    },
+    {
+      path: '/api/date/',
+      mustContain: 'hello from api/date/index.js',
+      status: 200,
+    },
+    {
+      path: '/api/date/index',
+      mustContain: 'hello from api/date/index.js',
+      status: 200,
+    },
+    {
+      path: '/api/date/index.js',
+      mustContain: 'hello from api/date/index.js',
+      status: 200,
+    },
+    {
+      path: '/',
+      mustContain: 'hello from index.txt',
+    },
+  ];
+
+  const { builders } = await detectBuilders(files, pkg);
+  const { defaultRoutes } = await detectRoutes(files, builders);
+
+  const nowConfig = { builds: builders, routes: defaultRoutes, probes };
+  await fs.writeFile(
+    path.join(fixture, 'now.json'),
+    JSON.stringify(nowConfig, null, 2),
+  );
+
+  const deployment = await testDeployment(
+    { builderUrl, buildUtilsUrl },
+    fixture,
+  );
+  expect(deployment).toBeDefined();
 });

packages/now-go/.gitignore

@@ -1,6 +1,6 @@
 node_modules
+dist
 *.log
 /go
 /analyze
 *.js
-!util/install.js

packages/now-go/.npmignore

@@ -1,5 +0,0 @@
-*.ts
-test
-tsconfig.json
-package-lock.json
-yarn.lock

packages/now-go/build.sh

@@ -0,0 +1,4 @@
+ncc build index.ts -o dist
+ncc build install.ts -o dist/install
+mv dist/install/index.js dist/install.js
+rm -rf dist/install

packages/now-go/index.ts

@@ -106,7 +106,7 @@ Learn more: https://github.com/golang/go/wiki/Modules
   if (!analyzed) {
     const err = new Error(
       `Could not find an exported function in "${entrypoint}"
-Learn more: https://zeit.co/docs/v2/deployments/official-builders/go-now-go/#entrypoint
+Learn more: https://zeit.co/docs/v2/advanced/builders/#go
       `
     );
     console.log(err.message);

packages/now-go/install.ts

@@ -0,0 +1,6 @@
+import { downloadGo } from './go-helpers';
+
+downloadGo().catch(err => {
+  console.error(err);
+  process.exit(1);
+});

packages/now-go/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@now/go",
-  "version": "0.5.6",
+  "version": "0.5.10",
   "license": "MIT",
+  "main": "./dist/index",
   "homepage": "https://zeit.co/docs/v2/deployments/official-builders/go-now-go",
   "repository": {
     "type": "git",
@@ -9,29 +10,25 @@
     "directory": "packages/now-go"
   },
   "scripts": {
-    "build": "tsc",
-    "test": "tsc && jest",
-    "prepublish": "tsc"
+    "build": "./build.sh",
+    "test": "./build.sh && jest",
+    "prepublish": "./build.sh",
+    "now-postinstall": "node dist/install.js"
   },
   "files": [
-    "*.js",
-    "main.go",
-    "main__mod__.go",
-    "util"
+    "dist"
   ],
-  "dependencies": {
-    "debug": "^4.1.1",
-    "execa": "^1.0.0",
-    "fs-extra": "^7.0.0",
-    "node-fetch": "^2.2.1",
-    "tar": "4.4.6"
-  },
   "devDependencies": {
     "@types/debug": "^4.1.3",
     "@types/execa": "^0.9.0",
     "@types/fs-extra": "^5.0.5",
     "@types/node-fetch": "^2.3.0",
     "@types/tar": "^4.0.0",
+    "debug": "^4.1.1",
+    "execa": "^1.0.0",
+    "fs-extra": "^7.0.0",
+    "node-fetch": "^2.2.1",
+    "tar": "4.4.6",
     "typescript": "3.5.2"
   }
 }

packages/now-go/test/fixtures/02-parallel/api/go-one/one.go

@@ -0,0 +1,9 @@
+package handler
+import (
+	"fmt"
+	"net/http"
+)
+// Handler is cool
+func Handler(w http.ResponseWriter, r *http.Request) {
+	fmt.Fprintf(w, "ONE:RANDOMNESS_PLACEHOLDER")
+}

packages/now-go/test/fixtures/02-parallel/api/go-two/two.go

@@ -0,0 +1,9 @@
+package handler
+import (
+	"fmt"
+	"net/http"
+)
+// Handler is cool
+func Handler(w http.ResponseWriter, r *http.Request) {
+	fmt.Fprintf(w, "TWO:RANDOMNESS_PLACEHOLDER")
+}

packages/now-go/test/fixtures/02-parallel/api/go.mod

@@ -0,0 +1,3 @@
+module go-example
+
+go 1.12

packages/now-go/test/fixtures/02-parallel/now.json

@@ -0,0 +1,25 @@
+{
+  "version": 2,
+  "builds": [
+    {
+      "src": "/api/go-one/one.go",
+      "use": "@now/go",
+      "config": { "parallel": true }
+    },
+    {
+      "src": "/api/go-two/two.go",
+      "use": "@now/go",
+      "config": { "parallel": true }
+    }
+  ],
+  "probes": [
+    {
+      "path": "/api/go-one/one.go",
+      "mustContain": "ONE:RANDOMNESS_PLACEHOLDER"
+    },
+    {
+      "path": "/api/go-two/two.go",
+      "mustContain": "TWO:RANDOMNESS_PLACEHOLDER"
+    }
+  ]
+}

packages/now-next/.gitignore

@@ -1,2 +1,2 @@
 /dist
-/src/now__bridge.d.ts
+/src/now__bridge.ts

packages/now-next/build.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+set -euo pipefail
+
+bridge_defs="$(dirname $(pwd))/now-node-bridge/src/bridge.ts"
+
+cp -v "$bridge_defs" src/now__bridge.ts
+
+tsc
+
+ncc build src/dev-server.ts -o dist/dev
+mv dist/dev/index.js dist/dev-server.js
+rm -rf dist/dev
+
+ncc build src/index.ts -o dist/main
+mv dist/main/index.js dist/index.js
+rm -rf dist/main

packages/now-next/getBridgeTypes.sh

@@ -1,11 +0,0 @@
-#!/bin/bash
-set -euo pipefail
-
-bridge_entrypoint="$(node -p 'require.resolve("@now/node-bridge")')"
-bridge_defs="$(dirname "$bridge_entrypoint")/bridge.d.ts"
-
-if [ ! -e "$bridge_defs" ]; then
-  yarn install --cwd "$bridge_entrypoint"
-fi
-
-cp -v "$bridge_defs" src/now__bridge.d.ts

packages/now-next/package.json

@@ -1,33 +1,31 @@
 {
   "name": "@now/next",
-  "version": "0.5.5",
+  "version": "0.6.0",
   "license": "MIT",
   "main": "./dist/index",
   "homepage": "https://zeit.co/docs/v2/deployments/official-builders/next-js-now-next",
   "scripts": {
-    "build": "./getBridgeTypes.sh && tsc",
-    "test": "npm run build && jest",
-    "prepublish": "yarn run build"
+    "build": "./build.sh",
+    "test": "./build.sh && jest",
+    "prepublishOnly": "./build.sh"
   },
   "repository": {
     "type": "git",
     "url": "https://github.com/zeit/now-builders.git",
     "directory": "packages/now-next"
   },
-  "dependencies": {
-    "@now/node-bridge": "1.2.3",
-    "fs-extra": "^7.0.0",
-    "get-port": "^5.0.0",
-    "resolve-from": "^5.0.0",
-    "semver": "^5.6.0"
-  },
   "files": [
     "dist"
   ],
   "devDependencies": {
-    "@types/next-server": "^8.0.0",
-    "@types/resolve-from": "^5.0.1",
-    "@types/semver": "^6.0.0",
+    "@types/next-server": "8.0.0",
+    "@types/resolve-from": "5.0.1",
+    "@types/semver": "6.0.0",
+    "@zeit/node-file-trace": "0.2.9",
+    "fs-extra": "7.0.0",
+    "get-port": "5.0.0",
+    "resolve-from": "5.0.0",
+    "semver": "6.1.1",
     "typescript": "3.5.2"
   }
 }

packages/now-next/src/create-serverless-config.ts

@@ -1,13 +1,16 @@
-import path from 'path';
 import fs from 'fs-extra';
+import path from 'path';
+import semver from 'semver';
 
-function getCustomData(importName: string) {
+import { ExperimentalTraceVersion } from './utils';
+
+function getCustomData(importName: string, target: string) {
   return `
 module.exports = function(...args) {
   let original = require('./${importName}');
 
   const finalConfig = {};
-  const target = { target: 'serverless' };
+  const target = { target: '${target}' };
 
   if (typeof original === 'function' && original.constructor.name === 'AsyncFunction') {
     // AsyncFunctions will become promises
@@ -37,14 +40,29 @@ function getDefaultData() {
   return `module.exports = { target: 'serverless' };`;
 }
 
-export default async function createServerlessConfig(workPath: string) {
+export default async function createServerlessConfig(
+  workPath: string,
+  nextVersion: string | undefined
+) {
+  let target = 'serverless';
+  if (nextVersion) {
+    try {
+      if (
+        nextVersion.includes('canary') &&
+        semver.satisfies(nextVersion, `>=${ExperimentalTraceVersion}`)
+      ) {
+        target = 'experimental-serverless-trace';
+      }
+    } catch (_ignored) {}
+  }
+
   const configPath = path.join(workPath, 'next.config.js');
   const backupConfigName = `next.config.original.${Date.now()}.js`;
   const backupConfigPath = path.join(workPath, backupConfigName);
 
   if (fs.existsSync(configPath)) {
     await fs.rename(configPath, backupConfigPath);
-    await fs.writeFile(configPath, getCustomData(backupConfigName));
+    await fs.writeFile(configPath, getCustomData(backupConfigName, target));
   } else {
     await fs.writeFile(configPath, getDefaultData());
   }

packages/now-next/src/index.ts

@@ -1,4 +1,4 @@
-import { ChildProcess, fork, SpawnOptions } from 'child_process';
+import { ChildProcess, fork } from 'child_process';
 import {
   pathExists,
   readFile,
@@ -7,42 +7,47 @@ import {
 } from 'fs-extra';
 import os from 'os';
 import path from 'path';
+import resolveFrom from 'resolve-from';
 import semver from 'semver';
 
 import {
   BuildOptions,
+  Config,
   createLambda,
   download,
   FileBlob,
   FileFsRef,
   Files,
+  getNodeVersion,
+  getSpawnOptions,
   glob,
   Lambda,
   PrepareCacheOptions,
+  Route,
   runNpmInstall,
   runPackageJsonScript,
-  getNodeVersion,
-  getSpawnOptions,
 } from '@now/build-utils';
+import nodeFileTrace from '@zeit/node-file-trace';
 
+import createServerlessConfig from './create-serverless-config';
 import nextLegacyVersions from './legacy-versions';
 import {
   EnvConfig,
   excludeFiles,
+  ExperimentalTraceVersion,
+  filesFromDirectory,
+  getDynamicRoutes,
   getNextConfig,
   getPathsInside,
   getRoutes,
   includeOnlyEntryDirectory,
+  isDynamicRoute,
   normalizePackageJson,
-  filesFromDirectory,
+  normalizePage,
   stringMap,
   syncEnvVars,
   validateEntrypoint,
-  normalizePage,
-  getDynamicRoutes,
-  isDynamicRoute,
 } from './utils';
-import createServerlessConfig from './create-serverless-config';
 
 interface BuildParamsMeta {
   isDev: boolean | undefined;
@@ -155,9 +160,10 @@ export const build = async ({
   files,
   workPath,
   entrypoint,
+  config = {} as Config,
   meta = {} as BuildParamsMeta,
 }: BuildParamsType): Promise<{
-  routes?: ({ src?: string; dest?: string } | { handle: string })[];
+  routes: Route[];
   output: Files;
   watch?: string[];
   childProcesses: ChildProcess[];
@@ -174,11 +180,7 @@ export const build = async ({
   const pkg = await readPackageJson(entryPath);
   const nextVersion = getNextVersion(pkg);
 
-  if (!meta.isDev) {
-    await createServerlessConfig(workPath);
-  }
-
-  const nodeVersion = await getNodeVersion(entryPath);
+  const nodeVersion = await getNodeVersion(entryPath, undefined, config);
   const spawnOpts = getSpawnOptions(meta, nodeVersion);
 
   if (!nextVersion) {
@@ -282,6 +284,20 @@ export const build = async ({
   console.log('installing dependencies...');
   await runNpmInstall(entryPath, ['--prefer-offline'], spawnOpts);
 
+  let realNextVersion: string | undefined;
+  try {
+    realNextVersion = require(resolveFrom(entryPath, 'next/package.json'))
+      .version;
+
+    console.log(`detected Next.js version: ${realNextVersion}`);
+  } catch (_ignored) {
+    console.warn(`could not identify real Next.js version, that's OK!`);
+  }
+
+  if (!isLegacy) {
+    await createServerlessConfig(workPath, realNextVersion);
+  }
+
   console.log('running user script...');
   const memoryToConsume = Math.floor(os.totalmem() / 1024 ** 2) - 128;
   const env = { ...spawnOpts.env } as any;
@@ -301,7 +317,7 @@ export const build = async ({
     await unlinkFile(path.join(entryPath, '.npmrc'));
   }
 
-  const exportedPageRoutes: { src: string; dest: string }[] = [];
+  const exportedPageRoutes: Route[] = [];
   const lambdas: { [key: string]: Lambda } = {};
   const staticPages: { [key: string]: FileFsRef } = {};
   const dynamicPages: string[] = [];
@@ -330,7 +346,7 @@ export const build = async ({
     );
     const launcherFiles = {
       'now__bridge.js': new FileFsRef({
-        fsPath: require('@now/node-bridge'),
+        fsPath: path.join(__dirname, 'now__bridge.js'),
       }),
     };
     const nextFiles: { [key: string]: FileFsRef } = {
@@ -392,14 +408,6 @@ export const build = async ({
     );
   } else {
     console.log('preparing lambda files...');
-    const launcherFiles = {
-      'now__bridge.js': new FileFsRef({
-        fsPath: require('@now/node-bridge'),
-      }),
-      'now__launcher.js': new FileFsRef({
-        fsPath: path.join(__dirname, 'launcher.js'),
-      }),
-    };
     const pagesDir = path.join(entryPath, '.next', 'serverless', 'pages');
 
     const pages = await glob('**/*.js', pagesDir);
@@ -438,18 +446,77 @@ export const build = async ({
       );
     }
 
-    // An optional assets folder that is placed alongside every page entrypoint
-    const assets = await glob(
-      'assets/**',
-      path.join(entryPath, '.next', 'serverless')
-    );
-
-    const assetKeys = Object.keys(assets);
-    if (assetKeys.length > 0) {
-      console.log('detected assets to be bundled with lambda:');
-      assetKeys.forEach(assetFile => console.log(`\t${assetFile}`));
+    // Assume tracing to be safe, bail if we know we don't need it.
+    let requiresTracing = true;
+    try {
+      if (
+        realNextVersion &&
+        semver.satisfies(realNextVersion, `<${ExperimentalTraceVersion}`)
+      ) {
+        if (config.debug) {
+          console.log(
+            'Next.js version is too old for us to trace the required dependencies.\n' +
+              'Assuming Next.js has handled it!'
+          );
+        }
+        requiresTracing = false;
+      }
+    } catch (err) {
+      if (config.debug) {
+        console.log(
+          'Failed to check Next.js version for tracing compatibility: ' + err
+        );
+      }
     }
 
+    let assets:
+      | {
+          [filePath: string]: FileFsRef;
+        }
+      | undefined;
+    const tracedFiles: {
+      [filePath: string]: FileFsRef;
+    } = {};
+    if (requiresTracing) {
+      const tracingLabel = 'Tracing Next.js lambdas for external files ...';
+      console.time(tracingLabel);
+
+      const { fileList } = await nodeFileTrace(
+        Object.keys(pages).map(page => pages[page].fsPath),
+        { base: workPath }
+      );
+      if (config.debug) {
+        console.log(`node-file-trace result for pages: ${fileList}`);
+      }
+      fileList.forEach(file => {
+        tracedFiles[file] = new FileFsRef({
+          fsPath: path.join(workPath, file),
+        });
+      });
+
+      console.timeEnd(tracingLabel);
+    } else {
+      // An optional assets folder that is placed alongside every page
+      // entrypoint.
+      // This is a legacy feature that was needed before we began tracing
+      // lambdas.
+      assets = await glob(
+        'assets/**',
+        path.join(entryPath, '.next', 'serverless')
+      );
+
+      const assetKeys = Object.keys(assets!);
+      if (assetKeys.length > 0) {
+        console.log('detected (legacy) assets to be bundled with lambda:');
+        assetKeys.forEach(assetFile => console.log(`\t${assetFile}`));
+        console.log(
+          '\nPlease upgrade to Next.js 9.1 to leverage modern asset handling.'
+        );
+      }
+    }
+
+    const launcherPath = path.join(__dirname, 'templated-launcher.js');
+    const launcherData = await readFile(launcherPath, 'utf8');
     await Promise.all(
       pageKeys.map(async page => {
         // These default pages don't have to be handled as they'd always 404
@@ -463,17 +530,34 @@ export const build = async ({
           dynamicPages.push(normalizePage(pathname));
         }
 
-        console.log(`Creating lambda for page: "${page}"...`);
+        const label = `Creating lambda for page: "${page}"...`;
+        console.time(label);
+
+        const pageFileName = path.relative(workPath, pages[page].fsPath);
+        const launcher = launcherData.replace(
+          /__LAUNCHER_PAGE_PATH__/g,
+          JSON.stringify(
+            requiresTracing ? path.join('./', pageFileName) : './page'
+          )
+        );
+        const launcherFiles = {
+          'now__bridge.js': new FileFsRef({
+            fsPath: path.join(__dirname, 'now__bridge.js'),
+          }),
+          'now__launcher.js': new FileBlob({ data: launcher }),
+        };
+
         lambdas[path.join(entryDirectory, pathname)] = await createLambda({
           files: {
             ...launcherFiles,
             ...assets,
-            'page.js': pages[page],
+            ...tracedFiles,
+            [requiresTracing ? pageFileName : 'page.js']: pages[page],
           },
           handler: 'now__launcher.launcher',
           runtime: nodeVersion.runtime,
         });
-        console.log(`Created lambda for page: "${page}"`);
+        console.timeEnd(label);
       })
     );
   }
@@ -536,6 +620,16 @@ export const build = async ({
     routes: [
       // Static exported pages (.html rewrites)
       ...exportedPageRoutes,
+      // Before we handle static files we need to set proper caching headers
+      {
+        // This ensures we only match known emitted-by-Next.js files and not
+        // user-emitted files which may be missing a hash in their filename.
+        src: '/_next/static/(?:[^/]+/pages|chunks|runtime)/.+',
+        // Next.js assets contain a hash or entropy in their filenames, so they
+        // are guaranteed to be unique and cacheable indefinitely.
+        headers: { 'cache-control': 'public,max-age=31536000,immutable' },
+        continue: true,
+      },
       // Next.js page lambdas, `static/` folder, reserved assets, and `public/`
       // folder
       { handle: 'filesystem' },
@@ -547,6 +641,7 @@ export const build = async ({
             {
               src: path.join('/', entryDirectory, '.*'),
               dest: path.join('/', entryDirectory, '_error'),
+              status: 404,
             },
           ]),
     ],

packages/now-next/src/templated-launcher.ts

@@ -3,9 +3,10 @@ if (!process.env.NODE_ENV) {
     process.env.NOW_REGION === 'dev1' ? 'development' : 'production';
 }
 
-const { Server } = require('http');
-const { Bridge } = require('./now__bridge');
-const page = require('./page');
+import { Server } from 'http';
+import { Bridge } from './now__bridge';
+// @ts-ignore
+const page = require(__LAUNCHER_PAGE_PATH__);
 
 // page.render is for React rendering
 // page.default is for /api rendering

packages/now-next/src/utils.ts

@@ -228,7 +228,7 @@ function getRoutes(
 
     const relativeToPages = path.relative('pages', relativePath);
     const extension = path.extname(relativeToPages);
-    const pageName = relativeToPages.replace(extension, '');
+    const pageName = relativeToPages.replace(extension, '').replace(/\\/g, '/');
 
     if (pageName.startsWith('_')) {
       continue;
@@ -356,6 +356,8 @@ function syncEnvVars(base: EnvConfig, removeEnv: EnvConfig, addEnv: EnvConfig) {
   Object.assign(base, addEnv);
 }
 
+export const ExperimentalTraceVersion = `9.0.4-canary.1`;
+
 export {
   excludeFiles,
   validateEntrypoint,

packages/now-next/test/fixtures/01-cache-headers/next.config.js

@@ -0,0 +1,5 @@
+module.exports = {
+  generateBuildId() {
+    return 'testing-build-id';
+  },
+};

packages/now-next/test/fixtures/01-cache-headers/now.json

@@ -0,0 +1,12 @@
+{
+  "version": 2,
+  "builds": [{ "src": "package.json", "use": "@now/next" }],
+  "probes": [
+    {
+      "path": "/_next/static/testing-build-id/pages/index.js",
+      "responseHeaders": {
+        "cache-control": "public,max-age=31536000,immutable"
+      }
+    }
+  ]
+}

packages/now-next/test/fixtures/01-cache-headers/package.json

@@ -0,0 +1,7 @@
+{
+  "dependencies": {
+    "next": "latest",
+    "react": "^16.8.6",
+    "react-dom": "^16.8.6"
+  }
+}

packages/now-next/test/fixtures/01-cache-headers/pages/index.js

@@ -0,0 +1 @@
+export default () => 'Hi';

packages/now-next/test/fixtures/02-firebase/next.config.js

@@ -0,0 +1,5 @@
+module.exports = {
+  generateBuildId() {
+    return 'testing-build-id';
+  },
+};

packages/now-next/test/fixtures/02-firebase/now.json

@@ -0,0 +1,8 @@
+{
+  "version": 2,
+  "builds": [{ "src": "package.json", "use": "@now/next" }],
+  "probes": [
+    { "path": "/nested/fb", "mustContain": "Hello Firebase: <!-- -->0" },
+    { "path": "/nested/moar/fb", "mustContain": "Hello Firebase: <!-- -->0" }
+  ]
+}

packages/now-next/test/fixtures/02-firebase/package.json

@@ -0,0 +1,8 @@
+{
+  "dependencies": {
+    "next": "canary",
+    "react": "^16.8.6",
+    "react-dom": "^16.8.6",
+    "firebase": "6.3.4"
+  }
+}

packages/now-next/test/fixtures/02-firebase/pages/nested/fb.js

@@ -0,0 +1,19 @@
+import firebase from 'firebase/app';
+import 'firebase/firestore';
+
+if (!firebase.apps.length) {
+  firebase.initializeApp({ projectId: 'noop' });
+}
+
+const store = firebase.firestore();
+
+const Comp = ({ results }) => {
+  return <div>Hello Firebase: {results}</div>;
+};
+
+Comp.getInitialProps = async () => {
+  const query = await store.collection('users').get();
+  return { results: query.size };
+};
+
+export default Comp;

packages/now-next/test/fixtures/02-firebase/pages/nested/moar/fb.js

@@ -0,0 +1,19 @@
+import firebase from 'firebase/app';
+import 'firebase/firestore';
+
+if (!firebase.apps.length) {
+  firebase.initializeApp({ projectId: 'noop' });
+}
+
+const store = firebase.firestore();
+
+const Comp = ({ results }) => {
+  return <div>Hello Firebase: {results}</div>;
+};
+
+Comp.getInitialProps = async () => {
+  const query = await store.collection('users').get();
+  return { results: query.size };
+};
+
+export default Comp;

packages/now-next/test/fixtures/03-next-8/next.config.js

@@ -0,0 +1,5 @@
+module.exports = {
+  generateBuildId() {
+    return 'testing-build-id';
+  },
+};

packages/now-next/test/fixtures/03-next-8/now.json

@@ -0,0 +1,8 @@
+{
+  "version": 2,
+  "builds": [{ "src": "package.json", "use": "@now/next" }],
+  "probes": [
+    { "path": "/hello1", "mustContain": "Hello World 1" },
+    { "path": "/nested/hello2", "mustContain": "Hello World 2" }
+  ]
+}

packages/now-next/test/fixtures/03-next-8/package.json

@@ -0,0 +1,7 @@
+{
+  "dependencies": {
+    "next": "8.x.x",
+    "react": "^16.8.6",
+    "react-dom": "^16.8.6"
+  }
+}

packages/now-next/test/fixtures/03-next-8/pages/hello1.js

@@ -0,0 +1,7 @@
+function A({ data }) {
+  return <div>{data}</div>;
+}
+
+A.getInitialProps = () => ({ data: 'Hello World 1' });
+
+export default A;

packages/now-next/test/fixtures/03-next-8/pages/nested/hello2.js

@@ -0,0 +1,7 @@
+function B({ data }) {
+  return <div>{data}</div>;
+}
+
+B.getInitialProps = () => ({ data: 'Hello World 2' });
+
+export default B;

packages/now-next/test/unit/build.test.js

@@ -22,6 +22,24 @@ describe('build meta dev', () => {
       export default () => 'Index page'
     `,
     }),
+    'pages/nested/[param].js': new FileBlob({
+      mode: 0o777,
+      data: `
+      export default () => 'Dynamic page'
+    `,
+    }),
+    'pages/nested/page.tsx': new FileBlob({
+      mode: 0o777,
+      data: `
+      export default () => 'Nested page'
+    `,
+    }),
+    'pages/api/test.js': new FileBlob({
+      mode: 0o777,
+      data: `
+      export default (req, res) => res.status(200).end('API Route')
+    `,
+    }),
     // This file should be omitted because `pages/index.js` will use the same route
     'public/index': new FileBlob({
       mode: 0o777,
@@ -39,9 +57,14 @@ describe('build meta dev', () => {
           "now-build": "next build"
         },
         "dependencies": {
-          "next": "8",
+          "next": "9",
           "react": "16",
           "react-dom": "16"
+        },
+        "devDependencies": {
+          "@types/node": "12",
+          "@types/react": "16",
+          "typescript": "3"
         }
       }
     `,
@@ -80,11 +103,20 @@ describe('build meta dev', () => {
       { src: '/static/(.*)', dest: 'http://localhost:5000/static/$1' },
       { src: '/index', dest: 'http://localhost:5000/index' },
       { src: '/', dest: 'http://localhost:5000/' },
+      { src: '/nested/page', dest: 'http://localhost:5000/nested/page' },
+      { src: '/api/test', dest: 'http://localhost:5000/api/test' },
+      {
+        src: '^/(nested\\/([^\\/]+?)(?:\\/)?)$',
+        dest: 'http://localhost:5000/$1',
+      },
       { src: '/data.txt', dest: 'http://localhost:5000/data.txt' },
     ]);
     expect(watch).toEqual([
       'next.config.js',
       'pages/index.js',
+      'pages/nested/[param].js',
+      'pages/nested/page.tsx',
+      'pages/api/test.js',
       'public/index',
       'public/data.txt',
       'package.json',

packages/now-next/test/unit/export.test.js

@@ -0,0 +1,13 @@
+describe('export', () => {
+  it('should require by path main', async () => {
+    const main = require('@now/next');
+    expect(main).toBeDefined();
+  });
+
+  it('should require by path dev-server relative to index', async () => {
+    const index = require('@now/next/dist/index.js');
+    const server = require('@now/next/dist/dev-server.js');
+    expect(index).toBeDefined();
+    expect(server).toBeDefined();
+  });
+});

packages/now-next/test/unit/utils.test.js

@@ -6,7 +6,7 @@ const {
   normalizePackageJson,
   getNextConfig,
 } = require('@now/next/dist/utils');
-const FileRef = require('@now/build-utils/file-ref'); // eslint-disable-line import/no-extraneous-dependencies
+const { FileRef } = require('@now/build-utils'); // eslint-disable-line import/no-extraneous-dependencies
 
 describe('getNextConfig', () => {
   const workPath = path.join(__dirname, 'fixtures');

packages/now-node/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@now/node",
-  "version": "0.12.0",
+  "version": "0.12.6",
   "license": "MIT",
   "main": "./dist/index",
   "homepage": "https://zeit.co/docs/v2/deployments/official-builders/node-js-now-node",
@@ -28,7 +28,7 @@
     "@types/etag": "1.8.0",
     "@types/test-listen": "1.1.0",
     "@zeit/ncc": "0.20.4",
-    "@zeit/node-file-trace": "0.2.1",
+    "@zeit/node-file-trace": "0.2.9",
     "content-type": "1.0.4",
     "cookie": "0.4.0",
     "etag": "1.8.1",

packages/now-node/src/index.ts

@@ -16,6 +16,7 @@ import {
   PrepareCacheOptions,
   BuildOptions,
   shouldServe,
+  Config,
 } from '@now/build-utils';
 export { NowRequest, NowResponse } from './types';
 import { makeLauncher } from './launcher';
@@ -32,6 +33,7 @@ interface DownloadOptions {
   files: Files;
   entrypoint: string;
   workPath: string;
+  config: Config;
   meta: Meta;
 }
 
@@ -53,16 +55,25 @@ async function downloadInstallAndBundle({
   files,
   entrypoint,
   workPath,
+  config,
   meta,
 }: DownloadOptions) {
   console.log('downloading user files...');
+  const downloadTime = Date.now();
   const downloadedFiles = await download(files, workPath, meta);
+  console.log(`download complete [${Date.now() - downloadTime}ms]`);
 
   console.log("installing dependencies for user's code...");
+  const installTime = Date.now();
   const entrypointFsDirname = join(workPath, dirname(entrypoint));
-  const nodeVersion = await getNodeVersion(entrypointFsDirname);
+  const nodeVersion = await getNodeVersion(
+    entrypointFsDirname,
+    undefined,
+    config
+  );
   const spawnOpts = getSpawnOptions(meta, nodeVersion);
   await runNpmInstall(entrypointFsDirname, ['--prefer-offline'], spawnOpts);
+  console.log(`install complete [${Date.now() - installTime}ms]`);
 
   const entrypointPath = downloadedFiles[entrypoint].fsPath;
   return { entrypointPath, entrypointFsDirname, nodeVersion, spawnOpts };
@@ -72,8 +83,7 @@ async function compile(
   workPath: string,
   entrypointPath: string,
   entrypoint: string,
-  config: CompilerConfig,
-  { isDev, filesChanged, filesRemoved }: Meta
+  config: CompilerConfig
 ): Promise<{
   preparedFiles: Files;
   shouldAddSourcemapSupport: boolean;
@@ -162,6 +172,7 @@ async function compile(
   const { fileList, esmFileList } = await nodeFileTrace([...inputFiles], {
     base: workPath,
     ts: true,
+    mixedModules: true,
     ignore: config.excludeFiles,
     readFile(fsPath: string): Buffer | string | null {
       const relPath = relative(workPath, fsPath);
@@ -175,9 +186,12 @@ async function compile(
           source = compileTypeScript(fsPath, source.toString());
         }
         const { mode } = lstatSync(fsPath);
-        if (isSymbolicLink(mode))
-          throw new Error('Internal error: Unexpected symlink.');
-        const entry = new FileBlob({ data: source, mode });
+        let entry: File;
+        if (isSymbolicLink(mode)) {
+          entry = new FileFsRef({ fsPath, mode });
+        } else {
+          entry = new FileBlob({ data: source, mode });
+        }
         fsCache.set(relPath, entry);
         sourceCache.set(relPath, source);
         return source.toString();
@@ -225,7 +239,12 @@ async function compile(
       }
     }
     // Rename .ts -> .js (except for entry)
-    if (path !== entrypoint && tsCompiled.has(path)) {
+    // There is a bug on Windows where entrypoint uses forward slashes
+    // and workPath uses backslashes so we use resolve before comparing.
+    if (
+      resolve(workPath, path) !== resolve(workPath, entrypoint) &&
+      tsCompiled.has(path)
+    ) {
       preparedFiles[
         path.slice(0, -3 - Number(path.endsWith('x'))) + '.js'
       ] = entry;
@@ -290,20 +309,24 @@ export async function build({
     files,
     entrypoint,
     workPath,
+    config,
     meta,
   });
 
   console.log('running user script...');
+  const runScriptTime = Date.now();
   await runPackageJsonScript(entrypointFsDirname, 'now-build', spawnOpts);
+  console.log(`script complete [${Date.now() - runScriptTime}ms]`);
 
   console.log('tracing input files...');
+  const traceTime = Date.now();
   const { preparedFiles, shouldAddSourcemapSupport, watch } = await compile(
     workPath,
     entrypointPath,
     entrypoint,
-    config,
-    meta
+    config
   );
+  console.log(`trace complete [${Date.now() - traceTime}ms]`);
 
   const launcherFiles: Files = {
     [`${LAUNCHER_FILENAME}.js`]: new FileBlob({

packages/now-node/src/typescript.ts

@@ -8,7 +8,7 @@ import _ts from 'typescript';
  */
 
 /**
- * Debugging `ts-node`.
+ * Debugging.
  */
 const shouldDebug = false;
 const debug = shouldDebug
@@ -453,11 +453,18 @@ function fixConfig(ts: TSCommon, config: _ts.ParsedCommandLine) {
   delete config.options.tsBuildInfoFile;
   delete config.options.incremental;
 
-  // Target ES5 output by default (instead of ES3).
+  // Target esnext output by default (instead of ES3).
+  // This will prevent TS from polyfill/downlevel emit.
   if (config.options.target === undefined) {
     config.options.target = ts.ScriptTarget.ESNext;
   }
 
+  // When mixing TS with JS, its best to enable this flag.
+  // This is useful when no `tsconfig.json` is supplied.
+  if (config.options.esModuleInterop === undefined) {
+    config.options.esModuleInterop = true;
+  }
+
   // Target CommonJS, always!
   config.options.module = ts.ModuleKind.CommonJS;
 

packages/now-node/test/fixtures/18-nested-tsconfig/functions/double-redirect.ts

@@ -3,13 +3,15 @@ import { parse } from 'url';
 
 const func = (req: IncomingMessage, res: ServerResponse) => {
   if (req.url) {
-    const url = parse(req.url);
+    const { pathname, search } = parse(req.url);
+    const location = pathname
+      ? pathname.replace(/\/+/g, '/') + (search ? search : '')
+      : '/';
+    /*
     res.writeHead(302, {
-      Location: url.pathname
-        ? url.pathname.replace(/\/+/g, '/') + (url.search ? url.search : '')
-        : '/',
-    });
-    res.end();
+      Location: location
+    });*/
+    res.end(`double-redirect:RANDOMNESS_PLACEHOLDER:${location}`);
   }
 };
 

packages/now-node/test/fixtures/18-nested-tsconfig/now.json

@@ -29,7 +29,7 @@
       "mustContain": "root:RANDOMNESS_PLACEHOLDER"
     },
     {
-      "path": "//",
+      "path": "/pricing/",
       "mustContain": "trailing-redirect:RANDOMNESS_PLACEHOLDER"
     }
   ]

packages/now-node/test/fixtures/19-default-import-ts/index.ts

@@ -0,0 +1,8 @@
+//@ts-ignore test will compile during deployment
+import express from 'express';
+const router = express.Router();
+
+export default function handler(req: any, res: any) {
+  if (router && req) res.end('default-import:RANDOMNESS_PLACEHOLDER');
+  else res.end('failed to fetch default import');
+}

packages/now-node/test/fixtures/19-default-import-ts/now.json

@@ -0,0 +1,10 @@
+{
+  "version": 2,
+  "builds": [{ "src": "index.ts", "use": "@now/node" }],
+  "probes": [
+    {
+      "path": "/",
+      "mustContain": "default-import:RANDOMNESS_PLACEHOLDER"
+    }
+  ]
+}

packages/now-node/test/fixtures/19-default-import-ts/package.json

@@ -0,0 +1,6 @@
+{
+  "dependencies": {
+    "@types/express": "4.17.0",
+    "express": "4.17.1"
+  }
+}

packages/now-node/test/fixtures/20-mixed-modules/entrypoint.js

@@ -0,0 +1,11 @@
+import { dep1 } from './js/ecmascript-module';
+
+const { dep2 } = require('./js/commonjs-module');
+
+module.exports = (req, res) => {
+  if (req && typeof dep1 === 'string' && typeof dep2 === 'string') {
+    res.end('mixed-modules:js:RANDOMNESS_PLACEHOLDER');
+  } else {
+    res.end('import failed');
+  }
+};

packages/now-node/test/fixtures/20-mixed-modules/entrypoint.ts

@@ -0,0 +1,11 @@
+import { IncomingMessage, ServerResponse } from 'http';
+import { dep1 } from './ts/ecmascript-module';
+const { dep2 } = require('./ts/commonjs-module');
+
+module.exports = (req: IncomingMessage, res: ServerResponse) => {
+  if (req && typeof dep1 === 'string' && typeof dep2 === 'string') {
+    res.end('mixed-modules:ts:RANDOMNESS_PLACEHOLDER');
+  } else {
+    res.end('import failed');
+  }
+};

packages/now-node/test/fixtures/20-mixed-modules/js/commonjs-module.js

@@ -0,0 +1 @@
+module.exports = { dep2: 'dep2' };

packages/now-node/test/fixtures/20-mixed-modules/js/ecmascript-module.js

@@ -0,0 +1,2 @@
+export const dep1 = 'dep1';
+export const another = 'another';

packages/now-node/test/fixtures/20-mixed-modules/js/package.json

@@ -0,0 +1,5 @@
+{
+  "engines": {
+    "node": "10.x"
+  }
+}

packages/now-node/test/fixtures/20-mixed-modules/now.json

@@ -0,0 +1,14 @@
+{
+  "version": 2,
+  "builds": [{ "src": "entrypoint**", "use": "@now/node" }],
+  "probes": [
+    {
+      "path": "/entrypoint.js",
+      "mustContain": "mixed-modules:js:RANDOMNESS_PLACEHOLDER"
+    },
+    {
+      "path": "/entrypoint.ts",
+      "mustContain": "mixed-modules:ts:RANDOMNESS_PLACEHOLDER"
+    }
+  ]
+}

packages/now-node/test/fixtures/20-mixed-modules/ts/commonjs-module.ts

@@ -0,0 +1 @@
+module.exports = { dep2: 'dep2' };

packages/now-node/test/fixtures/20-mixed-modules/ts/ecmascript-module.ts

@@ -0,0 +1 @@
+export const dep1 = 'dep1';

packages/now-node/test/fixtures/20-mixed-modules/ts/package.json

@@ -0,0 +1,5 @@
+{
+  "engines": {
+    "node": "10.x"
+  }
+}

packages/now-node/test/fixtures/42-yarn-workspaces-typescript-dep/packages/lib/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@builders-typescript-test/lib",
-  "main": "index.ts",
+  "main": "src/index",
   "version": "1.0.0",
   "devDependencies": {
     "typescript": "^3.4.5"

packages/now-node/test/fixtures/42-yarn-workspaces-typescript-dep/packages/lib/tsconfig.json

@@ -1,4 +1,4 @@
 {
   "extends": "../../tsconfig.json",
-  "include": ["./**/*.ts"]
+  "include": ["src/**/*.ts"]
 }

packages/now-php-bridge/.npmignore

@@ -1 +0,0 @@
-/build