Publish

- @now/bash@1.0.0
 - @now/build-utils@0.8.0
 - @now/go@0.5.4
 - @now/html-minifier@1.1.4
 - @now/md@0.5.5
 - @now/mdx-deck@0.5.5
 - @now/next@0.5.3
 - @now/node-server@0.8.2
 - @now/node@0.11.1
 - @now/optipng@0.6.4
 - @now/php@0.5.6
 - @now/python@0.2.10
 - @now/ruby@0.1.2
 - @now/rust@0.2.8
 - @now/static-build@0.7.0

.circleci/config.yml

@@ -29,14 +29,8 @@ jobs:
       - run:
           name: Tests and Coverage
           command: yarn test-coverage
-      - run:
-          name: Potentially save npm token
-          command: "([[ ! -z $NPM_TOKEN ]] && echo \"//registry.npmjs.org/:_authToken=$NPM_TOKEN\" >> ~/.npmrc) || echo \"Did not write npm token\""
-      - run:
-          name: Potentially publish releases to npm
-          command: ./.circleci/publish.sh
 workflows:
   version: 2
-  build-and-deploy:
+  build-and-test:
     jobs:
       - build

.circleci/publish.sh

@@ -1,6 +1,13 @@
 #!/bin/bash
 set -euo pipefail
 
+if [ -z "$NPM_TOKEN" ]; then
+  echo "NPM_TOKEN not found. Did you forget to assign the GitHub Action secret?"
+  exit 1
+fi
+
+echo "//registry.npmjs.org/:_authToken=$NPM_TOKEN" >> ~/.npmrc
+
 if [ ! -e ~/.npmrc ]; then
   echo "~/.npmrc file does not exist, skipping publish"
   exit 0

.editorconfig

@@ -0,0 +1,43 @@
+root = true
+
+[*]
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[{*.json,*.json.example,*.gyp,*.yml,*.yaml,*.workflow}]
+indent_style = space
+indent_size = 2
+
+[{*.py,*.asm}]
+indent_style = space
+
+[*.py]
+indent_size = 4
+
+[*.asm]
+indent_size = 8
+
+[*.md]
+trim_trailing_whitespace = false
+indent_style = space
+indent_size = 2
+
+# Ideal settings - some plugins might support these
+[*.js,*.jsx,*.ts,*.tsx]
+quote_type = single
+indent_style = space
+indent_size = 2
+
+[{*.c,*.cc,*.h,*.hh,*.cpp,*.hpp,*.m,*.mm,*.mpp,*.java,*.go,*.rs,*.php,*.ng,*.d,*.cs,*.swift}]
+indent_style = tab
+indent_size = 4
+tab_width = 4
+
+[{*.c,*.cc,*.h,*.hh,*.cpp,*.hpp,*.m,*.mm,*.mpp,*.js,*.java,*.go,*.rs,*.php,*.ng,*.jsx,*.ts,*.tsx,*.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

.eslintignore

@@ -3,9 +3,15 @@
 /**/node_modules/*
 /packages/now-go/go/*
 /packages/now-build-utils/dist/*
+/packages/now-build-utils/src/*.js
+/packages/now-build-utils/src/fs/*.js
 /packages/now-node/dist/*
 /packages/now-next/dist/*
 /packages/now-node-bridge/*
-/packages/now-python/*
+/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/**

.github/CODEOWNERS

@@ -1,7 +1,11 @@
 # Documentation
 # https://help.github.com/en/articles/about-code-owners
 
-*                       @styfle
-/packages/now-node      @styfle @tootallnate
-/packages/now-next      @styfle @dav-is
-/packages/now-go        @styfle @sophearak
+*                         @styfle
+/packages/now-node        @styfle @tootallnate @lucleray
+/packages/now-node-bridge @styfle @tootallnate @lucleray
+/packages/now-next        @timer  @dav-is
+/packages/now-go          @styfle @sophearak
+/packages/now-python      @styfle @sophearak
+/packages/now-rust        @styfle @mike-engel @anmonteiro
+/packages/now-ruby        @styfle @coetry @nathancahill

.github/main.workflow

@@ -0,0 +1,76 @@
+workflow "Canary publish" {
+  on = "push"
+  resolves = ["3. Canary yarn run publish"]
+}
+
+action "0. Canary filter" {
+  uses = "actions/bin/filter@3c0b4f0e63ea54ea5df2914b4fabf383368cd0da"
+  args = "branch canary"
+}
+
+action "0. Canary PR not deleted" {
+  uses = "actions/bin/filter@3c0b4f0e63ea54ea5df2914b4fabf383368cd0da"
+  needs = ["0. Canary filter"]
+  args = "not deleted"
+}
+
+action "1. Canary yarn install" {
+  uses = "actions/npm@59b64a598378f31e49cb76f27d6f3312b582f680"
+  needs = ["0. Canary PR not deleted"]
+  runs = "yarn"
+  args = "install"
+}
+
+action "2. Canary yarn run build" {
+  uses = "actions/npm@59b64a598378f31e49cb76f27d6f3312b582f680"
+  needs = ["1. Canary yarn install"]
+  runs = "yarn"
+  args = "run build"
+}
+
+action "3. Canary yarn run publish" {
+  uses = "actions/npm@59b64a598378f31e49cb76f27d6f3312b582f680"
+  needs = ["2. Canary yarn run build"]
+  runs = "yarn"
+  args = "run publish-from-github"
+  secrets = ["NPM_TOKEN"]
+}
+
+
+workflow "Master publish" {
+  on = "push"
+  resolves = ["3. Master yarn run publish"]
+}
+
+action "0. Master filter" {
+  uses = "actions/bin/filter@3c0b4f0e63ea54ea5df2914b4fabf383368cd0da"
+  args = "branch master"
+}
+
+action "0. Master PR not deleted" {
+  uses = "actions/bin/filter@3c0b4f0e63ea54ea5df2914b4fabf383368cd0da"
+  needs = ["0. Master filter"]
+  args = "not deleted"
+}
+
+action "1. Master yarn install" {
+  uses = "actions/npm@59b64a598378f31e49cb76f27d6f3312b582f680"
+  needs = ["0. Master PR not deleted"]
+  runs = "yarn"
+  args = "install"
+}
+
+action "2. Master yarn run build" {
+  uses = "actions/npm@59b64a598378f31e49cb76f27d6f3312b582f680"
+  needs = ["1. Master yarn install"]
+  runs = "yarn"
+  args = "run build"
+}
+
+action "3. Master yarn run publish" {
+  uses = "actions/npm@59b64a598378f31e49cb76f27d6f3312b582f680"
+  needs = ["2. Master yarn run build"]
+  runs = "yarn"
+  args = "run publish-from-github"
+  secrets = ["NPM_TOKEN"]
+}

.prettierrc.json

@@ -1,4 +0,0 @@
-{
-  "singleQuote": true,
-  "trailingComma": "es5"
-}

.vscode/settings.json

@@ -1,3 +0,0 @@
-{
-  "eslint.enable": false
-}

.yarnrc

@@ -0,0 +1 @@
+save-prefix ""

CONTRIBUTING.md

@@ -0,0 +1,85 @@
+# Contributing
+
+When contributing to this repository, please first discuss the change you wish to make via issue or [spectrum](https://spectrum.chat/zeit) with the owners of this repository before submitting a Pull Request.
+
+Please read our [code of conduct](CODE_OF_CONDUCT.md) and follow it in all your interactions with the project.
+
+## Local development
+
+This project is configured in a monorepo pattern where one repo contains multiple npm packages. Dependencies are installed and managed with `yarn`, not `npm` CLI.
+
+To get started, execute the following:
+
+```
+git clone https://github.com/zeit/now-builders
+yarn install
+yarn bootstrap
+yarn build
+yarn lint
+yarn test
+```
+
+Make sure all the tests pass before making changes.
+
+## Verifying your change
+
+Once you are done with your changes (we even suggest doing it along the way ), make sure all the test still run by running
+
+```
+yarn build && yarn test
+```
+
+from the root of the project.
+
+If any test fails, make sure to fix it along with your changes. See [Interpreting test errors](#Interpreting-test-errors) for more information about how the tests are executed, especially the integration tests.
+
+## Pull Request Process
+
+Once you are confident that your changes work properly, open a pull request on the main repository.
+
+The pull request will be reviewed by the maintainers and the tests will be checked by our continuous integration platform.
+
+## Interpreting test errors
+
+There are 2 kinds of tests in this repository – Unit tests and Integration tests.
+
+Unit tests are run locally with `jest` and execute quickly because they are testing the smallest units of code.
+
+### Integration tests
+
+Integration tests create deployments to your ZEIT account using the `test` project name. After each test is deployed, the `probes` key is used to check if the response is the expected value. If the value doesn't match, you'll see a message explaining the difference. If the deployment failed to build, you'll see a more generic message like the following:
+
+```
+[Error: Fetched page https://test-8ashcdlew.now.sh/root.js does not contain hello Root!. Instead it contains An error occurred with this application.
+
+    NO_STATUS_CODE_FRO Response headers:
+       cache-control=s-maxage=0
+      connection=close
+      content-type=text/plain; charset=utf-8
+      date=Wed, 19 Jun 2019 18:01:37 GMT
+      server=now
+      strict-transport-security=max-age=63072000
+      transfer-encoding=chunked
+      x-now-id=iad1:hgtzj-1560967297876-44ae12559f95
+      x-now-trace=iad1]
+```
+
+In such cases you can visit the URL of the failed deployment and append `/_logs` so see the build error. In the case above, that would be https://test-8ashcdlew.now.sh/_logs
+
+The logs of this deployment will contain the actual error which may help you to understand what went wrong.
+
+### @zeit/ncc integration
+
+Some of the builders use `@zeit/ncc` to bundle files before deployment. If you suspect an error with the bundling mechanism, you can run the `ncc` CLI with a couple modifications to the test.
+
+For example if an error occurred in `now-node/test/fixtures/08-assets`
+
+```
+cd packages/now-node/test/fixtures/08-assets
+yarn install
+echo 'require("http").createServer(module.exports).listen(3000)' >> index.js
+npx @zeit/ncc@0.20.1 build index.js --source-map
+node dist
+```
+
+This will compile the test with the specific version of `ncc` and run the resulting file. If it fails here, then there is likely a bug in `ncc` and not the Builder.

README.md

@@ -1,27 +1,52 @@
 # now-builders
 
-This is the full list of official Builders provided by the ZEIT team.
+This is a monorepo containing the [Official Builders](https://zeit.co/docs/v2/deployments/builders/overview) provided by the ZEIT team.
 
-More details here: https://zeit.co/docs/v2/deployments/builders/overview/
+## Channels
+
+There are two Channels:
+
+| Channel | Git Branch | npm dist-tag | use example        |
+| ------- | ---------- | ------------ | ------------------ |
+| Canary  | `canary`   | `@canary`    | `@now/node@canary` |
+| Stable  | `master`   | `@latest`    | `@now/node@latest` |
+
+All PRs should be 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.
 
 ### Publishing to npm
 
-Run the following command to publish modified builders to npm:
-
-For the stable channel use:
-
-```
-yarn publish-stable
-```
-
-For the canary channel use:
+For the Canary Channel, publish the modified Builders to npm with the following:
 
 ```
 yarn publish-canary
 ```
 
-CircleCI will take care of publishing the updated packages to npm from there.
+For the Stable Channel, you must do the following:
 
-If for some reason CircleCI fails to publish the npm package, you may do so
+- 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
+
+```
+git checkout master
+git pull      # make sure you're up to date
+git cherry-pick <PR501_COMMIT_SHA>
+git cherry-pick <PR502_COMMIT_SHA>
+git cherry-pick <PR503_COMMIT_SHA>
+git cherry-pick <PR504_COMMIT_SHA>
+# ... etc ...
+git diff origin/canary
+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
-include the `--tag canary` parameter if you are publishing a canary release!
+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.

errors/now-next-legacy-mode.md

@@ -29,12 +29,11 @@ Serverless:
 - No runtime dependencies, meaning smaller lambda functions
 - Optimized for fast [cold start](https://zeit.co/blog/serverless-ssr#cold-start)
 
-
 #### Possible Ways to Fix It
 
 In order to create the smallest possible lambdas Next.js has to be configured to build for the `serverless` target.
 
-1. Serverless Next.js requires Next.js 8 or later, to upgrade you can install the `latest` version: 
+1. Serverless Next.js requires Next.js 8 or later, to upgrade you can install the `latest` version:
 
 ```
 npm install next --save
@@ -46,7 +45,7 @@ npm install next --save
 {
   "scripts": {
     "now-build": "next build"
-  },
+  }
 }
 ```
 
@@ -54,9 +53,9 @@ npm install next --save
 
 ```js
 module.exports = {
-  target: 'serverless'
+  target: 'serverless',
   // Other options are still valid
-}
+};
 ```
 
 4. Optionally make sure the `"src"` in `"builds"` points to your application `package.json`
@@ -70,4 +69,4 @@ module.exports = {
 
 ### Useful Links
 
-- [Serverless target implementation](https://github.com/zeit/now-builders/pull/150) 
+- [Serverless target implementation](https://github.com/zeit/now-builders/pull/150)

errors/now-next-no-serverless-pages-built.md

@@ -20,7 +20,7 @@ npm install next --save
 {
   "scripts": {
     "now-build": "next build"
-  },
+  }
 }
 ```
 
@@ -28,9 +28,9 @@ npm install next --save
 
 ```js
 module.exports = {
-  target: 'serverless'
+  target: 'serverless',
   // Other options
-}
+};
 ```
 
 4. Remove `distDir` from `next.config.js` as `@now/next` can't parse this file and expects your build output at `/.next`

errors/now-static-build-failed-to-detect-a-server.md

@@ -0,0 +1,38 @@
+# `@now/static-build` Failed to detect a server running
+
+#### Why This Warning Occurred
+
+When running `now dev`, the `@now/static-build` builder proxies relevant HTTP
+requests to the server that is created by the `now-dev` script in the
+`package.json` file.
+
+In order for `now dev` to know which port the server is running on, the builder
+is provided a `$PORT` environment variable that the server _must_ bind to. The
+error "Failed to detect a server running on port" is printed if the builder fails
+to detect a server listening on that specific port within five minutes.
+
+#### Possible Ways to Fix It
+
+Please ensure that your `now-dev` script binds the spawned development server on
+the provided `$PORT` that the builder expects the server to bind to.
+
+For example, if you are using Gatsby, your `now-dev` script must use the `-p`
+(port) option to bind to the `$PORT` specified from the builder:
+
+```
+{
+  ...
+  "scripts": {
+    ...
+    "now-dev": "gatsby develop -p $PORT"
+  }
+}
+```
+
+Consult your static builder program's `--help` or documentation to figure out what
+the command line flag to bind to a specific port is (in many cases, it is one of:
+`-p` / `-P` / `--port`).
+
+### Useful Links
+
+- [`@now/static-build` Local Development Documentation](https://zeit.co/docs/v2/deployments/official-builders/static-build-now-static-build#local-development)

jest.config.js

@@ -1,5 +1,35 @@
+const { execSync } = require('child_process');
+const { relative } = require('path');
+
+const branch = execSync('git branch | grep "*" | cut -d " " -f2')
+  .toString()
+  .trim();
+console.log(`Running tests on branch "${branch}"`);
+const gitPath = branch === 'master' ? 'HEAD~1' : 'origin/canary...HEAD';
+const diff = execSync(`git diff ${gitPath} --name-only`).toString();
+
+const changed = diff
+  .split('\n')
+  .filter(item => Boolean(item) && item.includes('packages/'))
+  .map(item => relative('packages', item).split('/')[0]);
+
+const matches = Array.from(new Set(changed));
+
+if (matches.length === 0) {
+  matches.push('now-node');
+  console.log(`No packages changed, defaulting to ${matches[0]}`);
+} else {
+  console.log('The following packages have changed:');
+  console.log(matches.join('\n'));
+}
+
+const testMatch = matches.map(
+  item => `**/${item}/**/?(*.)+(spec|test).[jt]s?(x)`,
+);
+
 module.exports = {
   testEnvironment: 'node',
+  testMatch,
   collectCoverageFrom: [
     'packages/(!test)/**/*.{js,jsx}',
     '!**/node_modules/**',

lerna.json

@@ -1,9 +1,7 @@
 {
   "npmClient": "yarn",
   "useWorkspaces": true,
-  "packages": [
-    "packages/*"
-  ],
+  "packages": ["packages/*"],
   "command": {
     "publish": {
       "npmClient": "npm",

package.json

@@ -12,8 +12,9 @@
   "scripts": {
     "lerna": "lerna",
     "bootstrap": "lerna bootstrap",
-    "publish-stable": "lerna version",
-    "publish-canary": "lerna version prerelease --preid canary",
+    "publish-stable": "git checkout master && git pull && lerna version --exact",
+    "publish-canary": "git checkout canary && git pull && lerna version prerelease --preid canary --exact",
+    "publish-from-github": "./.circleci/publish.sh",
     "build": "./.circleci/build.sh",
     "lint": "eslint .",
     "codecov": "codecov",
@@ -31,6 +32,14 @@
     "*.ts": [
       "prettier --write",
       "git add"
+    ],
+    "*.json": [
+      "prettier --write",
+      "git add"
+    ],
+    "*.md": [
+      "prettier --write",
+      "git add"
     ]
   },
   "devDependencies": {
@@ -51,6 +60,10 @@
     "lint-staged": "^8.0.4",
     "node-fetch": "^2.3.0",
     "pre-commit": "^1.2.2",
-    "prettier": "^1.15.2"
+    "prettier": "1.17.1"
+  },
+  "prettier": {
+    "singleQuote": true,
+    "trailingComma": "es5"
   }
 }

packages/now-bash/index.js

@@ -13,6 +13,15 @@ exports.config = {
   maxLambdaSize: '10mb',
 };
 
+// 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 ({
@@ -24,10 +33,23 @@ exports.build = async ({
   await download(files, srcDir);
 
   const configEnv = Object.keys(config).reduce((o, v) => {
-    o[`IMPORT_${snakeCase(v).toUpperCase()}`] = config[v]; // eslint-disable-line no-param-reassign
+    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 = `${workPath}/.import-cache`;
   const env = Object.assign({}, process.env, configEnv, {
     PATH: `${IMPORT_CACHE}/bin:${process.env.PATH}`,

packages/now-bash/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@now/bash",
-  "version": "0.2.3",
+  "version": "1.0.0",
   "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",

packages/now-build-utils/package.json

@@ -1,16 +1,21 @@
 {
   "name": "@now/build-utils",
-  "version": "0.5.5",
+  "version": "0.8.0",
   "license": "MIT",
   "main": "./dist/index.js",
   "types": "./dist/index.d.js",
+  "homepage": "https://zeit.co/docs/v2/deployments/builders/developer-guide",
   "repository": {
     "type": "git",
     "url": "https://github.com/zeit/now-builders.git",
     "directory": "packages/now-build-utils"
   },
+  "scripts": {
+    "build": "tsc",
+    "test": "tsc && jest",
+    "prepublishOnly": "tsc"
+  },
   "dependencies": {
-    "@types/cross-spawn": "6.0.0",
     "async-retry": "1.2.3",
     "async-sema": "2.1.4",
     "cross-spawn": "6.0.5",
@@ -18,24 +23,22 @@
     "fs-extra": "7.0.0",
     "glob": "7.1.3",
     "into-stream": "5.0.0",
-    "memory-fs": "0.4.1",
+    "minimatch": "3.0.4",
     "multistream": "2.1.1",
     "node-fetch": "2.2.0",
+    "semver": "6.1.1",
     "yazl": "2.4.3"
   },
-  "scripts": {
-    "build": "tsc",
-    "test": "tsc && jest",
-    "prepublish": "tsc"
-  },
   "devDependencies": {
     "@types/async-retry": "^1.2.1",
+    "@types/cross-spawn": "6.0.0",
     "@types/end-of-stream": "^1.4.0",
     "@types/fs-extra": "^5.0.5",
     "@types/glob": "^7.1.1",
     "@types/node-fetch": "^2.1.6",
+    "@types/semver": "6.0.0",
     "@types/yazl": "^2.4.1",
     "execa": "^1.0.0",
-    "typescript": "3.3.4000"
+    "typescript": "3.5.2"
   }
 }

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

@@ -0,0 +1,47 @@
+import { PackageJson, Builder, Config } from './types';
+import minimatch from 'minimatch';
+
+const src: string = 'package.json';
+const config: Config = { zeroConfig: true };
+
+// Static builders are special cased in `@now/static-build`
+const BUILDERS = new Map<string, Builder>([
+  ['next', { src, use: '@now/next', config }],
+]);
+
+const API_BUILDERS: Builder[] = [
+  { src: 'api/**/*.js', use: '@now/node', config },
+  { src: 'api/**/*.ts', use: '@now/node', config },
+  { src: 'api/**/*.rs', use: '@now/rust', 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 },
+];
+
+export async function detectBuilder(pkg: PackageJson): Promise<Builder> {
+  for (const [dependency, builder] of BUILDERS) {
+    const deps = Object.assign({}, pkg.dependencies, pkg.devDependencies);
+
+    // Return the builder when a dependency matches
+    if (deps[dependency]) {
+      return builder;
+    }
+  }
+
+  // By default we'll choose the `static-build` builder
+  return { src, use: '@now/static-build', config };
+}
+
+export async function detectApiBuilders(
+  files: string[]
+): Promise<Builder[] | null> {
+  const builds = files.map(file => {
+    return API_BUILDERS.find(({ src }): boolean => minimatch(file, src));
+  });
+
+  // We can use `new Set` here since `builds` contains references to `API_BUILDERS`
+  const finishedBuilds = Array.from(new Set(builds.filter(Boolean)));
+  return finishedBuilds.length > 0 ? (finishedBuilds as Builder[]) : null;
+}

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

@@ -0,0 +1,239 @@
+import path from 'path';
+import { Route } from './types';
+
+function concatArrayOfText(texts: string[]): string {
+  const last = texts.pop();
+  return `${texts.join(', ')}, and ${last}`;
+}
+
+// Takes a filename or foldername, strips the extension
+// gets the part between the "[]" brackets.
+// It will return `null` if there are no brackets
+// and therefore no segment.
+function getSegmentName(segment: string): string | null {
+  const { name } = path.parse(segment);
+
+  if (name.startsWith('[') && name.endsWith(']')) {
+    return name.slice(1, -1);
+  }
+
+  return null;
+}
+
+function createRouteFromPath(filePath: string): Route {
+  const parts = filePath.split('/');
+
+  let append: string = '';
+  let counter: number = 1;
+  const query: string[] = [];
+
+  const srcParts = parts.map(
+    (segment, index): string => {
+      const name = getSegmentName(segment);
+      const isLast = index === parts.length - 1;
+
+      if (name !== null) {
+        query.push(`${name}=$${counter++}`);
+
+        if (isLast) {
+          // We append this to the last one
+          // to make sure GET params still work
+          // and are just appended to our GET params
+          append += `$${counter++}`;
+          return `([^\\/|\\?]+)\\/?(?:\\?(.*))?`;
+        }
+
+        return `([^\\/]+)`;
+      } else if (isLast) {
+        // If it is the last part we want to remove the extension
+        // and capture everything after that as regex group and append it
+        const { name: fileName } = path.parse(segment);
+        append += `$${counter++}`;
+        return `${fileName}(.*)`;
+      }
+
+      return segment;
+    }
+  );
+
+  const src = `^/${srcParts.join('/')}$`;
+  const dest = `/${filePath}${query.length ? '?' : ''}${query.join('&')}${
+    query.length ? '&' : ''
+  }${append}`;
+
+  return { src, dest };
+}
+
+// Check if the path partially matches and has the same
+// name for the path segment at the same position
+function partiallyMatches(pathA: string, pathB: string): boolean {
+  const partsA = pathA.split('/');
+  const partsB = pathB.split('/');
+
+  const long = partsA.length > partsB.length ? partsA : partsB;
+  const short = long === partsA ? partsB : partsA;
+
+  let index = 0;
+
+  for (const segmentShort of short) {
+    const segmentLong = long[index];
+
+    const nameLong = getSegmentName(segmentLong);
+    const nameShort = getSegmentName(segmentShort);
+
+    // If there are no segments or the paths differ we
+    // return as they are not matching
+    if (segmentShort !== segmentLong && (!nameLong || !nameShort)) {
+      return false;
+    }
+
+    if (nameLong !== nameShort) {
+      return true;
+    }
+
+    index += 1;
+  }
+
+  return false;
+}
+
+// Counts how often a path occurres when all placeholders
+// got resolved, so we can check if they have conflicts
+function pathOccurrences(filePath: string, files: string[]): string[] {
+  const getAbsolutePath = (unresolvedPath: string): string => {
+    const { dir, name } = path.parse(unresolvedPath);
+    const parts = path.join(dir, name).split('/');
+    return parts.map(part => part.replace(/\[.*\]/, '1')).join('/');
+  };
+
+  const currentAbsolutePath = getAbsolutePath(filePath);
+
+  return files.reduce((prev: string[], file: string): string[] => {
+    const absolutePath = getAbsolutePath(file);
+
+    if (absolutePath === currentAbsolutePath) {
+      prev.push(file);
+    } else if (partiallyMatches(filePath, file)) {
+      prev.push(file);
+    }
+
+    return prev;
+  }, []);
+}
+
+// Checks if a placeholder with the same name is used
+// multiple times inside the same path
+function getConflictingSegment(filePath: string): string | null {
+  const segments = new Set<string>();
+
+  for (const segment of filePath.split('/')) {
+    const name = getSegmentName(segment);
+
+    if (name !== null && segments.has(name)) {
+      return name;
+    }
+
+    if (name) {
+      segments.add(name);
+    }
+  }
+
+  return null;
+}
+
+function sortFilesBySegmentCount(fileA: string, fileB: string): number {
+  const lengthA = fileA.split('/').length;
+  const lengthB = fileB.split('/').length;
+
+  if (lengthA > lengthB) {
+    return -1;
+  }
+
+  if (lengthA < lengthB) {
+    return 1;
+  }
+
+  // Paths that have the same segment length but
+  // less placeholders are preferred
+  const countSegments = (prev: number, segment: string) =>
+    getSegmentName(segment) ? prev + 1 : 0;
+  const segmentLengthA = fileA.split('/').reduce(countSegments, 0);
+  const segmentLengthB = fileB.split('/').reduce(countSegments, 0);
+
+  if (segmentLengthA > segmentLengthB) {
+    return 1;
+  }
+
+  if (segmentLengthA < segmentLengthB) {
+    return -1;
+  }
+
+  return 0;
+}
+
+export async function detectApiRoutes(
+  files: string[]
+): Promise<{
+  defaultRoutes: Route[] | null;
+  error: { [key: string]: string } | null;
+}> {
+  if (!files || files.length === 0) {
+    return { defaultRoutes: null, error: null };
+  }
+
+  // The deepest routes need to be
+  // the first ones to get handled
+  const sortedFiles = files.sort(sortFilesBySegmentCount);
+
+  const defaultRoutes: Route[] = [];
+
+  for (const file of sortedFiles) {
+    // We only consider every file in the api directory
+    // as we will strip extensions as well as resolving "[segments]"
+    if (!file.startsWith('api/')) {
+      continue;
+    }
+
+    const conflictingSegment = getConflictingSegment(file);
+
+    console.log({ file, conflictingSegment });
+
+    if (conflictingSegment) {
+      return {
+        defaultRoutes: null,
+        error: {
+          code: 'conflicting_path_segment',
+          message:
+            `The segment "${conflictingSegment}" occurres more than ` +
+            `one time in your path "${file}". Please make sure that ` +
+            `every segment in a path is unique`,
+        },
+      };
+    }
+
+    const occurrences = pathOccurrences(file, sortedFiles).filter(
+      name => name !== file
+    );
+
+    if (occurrences.length > 0) {
+      const messagePaths = concatArrayOfText(
+        occurrences.map(name => `"${name}"`)
+      );
+
+      return {
+        defaultRoutes: null,
+        error: {
+          code: 'conflicting_file_path',
+          message:
+            `Two or more files have conflicting paths or names. ` +
+            `Please make sure path segments and filenames, without their extension, are unique. ` +
+            `The path "${file}" has conflicts with ${messagePaths}`,
+        },
+      };
+    }
+
+    defaultRoutes.push(createRouteFromPath(file));
+  }
+
+  return { defaultRoutes, error: null };
+}

packages/now-build-utils/src/file-fs-ref.ts

@@ -31,7 +31,10 @@ class FileFsRef implements File {
     this.fsPath = fsPath;
   }
 
-  static async fromFsPath({ mode, fsPath }: FileFsRefOptions): Promise<FileFsRef> {
+  static async fromFsPath({
+    mode,
+    fsPath,
+  }: FileFsRefOptions): Promise<FileFsRef> {
     let m = mode;
     if (!m) {
       const stat = await fs.lstat(fsPath);
@@ -40,7 +43,11 @@ class FileFsRef implements File {
     return new FileFsRef({ mode: m, fsPath });
   }
 
-  static async fromStream({ mode = 0o100644, stream, fsPath }: FromStreamOptions): Promise<FileFsRef> {
+  static async fromStream({
+    mode = 0o100644,
+    stream,
+    fsPath,
+  }: FromStreamOptions): Promise<FileFsRef> {
     assert(typeof mode === 'number');
     assert(typeof stream.pipe === 'function'); // is-stream
     assert(typeof fsPath === 'string');
@@ -48,7 +55,7 @@ class FileFsRef implements File {
 
     await new Promise<void>((resolve, reject) => {
       const dest = fs.createWriteStream(fsPath, {
-        mode: mode & 0o777
+        mode: mode & 0o777,
       });
       stream.pipe(dest);
       stream.on('error', reject);
@@ -72,15 +79,15 @@ class FileFsRef implements File {
     let flag = false;
 
     // eslint-disable-next-line consistent-return
-    return multiStream((cb) => {
+    return multiStream(cb => {
       if (flag) return cb(null, null);
       flag = true;
 
       this.toStreamAsync()
-        .then((stream) => {
+        .then(stream => {
           cb(null, stream);
         })
-        .catch((error) => {
+        .catch(error => {
           cb(error, null);
         });
     });

packages/now-build-utils/src/fs/download.ts

@@ -39,10 +39,10 @@ export default async function download(
   basePath: string,
   meta?: Meta
 ): Promise<DownloadedFiles> {
-  const { isDev = false, filesChanged = null, filesRemoved = null } =
+  const { isDev = false, skipDownload = false, filesChanged = null, filesRemoved = null } =
     meta || {};
 
-  if (isDev) {
+  if (isDev || skipDownload) {
     // In `now dev`, the `download()` function is a no-op because
     // the `basePath` matches the `cwd` of the dev server, so the
     // source files are already available.

packages/now-build-utils/src/fs/node-version.ts

@@ -0,0 +1,53 @@
+import { intersects } from 'semver';
+import { NodeVersion } from '../types';
+
+const supportedOptions: NodeVersion[] = [
+  { major: 10, range: '10.x', runtime: 'nodejs10.x' },
+  { major: 8, range: '8.10.x', runtime: 'nodejs8.10' },
+];
+
+// This version should match Fargate's default in the PATH
+// Today that is Node 8
+export const defaultSelection = supportedOptions.find(
+  o => o.major === 8
+) as NodeVersion;
+
+export async function getSupportedNodeVersion(
+  engineRange?: string,
+  silent?: boolean
+): Promise<NodeVersion> {
+  let selection = defaultSelection;
+
+  if (!engineRange) {
+    if (!silent) {
+      console.log(
+        'missing `engines` in `package.json`, using default range: ' +
+          selection.range
+      );
+    }
+  } else {
+    const found = supportedOptions.some(o => {
+      // the array is already in order so return the first
+      // match which will be the newest version of node
+      selection = o;
+      return intersects(o.range, engineRange);
+    });
+    if (found) {
+      if (!silent) {
+        console.log(
+          'Found `engines` in `package.json`, selecting range: ' +
+            selection.range
+        );
+      }
+    } else {
+      if (!silent) {
+        throw new Error(
+          'found `engines` in `package.json` with an unsupported node range: ' +
+            engineRange +
+            '\nplease use `10.x` or `8.10.x` instead'
+        );
+      }
+    }
+  }
+  return selection;
+}

packages/now-build-utils/src/fs/rename.ts

@@ -7,6 +7,6 @@ export default function rename(files: Files, delegate: Delegate): Files {
       ...newFiles,
       [delegate(name)]: files[name],
     }),
-    {},
+    {}
   );
 }

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

@@ -3,6 +3,9 @@ import fs from 'fs-extra';
 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 { getSupportedNodeVersion } from './node-version';
 
 function spawnAsync(
   command: string,
@@ -43,19 +46,49 @@ async function chmodPlusX(fsPath: string) {
   await fs.chmod(fsPath, base8);
 }
 
-export async function runShellScript(fsPath: string) {
+export async function runShellScript(
+  fsPath: string,
+  args: string[] = [],
+  spawnOpts?: SpawnOptions
+) {
   assert(path.isAbsolute(fsPath));
   const destPath = path.dirname(fsPath);
   await chmodPlusX(fsPath);
-  await spawnAsync(`./${path.basename(fsPath)}`, [], destPath);
+  await spawnAsync(`./${path.basename(fsPath)}`, args, destPath, spawnOpts);
   return true;
 }
 
-async function scanParentDirs(destPath: string, scriptName?: string) {
+export function getSpawnOptions(
+  meta: Meta,
+  nodeVersion: NodeVersion
+): SpawnOptions {
+  const opts = {
+    env: { ...process.env },
+  };
+
+  if (!meta.isDev) {
+    opts.env.PATH = `/node${nodeVersion.major}/bin:${opts.env.PATH}`;
+  }
+
+  return opts;
+}
+
+export async function getNodeVersion(
+  destPath: string,
+  minNodeVersion?: string
+): Promise<NodeVersion> {
+  const { packageJson } = await scanParentDirs(destPath, true);
+  const range =
+    (packageJson && packageJson.engines && packageJson.engines.node) ||
+    minNodeVersion;
+  return getSupportedNodeVersion(range, typeof minNodeVersion !== 'undefined');
+}
+
+async function scanParentDirs(destPath: string, readPackageJson = false) {
   assert(path.isAbsolute(destPath));
 
-  let hasScript = false;
   let hasPackageLockJson = false;
+  let packageJson: PackageJson | undefined;
   let currentDestPath = destPath;
 
   // eslint-disable-next-line no-constant-condition
@@ -64,12 +97,9 @@ async function scanParentDirs(destPath: string, scriptName?: string) {
     // eslint-disable-next-line no-await-in-loop
     if (await fs.pathExists(packageJsonPath)) {
       // eslint-disable-next-line no-await-in-loop
-      const packageJson = JSON.parse(
-        await fs.readFile(packageJsonPath, 'utf8')
-      );
-      hasScript = Boolean(
-        packageJson.scripts && scriptName && packageJson.scripts[scriptName]
-      );
+      if (readPackageJson) {
+        packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf8'));
+      }
       // eslint-disable-next-line no-await-in-loop
       hasPackageLockJson = await fs.pathExists(
         path.join(currentDestPath, 'package-lock.json')
@@ -82,12 +112,13 @@ async function scanParentDirs(destPath: string, scriptName?: string) {
     currentDestPath = newDestPath;
   }
 
-  return { hasScript, hasPackageLockJson };
+  return { hasPackageLockJson, packageJson };
 }
 
-export async function installDependencies(
+export async function runNpmInstall(
   destPath: string,
-  args: string[] = []
+  args: string[] = [],
+  spawnOpts?: SpawnOptions
 ) {
   assert(path.isAbsolute(destPath));
 
@@ -95,30 +126,28 @@ export async function installDependencies(
   console.log(`installing to ${destPath}`);
   const { hasPackageLockJson } = await scanParentDirs(destPath);
 
-  const opts = {
-    env: {
-      ...process.env,
-      // This is a little hack to force `node-gyp` to build for the
-      // Node.js version that `@now/node` and `@now/node-server` use
-      npm_config_target: '8.10.0',
-    },
-    stdio: 'pipe',
-  };
+  const opts = spawnOpts || { env: process.env };
 
   if (hasPackageLockJson) {
     commandArgs = args.filter(a => a !== '--prefer-offline');
     await spawnAsync(
       'npm',
-      ['install'].concat(commandArgs),
+      commandArgs.concat(['install', '--unsafe-perm']),
       destPath,
-      opts as SpawnOptions
+      opts
     );
   } else {
     await spawnAsync(
       'yarn',
-      ['--ignore-engines', '--cwd', destPath].concat(commandArgs),
+      commandArgs.concat([
+        '--ignore-engines',
+        '--mutex',
+        'network',
+        '--cwd',
+        destPath,
+      ]),
       destPath,
-      opts as SpawnOptions
+      opts
     );
   }
 }
@@ -129,9 +158,15 @@ export async function runPackageJsonScript(
   opts?: SpawnOptions
 ) {
   assert(path.isAbsolute(destPath));
-  const { hasScript, hasPackageLockJson } = await scanParentDirs(
+  const { packageJson, hasPackageLockJson } = await scanParentDirs(
     destPath,
-    scriptName
+    true
+  );
+  const hasScript = Boolean(
+    packageJson &&
+      packageJson.scripts &&
+      scriptName &&
+      packageJson.scripts[scriptName]
   );
   if (!hasScript) return false;
 
@@ -151,4 +186,11 @@ export async function runPackageJsonScript(
   return true;
 }
 
-export const runNpmInstall = installDependencies;
+/**
+ * @deprecate installDependencies() is deprecated.
+ * Please use runNpmInstall() instead.
+ */
+export const installDependencies = deprecate(
+  runNpmInstall,
+  'installDependencies() is deprecated. Please use runNpmInstall() instead.'
+);

packages/now-build-utils/src/fs/stream-to-buffer.ts

@@ -1,26 +1,28 @@
 import eos from 'end-of-stream';
 
-export default function streamToBuffer(stream: NodeJS.ReadableStream): Promise<Buffer> {
+export default function streamToBuffer(
+  stream: NodeJS.ReadableStream
+): Promise<Buffer> {
   return new Promise<Buffer>((resolve, reject) => {
     const buffers: Buffer[] = [];
 
-    stream.on('data', buffers.push.bind(buffers))
+    stream.on('data', buffers.push.bind(buffers));
 
-    eos(stream, (err) => {
-        if (err) {
-          reject(err);
-          return;
-        }
-        switch (buffers.length) {
-          case 0:
-            resolve(Buffer.allocUnsafe(0));
-            break;
-          case 1:
-            resolve(buffers[0]);
-            break;
-          default:
-            resolve(Buffer.concat(buffers));
-        }
+    eos(stream, err => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      switch (buffers.length) {
+        case 0:
+          resolve(Buffer.allocUnsafe(0));
+          break;
+        case 1:
+          resolve(buffers[0]);
+          break;
+        default:
+          resolve(Buffer.concat(buffers));
+      }
     });
   });
-}
+}

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

@@ -1,34 +1,46 @@
 import FileBlob from './file-blob';
 import FileFsRef from './file-fs-ref';
 import FileRef from './file-ref';
-import { File, Files, AnalyzeOptions, BuildOptions, PrepareCacheOptions, ShouldServeOptions, Meta } from './types';
 import { Lambda, createLambda } from './lambda';
-import download from './fs/download';
-import getWriteableDirectory from './fs/get-writable-directory'
+import download, { DownloadedFiles } from './fs/download';
+import getWriteableDirectory from './fs/get-writable-directory';
 import glob from './fs/glob';
 import rename from './fs/rename';
-import { installDependencies, runPackageJsonScript, runNpmInstall, runShellScript } from './fs/run-user-scripts';
+import {
+  installDependencies,
+  runPackageJsonScript,
+  runNpmInstall,
+  runShellScript,
+  getNodeVersion,
+  getSpawnOptions,
+} from './fs/run-user-scripts';
 import streamToBuffer from './fs/stream-to-buffer';
 import shouldServe from './should-serve';
+import { detectBuilder, detectApiBuilders } from './detect-builder';
+import { detectApiRoutes } from './detect-routes';
 
 export {
-    FileBlob,
-    FileFsRef,
-    FileRef,
-    Files,
-    File,
-    Meta,
-    Lambda,
-    createLambda,
-    download,
-    getWriteableDirectory,
-    glob,
-    rename,
-    installDependencies, runPackageJsonScript, runNpmInstall, runShellScript,
-    streamToBuffer,
-    AnalyzeOptions,
-    BuildOptions,
-    PrepareCacheOptions,
-    ShouldServeOptions,
-    shouldServe,
+  FileBlob,
+  FileFsRef,
+  FileRef,
+  Lambda,
+  createLambda,
+  download,
+  DownloadedFiles,
+  getWriteableDirectory,
+  glob,
+  rename,
+  installDependencies,
+  runPackageJsonScript,
+  runNpmInstall,
+  runShellScript,
+  getNodeVersion,
+  getSpawnOptions,
+  streamToBuffer,
+  shouldServe,
+  detectBuilder,
+  detectApiBuilders,
+  detectApiRoutes,
 };
+
+export * from './types';

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

@@ -32,9 +32,7 @@ export class Lambda {
   public runtime: string;
   public environment: Environment;
 
-  constructor({
-    zipBuffer, handler, runtime, environment,
-  }: LambdaOptions) {
+  constructor({ zipBuffer, handler, runtime, environment }: LambdaOptions) {
     this.type = 'Lambda';
     this.zipBuffer = zipBuffer;
     this.handler = handler;
@@ -47,7 +45,10 @@ const sema = new Sema(10);
 const mtime = new Date(1540000000000);
 
 export async function createLambda({
-  files, handler, runtime, environment = {},
+  files,
+  handler,
+  runtime,
+  environment = {},
 }: CreateLambdaOptions): Promise<Lambda> {
   assert(typeof files === 'object', '"files" must be an object');
   assert(typeof handler === 'string', '"handler" is not a string');
@@ -97,7 +98,9 @@ export async function createZip(files: Files): Promise<Buffer> {
     }
 
     zipFile.end();
-    streamToBuffer(zipFile.outputStream).then(resolve).catch(reject);
+    streamToBuffer(zipFile.outputStream)
+      .then(resolve)
+      .catch(reject);
   });
 
   return zipBuffer;

packages/now-build-utils/src/should-serve.ts

@@ -5,7 +5,7 @@ import FileFsRef from './file-fs-ref';
 export default function shouldServe({
   entrypoint,
   files,
-  requestPath
+  requestPath,
 }: ShouldServeOptions): boolean {
   requestPath = requestPath.replace(/\/$/, ''); // sanitize trailing '/'
   entrypoint = entrypoint.replace(/\\/, '/'); // windows compatibility
@@ -23,5 +23,5 @@ export default function shouldServe({
 }
 
 function hasProp(obj: { [path: string]: FileFsRef }, key: string): boolean {
-  return Object.hasOwnProperty.call(obj, key)
+  return Object.hasOwnProperty.call(obj, key);
 }

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

@@ -15,12 +15,38 @@ export interface Files {
   [filePath: string]: File;
 }
 
+export interface Route {
+  src?: string;
+  dest?: string;
+  handle?: string;
+  type?: string;
+  headers?: {
+    [key: string]: string;
+  };
+}
+
 export interface Config {
-  [key: string]: string;
+  [key: string]:
+    | string
+    | string[]
+    | boolean
+    | number
+    | { [key: string]: string }
+    | undefined;
+  maxLambdaSize?: string;
+  includeFiles?: string | string[];
+  bundle?: boolean;
+  ldsflags?: string;
+  helpers?: boolean;
+  rust?: string;
+  debug?: boolean;
+  zeroConfig?: boolean;
+  import?: { [key: string]: string };
 }
 
 export interface Meta {
   isDev?: boolean;
+  skipDownload?: boolean;
   requestPath?: string;
   filesChanged?: string[];
   filesRemoved?: string[];
@@ -155,3 +181,34 @@ export interface ShouldServeOptions {
    */
   config: Config;
 }
+
+export interface PackageJson {
+  name: string;
+  version: string;
+  engines?: {
+    [key: string]: string;
+    node: string;
+    npm: string;
+  };
+  scripts?: {
+    [key: string]: string;
+  };
+  dependencies?: {
+    [key: string]: string;
+  };
+  devDependencies?: {
+    [key: string]: string;
+  };
+}
+
+export interface NodeVersion {
+  major: number;
+  range: string;
+  runtime: string;
+}
+
+export interface Builder {
+  use: string;
+  src: string;
+  config?: Config;
+}

packages/now-build-utils/test/fixtures/07-cross-install/now.json

@@ -1,9 +1,10 @@
 {
   "version": 2,
-  "builds": [
-    { "src": "api/index.js", "use": "@now/node" }
-  ],
+  "builds": [{ "src": "api/index.js", "use": "@now/node" }],
   "probes": [
-    { "path": "/api/index.js", "mustContain": "cross-cow:RANDOMNESS_PLACEHOLDER" }
+    {
+      "path": "/api/index.js",
+      "mustContain": "cross-cow:RANDOMNESS_PLACEHOLDER"
+    }
   ]
 }

packages/now-build-utils/test/fixtures/15-yarn-ignore-engines/now.json

@@ -1,10 +1,11 @@
 {
-    "version": 2,
-    "builds": [
-      { "src": "index.js", "use": "@now/node", "config": { "maxLambdaSize": "15mb" } }
-    ],
-    "probes": [
-      { "path": "/", "mustContain": "found:RANDOMNESS_PLACEHOLDER" }
-    ]
-  }
-  
+  "version": 2,
+  "builds": [
+    {
+      "src": "index.js",
+      "use": "@now/node",
+      "config": { "maxLambdaSize": "18mb" }
+    }
+  ],
+  "probes": [{ "path": "/", "mustContain": "found:RANDOMNESS_PLACEHOLDER" }]
+}

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

@@ -6,12 +6,22 @@ const execa = require('execa');
 const assert = require('assert');
 const { glob, download } = require('../');
 const { createZip } = require('../dist/lambda');
+const {
+  getSupportedNodeVersion,
+  defaultSelection,
+} = require('../dist/fs/node-version');
 
 const {
   packAndDeploy,
   testDeployment,
 } = require('../../../test/lib/deployment/test-deployment.js');
 
+const {
+  detectBuilder,
+  detectApiBuilders,
+  detectApiRoutes,
+} = require('../dist');
+
 jest.setTimeout(4 * 60 * 1000);
 const builderUrl = '@canary';
 let buildUtilsUrl;
@@ -64,6 +74,52 @@ it('should create zip files with symlinks properly', async () => {
   assert(aStat.isFile());
 });
 
+it('should only match supported node versions', () => {
+  expect(getSupportedNodeVersion('10.x')).resolves.toHaveProperty('major', 10);
+  expect(getSupportedNodeVersion('8.10.x')).resolves.toHaveProperty('major', 8);
+  expect(getSupportedNodeVersion('8.11.x')).rejects.toThrow();
+  expect(getSupportedNodeVersion('6.x')).rejects.toThrow();
+  expect(getSupportedNodeVersion('999.x')).rejects.toThrow();
+  expect(getSupportedNodeVersion('foo')).rejects.toThrow();
+  expect(getSupportedNodeVersion('')).resolves.toBe(defaultSelection);
+  expect(getSupportedNodeVersion(null)).resolves.toBe(defaultSelection);
+  expect(getSupportedNodeVersion(undefined)).resolves.toBe(defaultSelection);
+});
+
+it('should match all semver ranges', () => {
+  // See https://docs.npmjs.com/files/package.json#engines
+  expect(getSupportedNodeVersion('10.0.0')).resolves.toHaveProperty(
+    'major',
+    10,
+  );
+  expect(getSupportedNodeVersion('10.x')).resolves.toHaveProperty('major', 10);
+  expect(getSupportedNodeVersion('>=10')).resolves.toHaveProperty('major', 10);
+  expect(getSupportedNodeVersion('>=10.3.0')).resolves.toHaveProperty(
+    'major',
+    10,
+  );
+  expect(getSupportedNodeVersion('8.5.0 - 10.5.0')).resolves.toHaveProperty(
+    'major',
+    10,
+  );
+  expect(getSupportedNodeVersion('>=9.0.0')).resolves.toHaveProperty(
+    'major',
+    10,
+  );
+  expect(getSupportedNodeVersion('>=9.5.0 <=10.5.0')).resolves.toHaveProperty(
+    'major',
+    10,
+  );
+  expect(getSupportedNodeVersion('~10.5.0')).resolves.toHaveProperty(
+    'major',
+    10,
+  );
+  expect(getSupportedNodeVersion('^10.5.0')).resolves.toHaveProperty(
+    'major',
+    10,
+  );
+});
+
 // own fixtures
 
 const fixturesPath = path.resolve(__dirname, 'fixtures');
@@ -108,3 +164,84 @@ for (const builder of buildersToTestWith) {
     }
   }
 }
+
+it('Test `detectBuilder`', async () => {
+  {
+    const pkg = { dependencies: { next: '1.0.0' } };
+    const builder = await detectBuilder(pkg);
+    expect(builder.use).toBe('@now/next');
+  }
+
+  {
+    const pkg = { devDependencies: { next: '1.0.0' } };
+    const builder = await detectBuilder(pkg);
+    expect(builder.use).toBe('@now/next');
+  }
+
+  {
+    const pkg = {};
+    const builder = await detectBuilder(pkg);
+    expect(builder.use).toBe('@now/static-build');
+  }
+});
+
+it('Test `detectApiBuilders`', async () => {
+  {
+    const files = ['package.json', 'api/user.js', 'api/team.js'];
+
+    const builders = await detectApiBuilders(files);
+    expect(builders[0].use).toBe('@now/node');
+  }
+
+  {
+    const files = ['package.json', 'api/user.go', 'api/team.js'];
+
+    const builders = await detectApiBuilders(files);
+    expect(builders.some(({ use }) => use === '@now/go')).toBeTruthy();
+    expect(builders.some(({ use }) => use === '@now/node')).toBeTruthy();
+  }
+
+  {
+    const files = ['package.json'];
+
+    const builders = await detectApiBuilders(files);
+    expect(builders).toBe(null);
+  }
+});
+
+it('Test `detectApiRoutes`', async () => {
+  {
+    const files = ['api/user.go', 'api/team.js'];
+
+    const { defaultRoutes } = await detectApiRoutes(files);
+    expect(defaultRoutes.length).toBe(2);
+  }
+
+  {
+    const files = ['api/user.go', 'api/user.js'];
+
+    const { error } = await detectApiRoutes(files);
+    expect(error.code).toBe('conflicting_file_path');
+  }
+
+  {
+    const files = ['api/[user].go', 'api/[team]/[id].js'];
+
+    const { error } = await detectApiRoutes(files);
+    expect(error.code).toBe('conflicting_file_path');
+  }
+
+  {
+    const files = ['api/[team]/[team].js'];
+
+    const { error } = await detectApiRoutes(files);
+    expect(error.code).toBe('conflicting_path_segment');
+  }
+
+  {
+    const files = ['api/[endpoint].js', 'api/[endpoint]/[id].js'];
+
+    const { defaultRoutes } = await detectApiRoutes(files);
+    expect(defaultRoutes.length).toBe(2);
+  }
+});

packages/now-build-utils/tsconfig.json

@@ -15,10 +15,6 @@
     "strict": true,
     "target": "esnext"
   },
-  "include": [
-    "src/**/*"
-  ],
-  "exclude": [
-    "node_modules"
-  ]
+  "include": ["src/**/*"],
+  "exclude": ["node_modules"]
 }

packages/now-go/go-helpers.ts

@@ -23,7 +23,7 @@ const getGoUrl = (version: string, platform: string, arch: string) => {
   return `https://dl.google.com/go/go${version}.${goPlatform}-${goArch}.${ext}`;
 };
 
-export async function getAnalyzedEntrypoint(filePath: string) {
+export async function getAnalyzedEntrypoint(filePath: string, modulePath = '') {
   debug('Analyzing entrypoint %o', filePath);
   const bin = join(__dirname, 'analyze');
 
@@ -35,7 +35,8 @@ export async function getAnalyzedEntrypoint(filePath: string) {
     await go.build(src, dest);
   }
 
-  const args = [filePath];
+  const args = [`-modpath=${modulePath}`, filePath];
+
   const analyzed = await execa.stdout(bin, args);
   debug('Analyzed entrypoint %o', analyzed);
   return analyzed;
@@ -125,7 +126,15 @@ export async function downloadGo(
   // If we found GOPATH in ENV, or default `Go` path exists
   // asssume that user have `Go` installed
   if (isUserGo || process.env.GOPATH !== undefined) {
-    return createGo(dir, platform, arch);
+    const { stdout } = await execa('go', ['version']);
+
+    if (parseInt(stdout.split('.')[1]) >= 11) {
+      return createGo(dir, platform, arch);
+    }
+
+    throw new Error(
+      `Your current ${stdout} doesn't support Go Modules. Please update.`
+    );
   } else {
     // Check `Go` bin in builder CWD
     const isGoExist = await pathExists(join(dir, 'bin'));

packages/now-go/index.ts

@@ -1,5 +1,7 @@
-import { join, sep, dirname } from 'path';
+import { join, sep, dirname, basename } from 'path';
 import { readFile, writeFile, pathExists, move } from 'fs-extra';
+import { homedir } from 'os';
+import execa from 'execa';
 
 import {
   glob,
@@ -29,6 +31,18 @@ interface BuildParamsType extends BuildOptions {
   meta: BuildParamsMeta;
 }
 
+// Initialize private git repo for Go Modules
+async function initPrivateGit(credentials: string) {
+  await execa('git', [
+    'config',
+    '--global',
+    'credential.helper',
+    `store --file ${join(homedir(), '.git-credentials')}`,
+  ]);
+
+  await writeFile(join(homedir(), '.git-credentials'), credentials);
+}
+
 export const version = 2;
 
 export const config = {
@@ -39,8 +53,26 @@ export async function build({
   files,
   entrypoint,
   config,
+  workPath,
   meta = {} as BuildParamsMeta,
 }: BuildParamsType) {
+  if (process.env.GIT_CREDENTIALS && !meta.isDev) {
+    console.log('Initialize Git credentials...');
+    await initPrivateGit(process.env.GIT_CREDENTIALS);
+  }
+
+  if (process.env.GO111MODULE) {
+    console.log(`\nManually assigning 'GO111MODULE' is not recommended.
+
+By default:
+  - 'GO111MODULE=on' If entrypoint package name is not 'main'
+  - 'GO111MODULE=off' If entrypoint package name is 'main'
+
+We highly recommend you leverage Go Modules in your project.
+Learn more: https://github.com/golang/go/wiki/Modules
+`);
+  }
+
   console.log('Downloading user files...');
   const entrypointArr = entrypoint.split(sep);
 
@@ -49,32 +81,27 @@ export async function build({
     getWriteableDirectory(),
   ]);
 
-  if (meta.isDev) {
-    const devGoPath = `dev${entrypointArr[entrypointArr.length - 1]}`;
-    const goPathArr = goPath.split(sep);
-    goPathArr.pop();
-    goPathArr.push(devGoPath);
-    goPath = goPathArr.join(sep);
-  }
-
   const srcPath = join(goPath, 'src', 'lambda');
-  const downloadedFiles = await download(files, srcPath);
-  const input = dirname(downloadedFiles[entrypoint].fsPath);
-  var includedFiles: Files = {};
-
-  if (config && config.includeFiles) {
-    for (const pattern of config.includeFiles) {
-      const files = await glob(pattern, input);
-      for (const assetName of Object.keys(files)) {
-        includedFiles[assetName] = files[assetName];
-      }
-    }
+  let downloadedFiles;
+  if (meta.isDev) {
+    downloadedFiles = await download(files, workPath, meta);
+  } else {
+    downloadedFiles = await download(files, srcPath);
   }
 
   console.log(`Parsing AST for "${entrypoint}"`);
   let analyzed: string;
   try {
-    analyzed = await getAnalyzedEntrypoint(downloadedFiles[entrypoint].fsPath);
+    let goModAbsPathDir = '';
+    for (const file of Object.keys(downloadedFiles)) {
+      if (file === 'go.mod') {
+        goModAbsPathDir = dirname(downloadedFiles[file].fsPath);
+      }
+    }
+    analyzed = await getAnalyzedEntrypoint(
+      downloadedFiles[entrypoint].fsPath,
+      goModAbsPathDir
+    );
   } catch (err) {
     console.log(`Failed to parse AST for "${entrypoint}"`);
     throw err;
@@ -92,18 +119,72 @@ Learn more: https://zeit.co/docs/v2/deployments/official-builders/go-now-go/#ent
 
   const parsedAnalyzed = JSON.parse(analyzed) as Analyzed;
 
+  if (meta.isDev) {
+    const base = dirname(downloadedFiles['now.json'].fsPath);
+    const destNow = join(
+      base,
+      '.now',
+      'cache',
+      basename(entrypoint, '.go'),
+      'src',
+      'lambda'
+    );
+    // this will ensure Go rebuilt fast
+    goPath = join(base, '.now', 'cache', basename(entrypoint, '.go'));
+    await download(downloadedFiles, destNow);
+
+    downloadedFiles = await glob('**', destNow);
+  }
+
+  // find `go.mod` in downloadedFiles
+  const entrypointDirname = dirname(downloadedFiles[entrypoint].fsPath);
+  let isGoModExist = false;
+  let goModPath = '';
+  let isGoModInRootDir = false;
+  for (const file of Object.keys(downloadedFiles)) {
+    const fileDirname = dirname(downloadedFiles[file].fsPath);
+    if (file === 'go.mod') {
+      isGoModExist = true;
+      isGoModInRootDir = true;
+      goModPath = fileDirname;
+    } else if (file.endsWith('go.mod') && !file.endsWith('vendor')) {
+      if (entrypointDirname === fileDirname) {
+        isGoModExist = true;
+        goModPath = fileDirname;
+        break;
+      }
+    }
+  }
+
+  const input = entrypointDirname;
+  var includedFiles: Files = {};
+
+  if (config && config.includeFiles) {
+    for (const pattern of config.includeFiles) {
+      const files = await glob(pattern, input);
+      for (const assetName of Object.keys(files)) {
+        includedFiles[assetName] = files[assetName];
+      }
+    }
+  }
+
   const handlerFunctionName = parsedAnalyzed.functionName;
   console.log(
     `Found exported function "${handlerFunctionName}" in "${entrypoint}"`
   );
 
-  // we need `main.go` in the same dir as the entrypoint,
-  // otherwise `go build` will refuse to build
-  const entrypointDirname = dirname(downloadedFiles[entrypoint].fsPath);
+  if (!isGoModExist && 'vendor' in downloadedFiles) {
+    throw new Error('`go.mod` is required to use a `vendor` directory.');
+  }
 
   // check if package name other than main
+  // using `go.mod` way building the handler
   const packageName = parsedAnalyzed.packageName;
-  const isGoModExist = await pathExists(join(entrypointDirname, 'go.mod'));
+
+  if (isGoModExist && packageName === 'main') {
+    throw new Error('Please change `package main` to `package handler`');
+  }
+
   if (packageName !== 'main') {
     const go = await createGo(
       goPath,
@@ -135,23 +216,39 @@ Learn more: https://zeit.co/docs/v2/deployments/official-builders/go-now-go/#ent
     const goFuncName = `${packageName}.${handlerFunctionName}`;
 
     if (isGoModExist) {
-      const goModContents = await readFile(
-        join(entrypointDirname, 'go.mod'),
-        'utf8'
-      );
+      const goModContents = await readFile(join(goModPath, 'go.mod'), 'utf8');
       const usrModName = goModContents.split('\n')[0].split(' ')[1];
-      goPackageName = `${usrModName}/${packageName}`;
+
+      if (entrypointArr.length > 1 && isGoModInRootDir) {
+        let cleanPackagePath = [...entrypointArr];
+        cleanPackagePath.pop();
+        goPackageName = `${usrModName}/${cleanPackagePath.join('/')}`;
+      } else {
+        goPackageName = `${usrModName}/${packageName}`;
+      }
     }
 
     const mainModGoContents = modMainGoContents
       .replace('__NOW_HANDLER_PACKAGE_NAME', goPackageName)
       .replace('__NOW_HANDLER_FUNC_NAME', goFuncName);
 
-    // write main__mod__.go
-    await writeFile(
-      join(entrypointDirname, mainModGoFileName),
-      mainModGoContents
-    );
+    if (meta.isDev && isGoModExist && isGoModInRootDir) {
+      await writeFile(
+        join(dirname(downloadedFiles['now.json'].fsPath), mainModGoFileName),
+        mainModGoContents
+      );
+    } else if (isGoModExist && isGoModInRootDir) {
+      await writeFile(join(srcPath, mainModGoFileName), mainModGoContents);
+    } else if (isGoModExist && !isGoModInRootDir) {
+      // using `go.mod` path to write main__mod__.go
+      await writeFile(join(goModPath, mainModGoFileName), mainModGoContents);
+    } else {
+      // using `entrypointDirname` to write main__mod__.go
+      await writeFile(
+        join(entrypointDirname, mainModGoFileName),
+        mainModGoContents
+      );
+    }
 
     // move user go file to folder
     try {
@@ -172,25 +269,41 @@ Learn more: https://zeit.co/docs/v2/deployments/official-builders/go-now-go/#ent
         );
       }
 
-      await move(downloadedFiles[entrypoint].fsPath, finalDestination, {
-        overwrite: forceMove,
-      });
+      if (
+        dirname(downloadedFiles[entrypoint].fsPath) === goModPath ||
+        !isGoModExist
+      ) {
+        await move(downloadedFiles[entrypoint].fsPath, finalDestination, {
+          overwrite: forceMove,
+        });
+      }
     } catch (err) {
       console.log('failed to move entry to package folder');
       throw err;
     }
 
+    let baseGoModPath = '';
+    if (meta.isDev && isGoModExist && isGoModInRootDir) {
+      baseGoModPath = dirname(downloadedFiles['now.json'].fsPath);
+    } else if (isGoModExist && isGoModInRootDir) {
+      baseGoModPath = srcPath;
+    } else if (isGoModExist && !isGoModInRootDir) {
+      baseGoModPath = goModPath;
+    } else {
+      baseGoModPath = entrypointDirname;
+    }
+
     if (meta.isDev) {
-      const isGoModBk = await pathExists(join(entrypointDirname, 'go.mod.bk'));
+      const isGoModBk = await pathExists(join(baseGoModPath, 'go.mod.bk'));
       if (isGoModBk) {
         await move(
-          join(entrypointDirname, 'go.mod.bk'),
-          join(entrypointDirname, 'go.mod'),
+          join(baseGoModPath, 'go.mod.bk'),
+          join(baseGoModPath, 'go.mod'),
           { overwrite: true }
         );
         await move(
-          join(entrypointDirname, 'go.sum.bk'),
-          join(entrypointDirname, 'go.sum'),
+          join(baseGoModPath, 'go.sum.bk'),
+          join(baseGoModPath, 'go.sum'),
           { overwrite: true }
         );
       }
@@ -207,8 +320,10 @@ Learn more: https://zeit.co/docs/v2/deployments/official-builders/go-now-go/#ent
 
     console.log('Running `go build`...');
     const destPath = join(outDir, 'handler');
+
     try {
-      const src = [join(entrypointDirname, mainModGoFileName)];
+      let src = [join(baseGoModPath, mainModGoFileName)];
+
       await go.build(src, destPath, config.ldsflags);
     } catch (err) {
       console.log('failed to `go build`');
@@ -217,17 +332,20 @@ Learn more: https://zeit.co/docs/v2/deployments/official-builders/go-now-go/#ent
     if (meta.isDev) {
       // caching for `now dev`
       await move(
-        join(entrypointDirname, 'go.mod'),
-        join(entrypointDirname, 'go.mod.bk'),
+        join(baseGoModPath, 'go.mod'),
+        join(baseGoModPath, 'go.mod.bk'),
         { overwrite: true }
       );
       await move(
-        join(entrypointDirname, 'go.sum'),
-        join(entrypointDirname, 'go.sum.bk'),
+        join(baseGoModPath, 'go.sum'),
+        join(baseGoModPath, 'go.sum.bk'),
         { overwrite: true }
       );
     }
   } else {
+    // legacy mode
+    // we need `main.go` in the same dir as the entrypoint,
+    // otherwise `go build` will refuse to build
     const go = await createGo(
       goPath,
       process.platform,
@@ -289,16 +407,17 @@ Learn more: https://zeit.co/docs/v2/deployments/official-builders/go-now-go/#ent
   };
 
   let watch = parsedAnalyzed.watch;
+  let watchSub: string[] = [];
   // if `entrypoint` located in subdirectory
   // we will need to concat it with return watch array
   if (entrypointArr.length > 1) {
     entrypointArr.pop();
-    watch = parsedAnalyzed.watch.map(file => join(...entrypointArr, file));
+    watchSub = parsedAnalyzed.watch.map(file => join(...entrypointArr, file));
   }
 
   return {
     output,
-    watch,
+    watch: watch.concat(watchSub),
   };
 }
 

packages/now-go/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@now/go",
-  "version": "0.4.6",
+  "version": "0.5.4",
   "license": "MIT",
+  "homepage": "https://zeit.co/docs/v2/deployments/official-builders/go-now-go",
   "repository": {
     "type": "git",
     "url": "https://github.com/zeit/now-builders.git",
@@ -31,6 +32,6 @@
     "@types/fs-extra": "^5.0.5",
     "@types/node-fetch": "^2.3.0",
     "@types/tar": "^4.0.0",
-    "typescript": "^3.4.2"
+    "typescript": "3.5.2"
   }
 }

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

@@ -8,4 +8,4 @@
     { "path": "/", "mustContain": "cow:RANDOMNESS_PLACEHOLDER" },
     { "path": "/subdirectory", "mustContain": "subcow:RANDOMNESS_PLACEHOLDER" }
   ]
-}
+}

packages/now-go/test/fixtures/03-env-vars/now.json

@@ -15,4 +15,4 @@
       "mustContain": "RANDOMNESS_PLACEHOLDER"
     }
   ]
-}
+}

packages/now-go/test/fixtures/06-content-type/now.json

@@ -1,6 +1,4 @@
 {
   "version": 2,
-  "builds": [
-    { "src": "index.go", "use": "@now/go" }
-  ]
-}
+  "builds": [{ "src": "index.go", "use": "@now/go" }]
+}

packages/now-go/test/fixtures/07-content-length/now.json

@@ -1,9 +1,7 @@
 {
   "version": 2,
-  "builds": [
-    { "src": "*.go", "use": "@now/go" }
-  ],
+  "builds": [{ "src": "*.go", "use": "@now/go" }],
   "env": {
     "RANDOMNESS_ENV_VAR": "RANDOMNESS_PLACEHOLDER"
   }
-}
+}

packages/now-go/test/fixtures/08-include-files/now.json

@@ -5,9 +5,7 @@
       "src": "index.go",
       "use": "@now/go",
       "config": {
-        "includeFiles": [
-          "templates/**"
-        ]
+        "includeFiles": ["templates/**"]
       }
     }
   ],

packages/now-go/test/fixtures/09-exported-function/now.json

@@ -1,9 +1,5 @@
 {
   "version": 2,
-  "builds": [
-    { "src": "index.go", "use": "@now/go" }
-  ],
-  "probes": [
-    { "path": "/", "mustContain": "RANDOMNESS_PLACEHOLDER" }
-  ]
+  "builds": [{ "src": "index.go", "use": "@now/go" }],
+  "probes": [{ "path": "/", "mustContain": "RANDOMNESS_PLACEHOLDER" }]
 }

packages/now-go/test/fixtures/10-go-mod/go.mod

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

packages/now-go/test/fixtures/10-go-mod/index.go

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

packages/now-go/test/fixtures/10-go-mod/now.json

@@ -0,0 +1,5 @@
+{
+  "version": 2,
+  "builds": [{ "src": "index.go", "use": "@now/go" }],
+  "probes": [{ "path": "/", "mustContain": "RANDOMNESS_PLACEHOLDER" }]
+}

packages/now-go/test/fixtures/11-go-mod-shared/api/index.go

@@ -0,0 +1,12 @@
+package api
+
+import (
+	"fmt"
+	"net/http"
+	"with-shared/shared"
+)
+
+// Handler func
+func Handler(w http.ResponseWriter, r *http.Request) {
+	fmt.Fprintf(w, shared.Say("RANDOMNESS_PLACEHOLDER"))
+}

packages/now-go/test/fixtures/11-go-mod-shared/go.mod

@@ -0,0 +1,3 @@
+module with-shared
+
+go 1.12

packages/now-go/test/fixtures/11-go-mod-shared/now.json

@@ -0,0 +1,5 @@
+{
+  "version": 2,
+  "builds": [{ "src": "api/*.go", "use": "@now/go" }],
+  "probes": [{ "path": "/api", "mustContain": "RANDOMNESS_PLACEHOLDER" }]
+}

packages/now-go/test/fixtures/11-go-mod-shared/shared/shared.go

@@ -0,0 +1,6 @@
+package shared
+
+// Say func
+func Say(text string) string {
+	return text
+}

packages/now-go/test/fixtures/12-go-mod-subs/now.json

@@ -0,0 +1,8 @@
+{
+  "version": 2,
+  "builds": [{ "src": "**/*.go", "use": "@now/go" }],
+  "probes": [
+    { "path": "/sub-1", "mustContain": "RANDOMNESS_PLACEHOLDER" },
+    { "path": "/sub-2", "mustContain": "RANDOMNESS_PLACEHOLDER" }
+  ]
+}

packages/now-go/test/fixtures/12-go-mod-subs/sub-1/go.mod

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

packages/now-go/test/fixtures/12-go-mod-subs/sub-1/index.go

@@ -0,0 +1,11 @@
+package sub1
+
+import (
+	"fmt"
+	"net/http"
+)
+
+// Handler func
+func Handler(w http.ResponseWriter, r *http.Request) {
+	fmt.Fprintf(w, "RANDOMNESS_PLACEHOLDER")
+}

packages/now-go/test/fixtures/12-go-mod-subs/sub-2/go.mod

@@ -0,0 +1,3 @@
+module sub-2
+
+go 1.12

packages/now-go/test/fixtures/12-go-mod-subs/sub-2/index.go

@@ -0,0 +1,11 @@
+package sub2
+
+import (
+	"fmt"
+	"net/http"
+)
+
+// Handler func
+func Handler(w http.ResponseWriter, r *http.Request) {
+	fmt.Fprintf(w, "RANDOMNESS_PLACEHOLDER")
+}

packages/now-go/test/fixtures/13-go-mod-nested/api/nested/index.go

@@ -0,0 +1,12 @@
+package nested
+
+import (
+	"fmt"
+	"net/http"
+	"with-nested/shared"
+)
+
+// Handler func
+func Handler(w http.ResponseWriter, r *http.Request) {
+	fmt.Fprintf(w, shared.Say("lol:RANDOMNESS_PLACEHOLDER"))
+}

packages/now-go/test/fixtures/13-go-mod-nested/go.mod

@@ -0,0 +1,3 @@
+module with-nested
+
+go 1.12

packages/now-go/test/fixtures/13-go-mod-nested/now.json

@@ -0,0 +1,5 @@
+{
+  "version": 2,
+  "builds": [{ "src": "api/nested/*.go", "use": "@now/go" }],
+  "probes": [{ "path": "/api/nested", "mustContain": "RANDOMNESS_PLACEHOLDER" }]
+}

packages/now-go/test/fixtures/13-go-mod-nested/shared/shared.go

@@ -0,0 +1,6 @@
+package shared
+
+// Say func
+func Say(text string) string {
+	return text
+}

packages/now-go/test/fixtures/14-go-mod-sub/api/index.go

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

packages/now-go/test/fixtures/14-go-mod-sub/now.json

@@ -0,0 +1,5 @@
+{
+  "version": 2,
+  "builds": [{ "src": "api/**/*.go", "use": "@now/go" }],
+  "probes": [{ "path": "/api", "mustContain": "RANDOMNESS_PLACEHOLDER" }]
+}

packages/now-go/test/fixtures/14-go-mod-sub/other-folder/go.mod

@@ -0,0 +1,3 @@
+module other-folder
+
+go 1.12

packages/now-go/test/fixtures/14-go-mod-sub/other-folder/index.go

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

packages/now-go/test/test.js

@@ -26,8 +26,8 @@ for (const fixture of fs.readdirSync(fixturesPath)) {
     await expect(
       testDeployment(
         { builderUrl, buildUtilsUrl },
-        path.join(fixturesPath, fixture),
-      ),
+        path.join(fixturesPath, fixture)
+      )
     ).resolves.toBeDefined();
   });
 }

packages/now-go/util/analyze.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"encoding/json"
+	"flag"
 	"fmt"
 	"go/ast"
 	"go/parser"
@@ -10,9 +11,22 @@ import (
 	"log"
 	"os"
 	"path/filepath"
+	"regexp"
 	"strings"
 )
 
+var ignoredFoldersRegex []*regexp.Regexp
+
+func init() {
+	ignoredFolders := []string{"vendor", "testdata", ".now"}
+
+	// Build the regex that matches if a path contains the respective ignored folder
+	// The pattern will look like: (.*/)?vendor/.*, which matches every path that contains a vendor folder
+	for _, folder := range ignoredFolders {
+		ignoredFoldersRegex = append(ignoredFoldersRegex, regexp.MustCompile("(.*/)?"+folder+"/.*"))
+	}
+}
+
 type analyze struct {
 	PackageName string   `json:"packageName"`
 	FuncName    string   `json:"functionName"`
@@ -40,8 +54,9 @@ func visit(files *[]string) filepath.WalkFunc {
 		}
 
 		// we don't need Dirs, or test files
-		// we only want `.go` files
-		if info.IsDir() || itf || filepath.Ext(path) != ".go" {
+		// we only want `.go` files. Further, we ignore
+		// every file that is in one of the ignored folders.
+		if info.IsDir() || itf || filepath.Ext(path) != ".go" || isInIgnoredFolder(path) {
 			return nil
 		}
 
@@ -50,6 +65,19 @@ func visit(files *[]string) filepath.WalkFunc {
 	}
 }
 
+// isInIgnoredFolder checks if the given path is in one of the ignored folders.
+func isInIgnoredFolder(path string) bool {
+	// Make sure the regex works for Windows paths
+	path = filepath.ToSlash(path)
+
+	for _, pattern := range ignoredFoldersRegex {
+		if pattern.MatchString(path) {
+			return true
+		}
+	}
+	return false
+}
+
 // return unique file
 func unique(files []string) []string {
 	encountered := map[string]bool{}
@@ -65,13 +93,13 @@ func unique(files []string) []string {
 }
 
 func main() {
-	if len(os.Args) != 2 {
+	if len(os.Args) != 3 {
 		// Args should have the program name on `0`
 		// and the file name on `1`
-		fmt.Println("Wrong number of args; Usage is:\n  ./go-analyze file_name.go")
+		fmt.Println("Wrong number of args; Usage is:\n  ./go-analyze -modpath=module-path file_name.go")
 		os.Exit(1)
 	}
-	fileName := os.Args[1]
+	fileName := os.Args[2]
 	rf, err := ioutil.ReadFile(fileName)
 	if err != nil {
 		log.Fatal(err)
@@ -95,6 +123,17 @@ func main() {
 		log.Fatal(err)
 	}
 
+	// looking related packages
+	var modPath string
+	flag.StringVar(&modPath, "modpath", "", "module path")
+	flag.Parse()
+	if len(modPath) > 1 {
+		err = filepath.Walk(modPath, visit(&files))
+		if err != nil {
+			log.Fatal(err)
+		}
+	}
+
 	for _, file := range files {
 		absFileName, _ := filepath.Abs(fileName)
 		absFile, _ := filepath.Abs(file)
@@ -127,7 +166,14 @@ func main() {
 			for _, ed := range exportedDecl {
 				if strings.Contains(se, ed) {
 					// find relative path of related file
-					rel, err := filepath.Rel(filepath.Dir(fileName), file)
+					var basePath string
+					if modPath == "" {
+						basePath = filepath.Dir(fileName)
+					} else {
+						basePath = modPath
+					}
+
+					rel, err := filepath.Rel(basePath, file)
 					if err != nil {
 						log.Fatal(err)
 					}

packages/now-html-minifier/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@now/html-minifier",
-  "version": "1.1.3",
+  "version": "1.1.4",
   "license": "MIT",
+  "homepage": "https://zeit.co/docs/v2/deployments/official-builders/html-minifier-now-html-minifier",
   "repository": {
     "type": "git",
     "url": "https://github.com/zeit/now-builders.git",

packages/now-lambda/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@now/lambda",
-  "version": "0.5.3",
+  "version": "0.5.4",
   "license": "MIT",
   "repository": {
     "type": "git",

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

@@ -1,11 +1,22 @@
 {
   "version": 2,
   "builds": [
-    { "src": "index.zip", "use": "@now/lambda", "config": { "handler": "index.handler", "runtime": "nodejs8.10" } },
-    { "src": "subdirectory/index.zip", "use": "@now/lambda", "config": { "handler": "index.handler", "runtime": "nodejs8.10" } }
+    {
+      "src": "index.zip",
+      "use": "@now/lambda",
+      "config": { "handler": "index.handler", "runtime": "nodejs8.10" }
+    },
+    {
+      "src": "subdirectory/index.zip",
+      "use": "@now/lambda",
+      "config": { "handler": "index.handler", "runtime": "nodejs8.10" }
+    }
   ],
   "probes": [
     { "path": "/", "mustContain": "cow:NO_REPLACE_TO_AVOID_CRC_MISMATCH" },
-    { "path": "/subdirectory/", "mustContain": "yoda:NO_REPLACE_TO_AVOID_CRC_MISMATCH" }
+    {
+      "path": "/subdirectory/",
+      "mustContain": "yoda:NO_REPLACE_TO_AVOID_CRC_MISMATCH"
+    }
   ]
 }

packages/now-md/index.js

@@ -39,4 +39,7 @@ exports.build = async ({ files, entrypoint, config }) => {
   return { [replacedEntrypoint]: result };
 };
 
-exports.shouldServe = shouldServe;
+exports.shouldServe = (options) => {
+  const requestPath = options.requestPath.replace(/\.html$/, '.md');
+  return shouldServe({ ...options, requestPath });
+};

packages/now-md/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@now/md",
-  "version": "0.5.3",
+  "version": "0.5.5",
   "license": "MIT",
+  "homepage": "https://zeit.co/docs/v2/deployments/official-builders/markdown-now-md",
   "repository": {
     "type": "git",
     "url": "https://github.com/zeit/now-builders.git",

packages/now-mdx-deck/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@now/mdx-deck",
-  "version": "0.5.4",
+  "version": "0.5.5",
   "license": "MIT",
+  "homepage": "https://zeit.co/docs/v2/deployments/official-builders/mdx-deck-now-mdx-deck",
   "repository": {
     "type": "git",
     "url": "https://github.com/zeit/now-builders.git",

packages/now-next/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@now/next",
-  "version": "0.3.2",
+  "version": "0.5.3",
   "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",
@@ -14,7 +15,7 @@
     "directory": "packages/now-next"
   },
   "dependencies": {
-    "@now/node-bridge": "^1.1.2",
+    "@now/node-bridge": "1.2.2",
     "fs-extra": "^7.0.0",
     "get-port": "^5.0.0",
     "resolve-from": "^5.0.0",
@@ -28,6 +29,6 @@
     "@types/resolve-from": "^5.0.1",
     "@types/semver": "^6.0.0",
     "jest": "^24.7.1",
-    "typescript": "^3.4.3"
+    "typescript": "3.5.2"
   }
 }

packages/now-next/src/index.ts

@@ -21,6 +21,8 @@ import {
   PrepareCacheOptions,
   runNpmInstall,
   runPackageJsonScript,
+  getNodeVersion,
+  getSpawnOptions,
 } from '@now/build-utils';
 
 import nextLegacyVersions from './legacy-versions';
@@ -36,6 +38,9 @@ import {
   stringMap,
   syncEnvVars,
   validateEntrypoint,
+  normalizePage,
+  getDynamicRoutes,
+  isDynamicRoute,
 } from './utils';
 
 interface BuildParamsMeta {
@@ -155,21 +160,25 @@ export const build = async ({
   entrypoint,
   meta = {} as BuildParamsMeta,
 }: BuildParamsType): Promise<{
-  routes?: any[];
+  routes?: ({ src?: string; dest?: string } | { handle: string })[];
   output: Files;
   watch?: string[];
   childProcesses: ChildProcess[];
 }> => {
+  process.env.__NEXT_BUILDER_EXPERIMENTAL_TARGET = 'serverless';
+
   validateEntrypoint(entrypoint);
 
-  const routes: any[] = [];
   const entryDirectory = path.dirname(entrypoint);
   const entryPath = path.join(workPath, entryDirectory);
-  const dotNext = path.join(entryPath, '.next');
+  const dotNextStatic = path.join(entryPath, '.next/static');
 
   console.log(`${name} Downloading user files...`);
   await download(files, workPath, meta);
 
+  const nodeVersion = await getNodeVersion(entryPath);
+  const spawnOpts = getSpawnOptions(meta, nodeVersion);
+
   const pkg = await readPackageJson(entryPath);
   const nextVersion = getNextVersion(pkg);
 
@@ -179,17 +188,17 @@ export const build = async ({
     );
   }
 
-  process.env.__NEXT_BUILDER_EXPERIMENTAL_TARGET = 'serverless';
-
   if (meta.isDev) {
-    // eslint-disable-next-line no-underscore-dangle
-    process.env.__NEXT_BUILDER_EXPERIMENTAL_DEBUG = 'true';
     let childProcess: ChildProcess | undefined;
 
     // If this is the initial build, we want to start the server
     if (!urls[entrypoint]) {
       console.log(`${name} Installing dependencies...`);
-      await runNpmInstall(entryPath, ['--prefer-offline']);
+      await runNpmInstall(entryPath, ['--prefer-offline'], spawnOpts);
+
+      if (!process.env.NODE_ENV) {
+        process.env.NODE_ENV = 'development';
+      }
 
       // The runtime env vars consist of the base `process.env` vars, but with the
       // build env vars removed, and the runtime env vars mixed in afterwards
@@ -210,13 +219,19 @@ export const build = async ({
 
     return {
       output: {},
-      routes: getRoutes(entryDirectory, pathsInside, files, urls[entrypoint]),
+      routes: getRoutes(
+        entryPath,
+        entryDirectory,
+        pathsInside,
+        files,
+        urls[entrypoint]
+      ),
       watch: pathsInside,
       childProcesses: childProcess ? [childProcess] : [],
     };
   }
 
-  if (await pathExists(dotNext)) {
+  if (await pathExists(dotNextStatic)) {
     console.warn(
       'WARNING: You should not upload the `.next` directory. See https://zeit.co/docs/v2/deployments/official-builders/next-js-now-next/ for more details.'
     );
@@ -248,14 +263,15 @@ export const build = async ({
     console.log('normalized package.json result: ', packageJson);
     await writePackageJson(entryPath, packageJson);
   } else if (!pkg.scripts || !pkg.scripts['now-build']) {
-    console.warn(
-      'WARNING: "now-build" script not found. Adding \'"now-build": "next build"\' to "package.json" automatically'
+    console.log(
+      'Your application is being built using `next build`. ' +
+        'If you need to define a different build step, please create a `now-build` script in your `package.json` ' +
+        '(e.g. `{ "scripts": { "now-build": "npm run prepare && next build" } }`).'
     );
     pkg.scripts = {
       'now-build': 'next build',
       ...(pkg.scripts || {}),
     };
-    console.log('normalized package.json result: ', pkg);
     await writePackageJson(entryPath, pkg);
   }
 
@@ -265,27 +281,31 @@ export const build = async ({
   }
 
   console.log('installing dependencies...');
-  await runNpmInstall(entryPath, ['--prefer-offline']);
+  await runNpmInstall(entryPath, ['--prefer-offline'], spawnOpts);
 
   console.log('running user script...');
   const memoryToConsume = Math.floor(os.totalmem() / 1024 ** 2) - 128;
-  await runPackageJsonScript(entryPath, 'now-build', {
-    env: {
-      ...process.env,
-      NODE_OPTIONS: `--max_old_space_size=${memoryToConsume}`,
-    },
-  } as SpawnOptions);
+  const env = { ...spawnOpts.env } as any;
+  env.NODE_OPTIONS = `--max_old_space_size=${memoryToConsume}`;
+  await runPackageJsonScript(entryPath, 'now-build', { ...spawnOpts, env });
 
   if (isLegacy) {
     console.log('running npm install --production...');
-    await runNpmInstall(entryPath, ['--prefer-offline', '--production']);
+    await runNpmInstall(
+      entryPath,
+      ['--prefer-offline', '--production'],
+      spawnOpts
+    );
   }
 
   if (process.env.NPM_AUTH_TOKEN) {
     await unlinkFile(path.join(entryPath, '.npmrc'));
   }
 
+  const exportedPageRoutes: { src: string; dest: string }[] = [];
   const lambdas: { [key: string]: Lambda } = {};
+  const staticPages: { [key: string]: FileFsRef } = {};
+  const dynamicPages: string[] = [];
 
   if (isLegacy) {
     const filesAfterBuild = await glob('**', entryPath);
@@ -310,7 +330,9 @@ export const build = async ({
       file => file.startsWith('node_modules/.cache')
     );
     const launcherFiles = {
-      'now__bridge.js': new FileFsRef({ fsPath: require('@now/node-bridge') }),
+      'now__bridge.js': new FileFsRef({
+        fsPath: require('@now/node-bridge'),
+      }),
     };
     const nextFiles: { [key: string]: FileFsRef } = {
       ...nodeModules,
@@ -364,7 +386,7 @@ export const build = async ({
             'now__launcher.js': new FileBlob({ data: launcher }),
           },
           handler: 'now__launcher.launcher',
-          runtime: 'nodejs8.10',
+          runtime: nodeVersion.runtime,
         });
         console.log(`Created lambda for page: "${page}"`);
       })
@@ -372,15 +394,33 @@ export const build = async ({
   } else {
     console.log('preparing lambda files...');
     const launcherFiles = {
-      'now__bridge.js': new FileFsRef({ fsPath: require('@now/node-bridge') }),
+      'now__bridge.js': new FileFsRef({
+        fsPath: require('@now/node-bridge'),
+      }),
       'now__launcher.js': new FileFsRef({
         fsPath: path.join(__dirname, 'launcher.js'),
       }),
     };
-    const pages = await glob(
-      '**/*.js',
-      path.join(entryPath, '.next', 'serverless', 'pages')
-    );
+    const pagesDir = path.join(entryPath, '.next', 'serverless', 'pages');
+
+    const pages = await glob('**/*.js', pagesDir);
+    const staticPageFiles = await glob('**/*.html', pagesDir);
+
+    Object.keys(staticPageFiles).forEach((page: string) => {
+      const staticRoute = path.join(entryDirectory, page);
+      staticPages[staticRoute] = staticPageFiles[page];
+
+      const pathname = page.replace(/\.html$/, '');
+
+      if (isDynamicRoute(pathname)) {
+        dynamicPages.push(pathname);
+      }
+
+      exportedPageRoutes.push({
+        src: `^${path.join('/', entryDirectory, pathname)}$`,
+        dest: path.join('/', staticRoute),
+      });
+    });
 
     const pageKeys = Object.keys(pages);
 
@@ -413,12 +453,16 @@ export const build = async ({
     await Promise.all(
       pageKeys.map(async page => {
         // These default pages don't have to be handled as they'd always 404
-        if (['_app.js', '_error.js', '_document.js'].includes(page)) {
+        if (['_app.js', '_document.js'].includes(page)) {
           return;
         }
 
         const pathname = page.replace(/\.js$/, '');
 
+        if (isDynamicRoute(pathname)) {
+          dynamicPages.push(normalizePage(pathname));
+        }
+
         console.log(`Creating lambda for page: "${page}"...`);
         lambdas[path.join(entryDirectory, pathname)] = await createLambda({
           files: {
@@ -427,7 +471,7 @@ export const build = async ({
             'page.js': pages[page],
           },
           handler: 'now__launcher.launcher',
-          runtime: 'nodejs8.10',
+          runtime: nodeVersion.runtime,
         });
         console.log(`Created lambda for page: "${page}"`);
       })
@@ -465,14 +509,44 @@ export const build = async ({
     {}
   );
 
+  let dynamicRoutes = getDynamicRoutes(
+    entryPath,
+    entryDirectory,
+    dynamicPages
+  ).map(route => {
+    // make sure .html is added to dest for now until
+    // outputting static files to clean routes is available
+    if (staticPages[`${route.dest}.html`.substr(1)]) {
+      route.dest = `${route.dest}.html`;
+    }
+    return route;
+  });
+
   return {
     output: {
       ...publicFiles,
       ...lambdas,
+      ...staticPages,
       ...staticFiles,
       ...staticDirectoryFiles,
     },
-    routes: [],
+    routes: [
+      // Static exported pages (.html rewrites)
+      ...exportedPageRoutes,
+      // Next.js page lambdas, `static/` folder, reserved assets, and `public/`
+      // folder
+      { handle: 'filesystem' },
+      // Dynamic routes
+      ...dynamicRoutes,
+      ...(isLegacy
+        ? []
+        : [
+            {
+              src: path.join('/', entryDirectory, '.*'),
+              dest: path.join('/', entryDirectory, '_error'),
+            },
+          ]),
+    ],
     watch: [],
     childProcesses: [],
   };

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

@@ -4,7 +4,8 @@ import url from 'url';
 import { Bridge } from './now__bridge';
 
 if (!process.env.NODE_ENV) {
-  process.env.NODE_ENV = process.env.NOW_REGION === 'dev1' ? 'development' : 'production';
+  process.env.NODE_ENV =
+    process.env.NOW_REGION === 'dev1' ? 'development' : 'production';
 }
 
 const app = next({});

packages/now-next/src/utils.ts

@@ -1,5 +1,6 @@
 import fs from 'fs-extra';
 import path from 'path';
+import resolveFrom from 'resolve-from';
 import { Files } from '@now/build-utils';
 
 type stringMap = { [key: string]: string };
@@ -8,6 +9,14 @@ export interface EnvConfig {
   [name: string]: string | undefined;
 }
 
+// Identify /[param]/ in route string
+const TEST_DYNAMIC_ROUTE = /\/\[[^\/]+?\](?=\/|$)/;
+
+function isDynamicRoute(route: string): boolean {
+  route = route.startsWith('/') ? route : `/${route}`;
+  return TEST_DYNAMIC_ROUTE.test(route);
+}
+
 /**
  * Validate if the entrypoint is allowed to be used
  */
@@ -168,7 +177,18 @@ function getPathsInside(entryDirectory: string, files: Files) {
   return watch;
 }
 
+function normalizePage(page: string): string {
+  // remove '/index' from the end
+  page = page.replace(/\/index$/, '/');
+  // Resolve on anything that doesn't start with `/`
+  if (!page.startsWith('/')) {
+    page = `/${page}`;
+  }
+  return page;
+}
+
 function getRoutes(
+  entryPath: string,
   entryDirectory: string,
   pathsInside: string[],
   files: Files,
@@ -196,6 +216,7 @@ function getRoutes(
     },
   ];
   const filePaths = Object.keys(filesInside);
+  const dynamicPages = [];
 
   for (const file of filePaths) {
     const relativePath = path.relative(entryDirectory, file);
@@ -213,6 +234,10 @@ function getRoutes(
       continue;
     }
 
+    if (isDynamicRoute(pageName)) {
+      dynamicPages.push(normalizePage(pageName));
+    }
+
     routes.push({
       src: `${prefix}${pageName}`,
       dest: `${url}/${pageName}`,
@@ -228,6 +253,17 @@ function getRoutes(
     }
   }
 
+  routes.push(
+    ...getDynamicRoutes(entryPath, entryDirectory, dynamicPages).map(
+      (route: { src: string; dest: string }) => {
+        // convert to make entire RegExp match as one group
+        route.src = route.src.replace('^', '^(').replace('$', ')$');
+        route.dest = `${url}/$1`;
+        return route;
+      }
+    )
+  );
+
   // Add public folder routes
   for (const file of filePaths) {
     const relativePath = path.relative(entryDirectory, file);
@@ -250,6 +286,52 @@ function getRoutes(
   return routes;
 }
 
+export function getDynamicRoutes(
+  entryPath: string,
+  entryDirectory: string,
+  dynamicPages: string[]
+): { src: string; dest: string }[] {
+  if (!dynamicPages.length) {
+    return [];
+  }
+
+  let getRouteRegex:
+    | ((pageName: string) => { re: RegExp })
+    | undefined = undefined;
+
+  let getSortedRoutes: ((normalizedPages: string[]) => string[]) | undefined;
+
+  try {
+    ({ getRouteRegex, getSortedRoutes } = require(resolveFrom(
+      entryPath,
+      'next-server/dist/lib/router/utils'
+    )));
+    if (typeof getRouteRegex !== 'function') {
+      getRouteRegex = undefined;
+    }
+  } catch (_) {}
+
+  if (!getRouteRegex || !getSortedRoutes) {
+    throw new Error(
+      'Found usage of dynamic routes but not on a new enough version of Next.js.'
+    );
+  }
+
+  const pageMatchers = getSortedRoutes(dynamicPages).map(pageName => ({
+    pageName,
+    matcher: getRouteRegex!(pageName).re,
+  }));
+
+  const routes: { src: string; dest: string }[] = [];
+  pageMatchers.forEach(pageMatcher => {
+    routes.push({
+      src: pageMatcher.matcher.source,
+      dest: path.join('/', entryDirectory, pageMatcher.pageName),
+    });
+  });
+  return routes;
+}
+
 function syncEnvVars(base: EnvConfig, removeEnv: EnvConfig, addEnv: EnvConfig) {
   // Remove any env vars from `removeEnv`
   // that are not present in the `addEnv`
@@ -276,4 +358,6 @@ export {
   getRoutes,
   stringMap,
   syncEnvVars,
+  normalizePage,
+  isDynamicRoute,
 };

packages/now-next/test/integration/index.test.js

@@ -10,12 +10,15 @@ it(
     const {
       buildResult: { output },
     } = await runBuildLambda(path.join(__dirname, 'standard'));
-    expect(output.index).toBeDefined();
+    expect(output['index.html']).toBeDefined();
+    expect(output.goodbye).toBeDefined();
     const filePaths = Object.keys(output);
+    const serverlessError = filePaths.some(filePath => filePath.match(/_error/));
     const hasUnderScoreAppStaticFile = filePaths.some(filePath => filePath.match(/static.*\/pages\/_app\.js$/));
     const hasUnderScoreErrorStaticFile = filePaths.some(filePath => filePath.match(/static.*\/pages\/_error\.js$/));
     expect(hasUnderScoreAppStaticFile).toBeTruthy();
     expect(hasUnderScoreErrorStaticFile).toBeTruthy();
+    expect(serverlessError).toBeTruthy();
   },
   FOUR_MINUTES,
 );

packages/now-next/test/integration/legacy-custom-dependency/now.json

@@ -1,6 +1,4 @@
 {
   "version": 2,
-  "builds": [
-    {"src": "package.json", "use": "@now/next"}
-  ]
+  "builds": [{ "src": "package.json", "use": "@now/next" }]
 }

packages/now-next/test/integration/legacy-custom-dependency/package.json

@@ -3,4 +3,4 @@
     "isomorphic-unfetch": "latest",
     "next": "7.0.0"
   }
-}
+}

packages/now-next/test/integration/legacy-standard/now.json

@@ -1,6 +1,4 @@
 {
   "version": 2,
-  "builds": [
-    {"src": "next.config.js", "use": "@now/next"}
-  ]
+  "builds": [{ "src": "next.config.js", "use": "@now/next" }]
 }

packages/now-next/test/integration/legacy-standard/package.json

@@ -2,4 +2,4 @@
   "dependencies": {
     "next": "^7.0.2"
   }
-}
+}

packages/now-next/test/integration/legacy-static-files/now.json

@@ -1,6 +1,4 @@
 {
   "version": 2,
-  "builds": [
-    {"src": "next.config.js", "use": "@now/next"}
-  ]
+  "builds": [{ "src": "next.config.js", "use": "@now/next" }]
 }

packages/now-next/test/integration/legacy-static-files/package.json

@@ -2,4 +2,4 @@
   "dependencies": {
     "next": "7.0.2"
   }
-}
+}

packages/now-next/test/integration/monorepo/now.json

@@ -1,6 +1,4 @@
 {
-    "version": 2,
-    "builds": [
-        { "src": "www/package.json", "use": "@now/next" }
-    ]
+  "version": 2,
+  "builds": [{ "src": "www/package.json", "use": "@now/next" }]
 }

packages/now-next/test/integration/no-package-json-and-next-config/now.json

@@ -1,6 +1,4 @@
 {
   "version": 2,
-  "builds": [
-    {"src": "pages/index.js", "use": "@now/next"}
-  ]
+  "builds": [{ "src": "pages/index.js", "use": "@now/next" }]
 }

packages/now-next/test/integration/public-files/now.json

@@ -1,6 +1,4 @@
 {
   "version": 2,
-  "builds": [
-    {"src": "next.config.js", "use": "@now/next"}
-  ]
+  "builds": [{ "src": "next.config.js", "use": "@now/next" }]
 }

packages/now-next/test/integration/public-files/package.json

@@ -7,4 +7,4 @@
     "react": "16",
     "react-dom": "16"
   }
-}
+}

packages/now-next/test/integration/standard/next.config.js

@@ -1,3 +0,0 @@
-module.exports = {
-  target: 'serverless',
-};

packages/now-next/test/integration/standard/now.json

@@ -1,6 +1,4 @@
 {
   "version": 2,
-  "builds": [
-    {"src": "next.config.js", "use": "@now/next"}
-  ]
+  "builds": [{ "src": "package.json", "use": "@now/next" }]
 }

packages/now-next/test/integration/standard/package.json

@@ -4,4 +4,4 @@
     "react": "latest",
     "react-dom": "latest"
   }
-}
+}

packages/now-next/test/integration/standard/pages/goodbye.js

@@ -0,0 +1,3 @@
+const F = () => 'Goodbye World!';
+F.getInitialProps = () => ({});
+export default F;

packages/now-next/test/integration/static-files/now.json

@@ -1,6 +1,4 @@
 {
   "version": 2,
-  "builds": [
-    {"src": "next.config.js", "use": "@now/next"}
-  ]
+  "builds": [{ "src": "next.config.js", "use": "@now/next" }]
 }

packages/now-next/test/integration/static-files/package.json

@@ -7,4 +7,4 @@
     "react": "16",
     "react-dom": "16"
   }
-}
+}

packages/now-next/tsconfig.json

@@ -9,10 +9,6 @@
     "sourceMap": false,
     "declaration": false
   },
-  "include": [
-    "src/**/*"
-  ],
-  "exclude": [
-    "node_modules"
-  ]
+  "include": ["src/**/*"],
+  "exclude": ["node_modules"]
 }

packages/now-node-bridge/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@now/node-bridge",
-  "version": "1.1.2",
+  "version": "1.2.2",
   "license": "MIT",
   "main": "./index.js",
   "repository": {
@@ -21,6 +21,6 @@
     "@types/aws-lambda": "8.10.19",
     "@types/node": "11.9.4",
     "jest": "24.1.0",
-    "typescript": "3.3.3"
+    "typescript": "3.5.2"
   }
 }

packages/now-node-bridge/src/bridge.ts

@@ -1,10 +1,10 @@
 import { AddressInfo } from 'net';
-import { APIGatewayProxyEvent } from 'aws-lambda';
+import { APIGatewayProxyEvent, Context } from 'aws-lambda';
 import {
   Server,
   IncomingHttpHeaders,
   OutgoingHttpHeaders,
-  request
+  request,
 } from 'http';
 
 interface NowProxyEvent {
@@ -27,6 +27,16 @@ export interface NowProxyResponse {
   encoding: string;
 }
 
+interface ServerLike {
+  listen: (
+    opts: {
+      host?: string;
+      port?: number;
+    },
+    callback: (this: Server | null) => void
+  ) => Server | void;
+}
+
 /**
  * If the `http.Server` handler function throws an error asynchronously,
  * then it ends up being an unhandled rejection which doesn't kill the node
@@ -92,12 +102,16 @@ function normalizeEvent(
 }
 
 export class Bridge {
-  private server: Server | null;
+  private server: ServerLike | null;
   private listening: Promise<AddressInfo>;
   private resolveListening: (info: AddressInfo) => void;
+  private events: { [key: string]: NowProxyRequest } = {};
+  private reqIdSeed: number = 1;
+  private shouldStoreEvents: boolean = false;
 
-  constructor(server?: Server) {
+  constructor(server?: ServerLike, shouldStoreEvents: boolean = false) {
     this.server = null;
+    this.shouldStoreEvents = shouldStoreEvents;
     if (server) {
       this.setServer(server);
     }
@@ -112,18 +126,8 @@ export class Bridge {
     });
   }
 
-  setServer(server: Server) {
+  setServer(server: ServerLike) {
     this.server = server;
-    server.once('listening', () => {
-      const addr = server.address();
-      if (typeof addr === 'string') {
-        throw new Error(`Unexpected string for \`server.address()\`: ${addr}`);
-      } else if (!addr) {
-        throw new Error('`server.address()` returned `null`');
-      } else {
-        this.resolveListening(addr);
-      }
-    });
   }
 
   listen() {
@@ -131,28 +135,54 @@ export class Bridge {
       throw new Error('Server has not been set!');
     }
 
-    return this.server.listen({
-      host: '127.0.0.1',
-      port: 0
-    });
+    const resolveListening = this.resolveListening;
+
+    return this.server.listen(
+      {
+        host: '127.0.0.1',
+        port: 0,
+      },
+      function listeningCallback() {
+        if (!this || typeof this.address !== 'function') {
+          throw new Error(
+            'Missing server.address() function on `this` in server.listen()'
+          );
+        }
+
+        const addr = this.address();
+
+        if (!addr) {
+          throw new Error('`server.address()` returned `null`');
+        }
+
+        if (typeof addr === 'string') {
+          throw new Error(
+            `Unexpected string for \`server.address()\`: ${addr}`
+          );
+        }
+
+        resolveListening(addr);
+      }
+    );
   }
 
   async launcher(
-    event: NowProxyEvent | APIGatewayProxyEvent
+    event: NowProxyEvent | APIGatewayProxyEvent,
+    context: Context
   ): Promise<NowProxyResponse> {
+    context.callbackWaitsForEmptyEventLoop = false;
     const { port } = await this.listening;
 
-    const { isApiGateway, method, path, headers, body } = normalizeEvent(
-      event
-    );
+    const normalizedEvent = normalizeEvent(event);
+    const { isApiGateway, method, path, headers, body } = normalizedEvent;
 
-    const opts = {
-      hostname: '127.0.0.1',
-      port,
-      path,
-      method,
-      headers
-    };
+    if (this.shouldStoreEvents) {
+      const reqId = `${this.reqIdSeed++}`;
+      this.events[reqId] = normalizedEvent;
+      headers['x-now-bridge-request-id'] = reqId;
+    }
+
+    const opts = { hostname: '127.0.0.1', port, path, method, headers };
 
     // eslint-disable-next-line consistent-return
     return new Promise((resolve, reject) => {
@@ -175,7 +205,7 @@ export class Bridge {
             statusCode: response.statusCode || 200,
             headers: response.headers,
             body: bodyBuffer.toString('base64'),
-            encoding: 'base64'
+            encoding: 'base64',
           });
         });
       });
@@ -192,4 +222,10 @@ export class Bridge {
       req.end();
     });
   }
+
+  consumeEvent(reqId: string) {
+    const event = this.events[reqId];
+    delete this.events[reqId];
+    return event;
+  }
 }

packages/now-node-bridge/test/bridge.test.js

@@ -16,56 +16,108 @@ test('port binding', async () => {
 });
 
 test('`APIGatewayProxyEvent` normalizing', async () => {
-  const server = new Server((req, res) => res.end(
-    JSON.stringify({
-      method: req.method,
-      path: req.url,
-      headers: req.headers,
-    }),
-  ));
+  const server = new Server((req, res) =>
+    res.end(
+      JSON.stringify({
+        method: req.method,
+        path: req.url,
+        headers: req.headers,
+      })
+    )
+  );
   const bridge = new Bridge(server);
   bridge.listen();
-  const result = await bridge.launcher({
-    httpMethod: 'GET',
-    headers: { foo: 'bar' },
-    path: '/apigateway',
-    body: null,
-  });
+  const context = {};
+  const result = await bridge.launcher(
+    {
+      httpMethod: 'GET',
+      headers: { foo: 'bar' },
+      path: '/apigateway',
+      body: null,
+    },
+    context
+  );
   assert.equal(result.encoding, 'base64');
   assert.equal(result.statusCode, 200);
   const body = JSON.parse(Buffer.from(result.body, 'base64').toString());
   assert.equal(body.method, 'GET');
   assert.equal(body.path, '/apigateway');
   assert.equal(body.headers.foo, 'bar');
+  assert.equal(context.callbackWaitsForEmptyEventLoop, false);
 
   server.close();
 });
 
 test('`NowProxyEvent` normalizing', async () => {
-  const server = new Server((req, res) => res.end(
-    JSON.stringify({
-      method: req.method,
-      path: req.url,
-      headers: req.headers,
-    }),
-  ));
+  const server = new Server((req, res) =>
+    res.end(
+      JSON.stringify({
+        method: req.method,
+        path: req.url,
+        headers: req.headers,
+      })
+    )
+  );
   const bridge = new Bridge(server);
   bridge.listen();
-  const result = await bridge.launcher({
-    Action: 'Invoke',
-    body: JSON.stringify({
-      method: 'POST',
-      headers: { foo: 'baz' },
-      path: '/nowproxy',
-      body: 'body=1',
-    }),
-  });
+  const context = { callbackWaitsForEmptyEventLoop: true };
+  const result = await bridge.launcher(
+    {
+      Action: 'Invoke',
+      body: JSON.stringify({
+        method: 'POST',
+        headers: { foo: 'baz' },
+        path: '/nowproxy',
+        body: 'body=1',
+      }),
+    },
+    context
+  );
   assert.equal(result.encoding, 'base64');
   assert.equal(result.statusCode, 200);
   const body = JSON.parse(Buffer.from(result.body, 'base64').toString());
   assert.equal(body.method, 'POST');
   assert.equal(body.path, '/nowproxy');
   assert.equal(body.headers.foo, 'baz');
+  assert.equal(context.callbackWaitsForEmptyEventLoop, false);
+
+  server.close();
+});
+
+test('consumeEvent', async () => {
+  const mockListener = jest.fn((req, res) => {
+    res.end('hello');
+  });
+
+  const server = new Server(mockListener);
+  const bridge = new Bridge(server, true);
+  bridge.listen();
+
+  const context = { callbackWaitsForEmptyEventLoop: true };
+  await bridge.launcher(
+    {
+      Action: 'Invoke',
+      body: JSON.stringify({
+        method: 'POST',
+        headers: { foo: 'baz' },
+        path: '/nowproxy',
+        body: 'body=1',
+      }),
+    },
+    context
+  );
+
+  const headers = mockListener.mock.calls[0][0].headers;
+  const reqId = headers['x-now-bridge-request-id'];
+
+  expect(reqId).toBeTruthy();
+
+  const event = bridge.consumeEvent(reqId);
+  expect(event.body.toString()).toBe('body=1');
+
+  // an event can't be consumed multiple times
+  // to avoid memory leaks
+  expect(bridge.consumeEvent(reqId)).toBeUndefined();
 
   server.close();
 });

packages/now-node-bridge/tsconfig.json

@@ -9,10 +9,6 @@
     "sourceMap": true,
     "declaration": true
   },
-  "include": [
-    "src/**/*"
-  ],
-  "exclude": [
-    "node_modules"
-  ]
+  "include": ["src/**/*"],
+  "exclude": ["node_modules"]
 }

packages/now-node-server/index.js

@@ -1,15 +1,17 @@
-const { createLambda } = require('@now/build-utils/lambda.js'); // eslint-disable-line import/no-extraneous-dependencies
-const download = require('@now/build-utils/fs/download.js'); // eslint-disable-line import/no-extraneous-dependencies
-const FileBlob = require('@now/build-utils/file-blob.js'); // eslint-disable-line import/no-extraneous-dependencies
-const FileFsRef = require('@now/build-utils/file-fs-ref.js'); // eslint-disable-line import/no-extraneous-dependencies
 const fs = require('fs-extra');
-const glob = require('@now/build-utils/fs/glob.js'); // eslint-disable-line import/no-extraneous-dependencies
 const path = require('path');
 const {
+  FileBlob,
+  FileFsRef,
+  download,
+  createLambda,
+  glob,
   runNpmInstall,
   runPackageJsonScript,
-} = require('@now/build-utils/fs/run-user-scripts.js'); // eslint-disable-line import/no-extraneous-dependencies
-const { shouldServe } = require('@now/build-utils'); // eslint-disable-line import/no-extraneous-dependencies
+  getNodeVersion,
+  getSpawnOptions,
+  shouldServe,
+} = require('@now/build-utils'); // eslint-disable-line import/no-extraneous-dependencies
 
 /** @typedef { import('@now/build-utils/file-ref') } FileRef */
 /** @typedef {{[filePath: string]: FileRef}} Files */
@@ -38,8 +40,15 @@ async function downloadInstallAndBundle(
 
   console.log("installing dependencies for user's code...");
   const entrypointFsDirname = path.join(workPath, path.dirname(entrypoint));
-  await runNpmInstall(entrypointFsDirname, npmArguments);
-  return [downloadedFiles, entrypointFsDirname];
+  const nodeVersion = await getNodeVersion(entrypointFsDirname);
+  const spawnOpts = getSpawnOptions(meta, nodeVersion);
+  await runNpmInstall(entrypointFsDirname, npmArguments, spawnOpts);
+  return {
+    downloadedFiles,
+    entrypointFsDirname,
+    spawnOpts,
+    nodeVersion,
+  };
 }
 
 async function compile(workPath, downloadedFiles, entrypoint, config) {
@@ -101,17 +110,25 @@ exports.config = {
  * @returns {Promise<Files>}
  */
 exports.build = async ({
-  files, entrypoint, config, workPath, meta,
+  files, entrypoint, config, workPath, meta = {},
 }) => {
-  const [downloadedFiles, entrypointFsDirname] = await downloadInstallAndBundle(
+  const {
+    downloadedFiles,
+    entrypointFsDirname,
+    spawnOptions,
+    nodeVersion,
+  } = await downloadInstallAndBundle(
     {
-      files, entrypoint, workPath, meta,
+      files,
+      entrypoint,
+      workPath,
+      meta,
     },
     { npmArguments: ['--prefer-offline'] },
   );
 
   console.log('running user script...');
-  await runPackageJsonScript(entrypointFsDirname, 'now-build');
+  await runPackageJsonScript(entrypointFsDirname, 'now-build', spawnOptions);
 
   console.log('preparing lambda files...');
   let preparedFiles;
@@ -140,10 +157,13 @@ exports.build = async ({
     'bridge.js': new FileFsRef({ fsPath: require('@now/node-bridge') }),
   };
 
+  // Use the system-installed version of `node` when running via `now dev`
+  const runtime = meta.isDev ? 'nodejs' : nodeVersion.runtime;
+
   const lambda = await createLambda({
     files: { ...preparedFiles, ...launcherFiles },
     handler: 'launcher.launcher',
-    runtime: 'nodejs8.10',
+    runtime,
   });
 
   return { [entrypoint]: lambda };