Publish

- @now/bash@0.1.5-canary.0
 - @now/node-server@0.5.2-canary.2
 - @now/node@0.5.2-canary.4
 - @now/python@0.0.42-canary.0

.circleci/build.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+set -euo pipefail
+
+circleci_dir="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
+needs_build="$(grep -rn '"build"' packages/*/package.json | cut -d: -f1)"
+
+for pkg in $needs_build; do
+  dir="$(dirname "$pkg")"
+  cd "$circleci_dir/../$dir"
+  echo "Building \`$dir\`"
+  yarn build
+done

.circleci/config.yml

@@ -23,6 +23,9 @@ jobs:
       - run:
           name: Linting
           command: yarn lint
+      - run:
+          name: Building
+          command: ./.circleci/build.sh
       - run:
           name: Tests
           command: yarn test
@@ -30,11 +33,8 @@ jobs:
           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 canary release
-          command: "if ls ~/.npmrc >/dev/null 2>&1 && [[ $(git describe --exact-match 2> /dev/null || :) =~ -canary ]]; then yarn run lerna publish from-git --npm-tag canary --yes; else  echo \"Did not publish\"; fi"
-      - run:
-          name: Potentially publish stable release
-          command: "if ls ~/.npmrc >/dev/null 2>&1 && [[ ! $(git describe --exact-match 2> /dev/null || :) =~ -canary ]]; then yarn run lerna publish from-git --yes; else  echo \"Did not publish\"; fi"
+          name: Potentially publish releases to npm
+          command: ./.circleci/publish.sh
 workflows:
   version: 2
   build-and-deploy:

.circleci/publish.sh

@@ -0,0 +1,24 @@
+#!/bin/bash
+set -euo pipefail
+
+if [ ! -e ~/.npmrc ]; then
+  echo "~/.npmrc file does not exist, skipping publish"
+  exit 0
+fi
+
+npm_tag=""
+tag="$(git describe --tags --exact-match 2> /dev/null || :)"
+
+if [ -z "$tag" ]; then
+  echo "Not a tagged commit, skipping publish"
+  exit 0
+fi
+
+if [[ "$tag" =~ -canary ]]; then
+  echo "Publishing canary release"
+  npm_tag="--npm-tag canary"
+else
+  echo "Publishing stable release"
+fi
+
+yarn run lerna publish from-git $npm_tag --yes

.eslintignore

@@ -1,3 +1,4 @@
 /tmp/*
 /node_modules/*
 /**/node_modules/*
+/packages/now-go/go/*

.gitignore

@@ -1,2 +1,4 @@
 node_modules
 tmp
+target/
+.next

.prettierrc.json

@@ -0,0 +1,3 @@
+{
+  "singleQuote": true
+}

README.md

@@ -2,7 +2,7 @@
 
 This is the full list of official Builders provided by the ZEIT team.
 
-More details here: http://zeit.co/docs
+More details here: https://zeit.co/docs/v2/deployments/builders/overview/
 
 ### Publishing to npm
 

errors/now-next-legacy-mode.md

@@ -0,0 +1,73 @@
+# `@now/next` Legacy Mode
+
+#### Why This Warning Occurred
+
+`@now/next` has two modes: `legacy` and `serverless`. You will always want to use the `serverless` mode. `legacy` is to provide backwards compatibility with previous `@now/next` versions.
+
+The differences:
+
+Legacy:
+
+- Minimal lambda size of `2.2Mb` (approximately)
+- Forces `next@v7.0.2-canary.49` and `next-server@v7.0.2-canary.49`
+- Forces all `dependencies` to be `devDependencies`
+- Loads `next.config.js` on bootup, breaking sometimes when users didn't use `phases` to load files
+- Used `next-server` which is the full Next.js server with routing etc.
+- Runs `npm install`
+- Runs `npm run now-build`
+- Runs `npm install --production` after build
+
+Serverless:
+
+- Minimal lambda size of `49Kb` (approximately)
+- Uses Next.js build targets (`target: 'serverless'`) in `next.config.js`. [documentation](https://github.com/zeit/next.js#summary)
+- Does not make changes to your application dependencies
+- Does not load `next.config.js` ([as per the serverless target documentation](https://github.com/zeit/next.js#summary))
+- Runs `npm install`
+- Runs `npm run now-build`
+- Does not run `npm install --production` as the output from the build is all that's needed to bundle lambdas.
+- 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: 
+
+```
+npm install next --save
+```
+
+2. Add the `now-build` script to your `package.json`
+
+```json
+{
+  "scripts": {
+    "now-build": "next build"
+  },
+}
+```
+
+3. Add `target: 'serverless'` to `next.config.js`
+
+```js
+module.exports = {
+  target: 'serverless'
+  // Other options are still valid
+}
+```
+
+4. Optionally make sure the `"src"` in `"builds"` points to your application `package.json`
+
+```js
+{
+  "version": 2,
+  "builds": [{ "src": "package.json", "use": "@now/next" }]
+}
+```
+
+### Useful Links
+
+- [Serverless target implementation](https://github.com/zeit/now-builders/pull/150) 

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

@@ -0,0 +1,45 @@
+# `@now/next` No Serverless Pages Built
+
+#### Why This Error Occurred
+
+This error occurs when you have your application is not configured for Serverless Next.js build output.
+
+#### 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:
+
+```
+npm install next --save
+```
+
+2. Add the `now-build` script to your `package.json`
+
+```json
+{
+  "scripts": {
+    "now-build": "next build"
+  },
+}
+```
+
+3. Add `target: 'serverless'` to `next.config.js`
+
+```js
+module.exports = {
+  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`
+
+5. Optionally make sure the `"src"` in `"builds"` points to your application `package.json`
+
+```js
+{
+  "version": 2,
+  "builds": [{ "src": "package.json", "use": "@now/next" }]
+}
+```

lerna.json

@@ -2,24 +2,7 @@
   "npmClient": "yarn",
   "useWorkspaces": true,
   "packages": [
-    "packages/now-build-utils",
-    "packages/now-node-bridge",
-    "packages/now-php-bridge",
-    "packages/now-bash",
-    "packages/now-cgi",
-    "packages/now-go",
-    "packages/now-html-minifier",
-    "packages/now-lambda",
-    "packages/now-md",
-    "packages/now-mdx-deck",
-    "packages/now-next",
-    "packages/now-node",
-    "packages/now-node-server",
-    "packages/now-optipng",
-    "packages/now-php",
-    "packages/now-python",
-    "packages/now-static-build",
-    "packages/now-wordpress"
+    "packages/*"
   ],
   "command": {
     "publish": {

package.json

@@ -15,13 +15,13 @@
     "publish-stable": "lerna version",
     "publish-canary": "lerna version prerelease --preid canary",
     "lint": "tsc && eslint .",
-    "test": "jest --runInBand",
+    "test": "jest --runInBand --verbose",
     "lint-staged": "lint-staged"
   },
   "pre-commit": "lint-staged",
   "lint-staged": {
     "*.js": [
-      "prettier --write --single-quote",
+      "prettier --write",
       "eslint --fix",
       "git add"
     ]

packages/now-bash/index.js

@@ -1,10 +1,10 @@
 const execa = require('execa');
 const { join } = require('path');
 const snakeCase = require('snake-case');
-const glob = require('@now/build-utils/fs/glob');
-const download = require('@now/build-utils/fs/download');
-const { createLambda } = require('@now/build-utils/lambda');
-const getWritableDirectory = require('@now/build-utils/fs/get-writable-directory');
+const glob = require('@now/build-utils/fs/glob'); // eslint-disable-line import/no-extraneous-dependencies
+const download = require('@now/build-utils/fs/download'); // eslint-disable-line import/no-extraneous-dependencies
+const { createLambda } = require('@now/build-utils/lambda'); // eslint-disable-line import/no-extraneous-dependencies
+const getWritableDirectory = require('@now/build-utils/fs/get-writable-directory'); // eslint-disable-line import/no-extraneous-dependencies
 
 exports.config = {
   maxLambdaSize: '10mb',
@@ -12,9 +12,10 @@ exports.config = {
 
 exports.analyze = ({ files, entrypoint }) => files[entrypoint].digest;
 
-exports.build = async ({ files, entrypoint, config }) => {
+exports.build = async ({
+  workPath, files, entrypoint, config,
+}) => {
   const srcDir = await getWritableDirectory();
-  const workDir = await getWritableDirectory();
 
   console.log('downloading files...');
   await download(files, srcDir);
@@ -24,7 +25,7 @@ exports.build = async ({ files, entrypoint, config }) => {
     return o;
   }, {});
 
-  const IMPORT_CACHE = `${workDir}/.import-cache`;
+  const IMPORT_CACHE = `${workPath}/.import-cache`;
   const env = Object.assign({}, process.env, configEnv, {
     PATH: `${IMPORT_CACHE}/bin:${process.env.PATH}`,
     IMPORT_CACHE,
@@ -37,12 +38,12 @@ exports.build = async ({ files, entrypoint, config }) => {
 
   await execa(builderPath, [entrypoint], {
     env,
-    cwd: workDir,
+    cwd: workPath,
     stdio: 'inherit',
   });
 
   const lambda = await createLambda({
-    files: await glob('**', workDir),
+    files: await glob('**', workPath),
     handler: entrypoint, // not actually used in `bootstrap`
     runtime: 'provided',
     environment: Object.assign({}, configEnv, {

packages/now-bash/package.json

@@ -1,10 +1,15 @@
 {
   "name": "@now/bash",
-  "version": "0.1.1",
+  "version": "0.1.5-canary.0",
   "description": "Now 2.0 builder for HTTP endpoints written in Bash",
   "main": "index.js",
   "author": "Nathan Rajlich <nate@zeit.co>",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zeit/now-builders.git",
+    "directory": "packages/now-bash"
+  },
   "files": [
     "builder.sh",
     "runtime.sh",
@@ -15,8 +20,5 @@
   "dependencies": {
     "execa": "^1.0.0",
     "snake-case": "^2.1.0"
-  },
-  "peerDependencies": {
-    "@now/build-utils": ">=0.0.1"
   }
 }

packages/now-bash/runtime.sh

@@ -52,11 +52,12 @@ _lambda_runtime_next() {
 	# Need to use a fifo here instead of bash <() because Lambda
 	# errors with "/dev/fd/63 not found" for some reason :/
 	local stdin
-	stdin="$(mktemp --dry-run)"
+	stdin="$(mktemp -u)"
 	mkfifo "$stdin"
-	_lambda_runtime_body "$event" > "$stdin" &
+	_lambda_runtime_body < "$event" > "$stdin" &
 
 	handler "$event" < "$stdin" > "$body" || exit_code="$?"
+
 	rm -f "$event" "$stdin"
 
 	if [ "$exit_code" -eq 0 ]; then
@@ -74,12 +75,14 @@ _lambda_runtime_next() {
 }
 
 _lambda_runtime_body() {
-	if [ "$(jq --raw-output '.body | type' < "$1")" = "string" ]; then
-		if [ "$(jq --raw-output '.encoding' < "$1")" = "base64" ]; then
-			jq --raw-output '.body' < "$1" | base64 -d
+	local event
+	event="$(cat)"
+	if [ "$(jq --raw-output '.body | type' <<< "$event")" = "string" ]; then
+		if [ "$(jq --raw-output '.encoding' <<< "$event")" = "base64" ]; then
+			jq --raw-output '.body' <<< "$event" | base64 --decode
 		else
 			# assume plain-text body
-			jq --raw-output '.body' < "$1"
+			jq --raw-output '.body' <<< "$event"
 		fi
 	fi
 }

packages/now-build-utils/.npmignore

@@ -1 +1,2 @@
 /test
+tmp

packages/now-build-utils/file-fs-ref.js

@@ -26,6 +26,18 @@ class FileFsRef {
     this.fsPath = fsPath;
   }
 
+  /**
+   * Creates a `FileFsRef` with the correct `mode` from the file system.
+   *
+   * @argument {Object} options
+   * @argument {string} options.fsPath
+   * @returns {Promise<FileFsRef>}
+   */
+  static async fromFsPath({ fsPath }) {
+    const { mode } = await fs.lstat(fsPath);
+    return new FileFsRef({ mode, fsPath });
+  }
+
   /**
    * @argument {Object} options
    * @argument {number} [options.mode=0o100644]

packages/now-build-utils/file-ref.js

@@ -49,7 +49,7 @@ class FileRef {
     assert(url);
 
     await semaToDownloadFromS3.acquire();
-    console.time(`downloading ${url}`);
+    // console.time(`downloading ${url}`);
     try {
       return await retry(
         async () => {
@@ -66,7 +66,7 @@ class FileRef {
         { factor: 1, retries: 3 },
       );
     } finally {
-      console.timeEnd(`downloading ${url}`);
+      // console.timeEnd(`downloading ${url}`);
       semaToDownloadFromS3.release();
     }
   }

packages/now-build-utils/fs/bootstrap-yarn.js

@@ -1,94 +0,0 @@
-const MemoryFileSystem = require('memory-fs');
-const fs = require('fs');
-const path = require('path');
-const { spawnSync } = require('child_process');
-
-const yarnPath = spawnSync('which', ['yarn'])
-  .stdout.toString()
-  .trim();
-
-const cachePath = spawnSync(yarnPath, ['cache', 'dir'])
-  .stdout.toString()
-  .trim();
-
-spawnSync(yarnPath, ['cache', 'clean']);
-const vfs = new MemoryFileSystem();
-
-function isInsideCachePath(filename) {
-  const relative = path.relative(cachePath, filename);
-  return !relative.startsWith('..');
-}
-
-const saveCreateWriteStream = fs.createWriteStream;
-fs.createWriteStream = (...args) => {
-  const filename = args[0];
-  if (!isInsideCachePath(filename)) {
-    return saveCreateWriteStream.call(fs, ...args);
-  }
-
-  vfs.mkdirpSync(path.dirname(filename));
-  fs.writeFileSync(filename, Buffer.alloc(0));
-  const stream = vfs.createWriteStream(...args);
-
-  stream.on('finish', () => {
-    setTimeout(() => {
-      stream.emit('close');
-    });
-  });
-
-  return stream;
-};
-
-const saveReadFile = fs.readFile;
-fs.readFile = (...args) => {
-  const filename = args[0];
-  if (!isInsideCachePath(filename)) {
-    return saveReadFile.call(fs, ...args);
-  }
-
-  const callback = args[args.length - 1];
-  return vfs.readFile(...args.slice(0, -1), (error, result) => {
-    if (error) {
-      saveReadFile.call(fs, ...args);
-      return;
-    }
-
-    callback(error, result);
-  });
-};
-
-const saveCopyFile = fs.copyFile;
-fs.copyFile = (...args) => {
-  const src = args[0];
-  const dest = args[1];
-  const callback = args[args.length - 1];
-
-  if (isInsideCachePath(src) && !isInsideCachePath(dest)) {
-    const buffer = vfs.readFileSync(src);
-    return fs.writeFile(dest, buffer, callback);
-  }
-
-  if (!isInsideCachePath(src) && isInsideCachePath(dest)) {
-    const buffer = fs.readFileSync(src);
-
-    vfs.mkdirpSync(path.dirname(dest));
-    fs.writeFileSync(dest, Buffer.alloc(0));
-    return vfs.writeFile(dest, buffer, callback);
-  }
-
-  return saveCopyFile.call(fs, ...args);
-};
-
-const saveWriteFile = fs.writeFile;
-fs.writeFile = (...args) => {
-  const filename = args[0];
-  if (!isInsideCachePath(filename)) {
-    return saveWriteFile.call(fs, ...args);
-  }
-
-  vfs.mkdirpSync(path.dirname(filename));
-  fs.writeFileSync(filename, Buffer.alloc(0));
-  return vfs.writeFile(...args);
-};
-
-require(yarnPath);

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

@@ -1,12 +1,10 @@
-const path = require('path');
-const fs = require('fs-extra');
-
-const prod = process.env.AWS_EXECUTION_ENV || process.env.X_GOOGLE_CODE_LOCATION;
-const TMP_PATH = prod ? '/tmp' : path.join(__dirname, 'tmp');
+const { join } = require('path');
+const { tmpdir } = require('os');
+const { mkdirp } = require('fs-extra');
 
 module.exports = async function getWritableDirectory() {
   const name = Math.floor(Math.random() * 0x7fffffff).toString(16);
-  const directory = path.join(TMP_PATH, name);
-  await fs.mkdirp(directory);
+  const directory = join(tmpdir(), name);
+  await mkdirp(directory);
   return directory;
 };

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

@@ -3,12 +3,9 @@ const fs = require('fs-extra');
 const path = require('path');
 const { spawn } = require('child_process');
 
-const prod = process.env.AWS_EXECUTION_ENV
-  || process.env.X_GOOGLE_CODE_LOCATION;
-
-function spawnAsync(command, args, cwd) {
+function spawnAsync(command, args, cwd, opts = {}) {
   return new Promise((resolve, reject) => {
-    const child = spawn(command, args, { stdio: 'inherit', cwd });
+    const child = spawn(command, args, { stdio: 'inherit', cwd, ...opts });
     child.on('error', reject);
     child.on('close', (code, signal) => (code !== 0
       ? reject(new Error(`Exited with ${code || signal}`))
@@ -16,9 +13,18 @@ function spawnAsync(command, args, cwd) {
   });
 }
 
+async function chmodPlusX(fsPath) {
+  const s = await fs.stat(fsPath);
+  const newMode = s.mode | 64 | 8 | 1; // eslint-disable-line no-bitwise
+  if (s.mode === newMode) return;
+  const base8 = newMode.toString(8).slice(-3);
+  await fs.chmod(fsPath, base8);
+}
+
 async function runShellScript(fsPath) {
   assert(path.isAbsolute(fsPath));
   const destPath = path.dirname(fsPath);
+  await chmodPlusX(fsPath);
   await spawnAsync(`./${path.basename(fsPath)}`, [], destPath);
   return true;
 }
@@ -62,22 +68,27 @@ async function installDependencies(destPath, args = []) {
   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',
+    },
+  };
+
   if (hasPackageLockJson) {
     commandArgs = args.filter(a => a !== '--prefer-offline');
-    await spawnAsync('npm', ['install'].concat(commandArgs), destPath);
-    await spawnAsync('npm', ['cache', 'clean', '--force'], destPath);
-  } else if (prod) {
-    console.log('using memory-fs for yarn cache');
-    await spawnAsync(
-      'node',
-      [path.join(__dirname, 'bootstrap-yarn.js'), '--cwd', destPath].concat(
-        commandArgs,
-      ),
-      destPath,
-    );
+    await spawnAsync('npm', ['install'].concat(commandArgs), destPath, opts);
+    await spawnAsync('npm', ['cache', 'clean', '--force'], destPath, opts);
   } else {
-    await spawnAsync('yarn', ['--cwd', destPath].concat(commandArgs), destPath);
-    await spawnAsync('yarn', ['cache', 'clean'], destPath);
+    await spawnAsync(
+      'yarn',
+      ['--cwd', destPath].concat(commandArgs),
+      destPath,
+      opts,
+    );
+    await spawnAsync('yarn', ['cache', 'clean'], destPath, opts);
   }
 }
 

packages/now-build-utils/package.json

@@ -1,7 +1,12 @@
 {
   "name": "@now/build-utils",
-  "version": "0.4.32",
+  "version": "0.4.37-canary.1",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zeit/now-builders.git",
+    "directory": "packages/now-build-utils"
+  },
   "dependencies": {
     "async-retry": "1.2.3",
     "async-sema": "2.1.4",

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

@@ -7,7 +7,7 @@ const {
   testDeployment,
 } = require('../../../test/lib/deployment/test-deployment.js');
 
-jest.setTimeout(2 * 60 * 1000);
+jest.setTimeout(4 * 60 * 1000);
 const builderUrl = '@canary';
 let buildUtilsUrl;
 

packages/now-cgi/index.js

@@ -1,10 +1,10 @@
 const path = require('path');
 const { mkdirp, copyFile } = require('fs-extra');
 
-const glob = require('@now/build-utils/fs/glob');
-const download = require('@now/build-utils/fs/download');
-const { createLambda } = require('@now/build-utils/lambda');
-const getWritableDirectory = require('@now/build-utils/fs/get-writable-directory');
+const glob = require('@now/build-utils/fs/glob'); // eslint-disable-line import/no-extraneous-dependencies
+const download = require('@now/build-utils/fs/download'); // eslint-disable-line import/no-extraneous-dependencies
+const { createLambda } = require('@now/build-utils/lambda'); // eslint-disable-line import/no-extraneous-dependencies
+const getWritableDirectory = require('@now/build-utils/fs/get-writable-directory'); // eslint-disable-line import/no-extraneous-dependencies
 
 exports.analyze = ({ files, entrypoint }) => files[entrypoint].digest;
 

packages/now-cgi/package.json

@@ -1,7 +1,12 @@
 {
   "name": "@now/cgi",
-  "version": "0.0.15",
+  "version": "0.0.16-canary.0",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zeit/now-builders.git",
+    "directory": "packages/now-cgi"
+  },
   "scripts": {
     "test": "best -I test/*.js",
     "prepublish": "./build.sh"
@@ -16,8 +21,5 @@
   "devDependencies": {
     "@zeit/best": "0.4.3",
     "rmfr": "2.0.0"
-  },
-  "peerDependencies": {
-    "@now/build-utils": ">=0.0.1"
   }
 }

packages/now-go/.gitignore

@@ -1,4 +1,5 @@
 node_modules
 *.log
-launcher
-bin
+/?.js
+/go
+/get-exported-function-name

packages/now-go/build.sh

@@ -1,7 +0,0 @@
-#!/usr/bin/env bash
-
-mkdir -p bin
-cd util
-GOOS=linux GOARCH=amd64 go build get-exported-function-name.go
-mv get-exported-function-name ../bin/
-

packages/now-go/download-go-bin.js

@@ -1,23 +0,0 @@
-const path = require('path');
-
-const fetch = require('node-fetch');
-const tar = require('tar');
-const getWritableDirectory = require('@now/build-utils/fs/get-writable-directory.js');
-
-const url = 'https://dl.google.com/go/go1.11.1.linux-amd64.tar.gz';
-
-module.exports = async () => {
-  const res = await fetch(url);
-  const dir = await getWritableDirectory();
-
-  if (!res.ok) {
-    throw new Error(`Failed to download: ${url}`);
-  }
-
-  return new Promise((resolve, reject) => {
-    res.body
-      .on('error', reject)
-      .pipe(tar.extract({ cwd: dir, strip: 1 }))
-      .on('finish', () => resolve(path.join(dir, 'bin', 'go')));
-  });
-};

packages/now-go/go-helpers.js

@@ -0,0 +1,129 @@
+const tar = require('tar');
+const execa = require('execa');
+const fetch = require('node-fetch');
+const { mkdirp } = require('fs-extra');
+const { dirname, join } = require('path');
+const debug = require('debug')('@now/go:go-helpers');
+
+const archMap = new Map([['x64', 'amd64'], ['x86', '386']]);
+const platformMap = new Map([['win32', 'windows']]);
+
+// Location where the `go` binary will be installed after `postinstall`
+const GO_DIR = join(__dirname, 'go');
+const GO_BIN = join(GO_DIR, 'bin/go');
+
+const getPlatform = p => platformMap.get(p) || p;
+const getArch = a => archMap.get(a) || a;
+const getGoUrl = (version, platform, arch) => {
+  const goArch = getArch(arch);
+  const goPlatform = getPlatform(platform);
+  const ext = platform === 'win32' ? 'zip' : 'tar.gz';
+  return `https://dl.google.com/go/go${version}.${goPlatform}-${goArch}.${ext}`;
+};
+
+async function getExportedFunctionName(filePath) {
+  debug('Detecting handler name for %o', filePath);
+  const bin = join(__dirname, 'get-exported-function-name');
+  const args = [filePath];
+  const name = await execa.stdout(bin, args);
+  debug('Detected exported name %o', name);
+  return name;
+}
+
+// Creates a `$GOPATH` directory tree, as per `go help gopath` instructions.
+// Without this, `go` won't recognize the `$GOPATH`.
+function createGoPathTree(goPath, platform, arch) {
+  const tuple = `${getPlatform(platform)}_${getArch(arch)}`;
+  debug('Creating GOPATH directory structure for %o (%s)', goPath, tuple);
+  return Promise.all([
+    mkdirp(join(goPath, 'bin')),
+    mkdirp(join(goPath, 'pkg', tuple)),
+  ]);
+}
+
+async function get({ src } = {}) {
+  const args = ['get'];
+  if (src) {
+    debug('Fetching `go` dependencies for file %o', src);
+    args.push(src);
+  } else {
+    debug('Fetching `go` dependencies for cwd %o', this.cwd);
+  }
+  await this(...args);
+}
+
+async function build({ src, dest }) {
+  debug('Building `go` binary %o -> %o', src, dest);
+  let sources;
+  if (Array.isArray(src)) {
+    sources = src;
+  } else {
+    sources = [src];
+  }
+  await this('build', '-o', dest, ...sources);
+}
+
+async function createGo(
+  goPath,
+  platform = process.platform,
+  arch = process.arch,
+  opts = {},
+  goMod = false,
+) {
+  const env = {
+    ...process.env,
+    PATH: `${dirname(GO_BIN)}:${process.env.PATH}`,
+    GOPATH: goPath,
+    ...opts.env,
+  };
+
+  if (goMod) {
+    env.GO111MODULE = 'on';
+  }
+
+  function go(...args) {
+    debug('Exec %o', `go ${args.join(' ')}`);
+    return execa('go', args, { stdio: 'inherit', ...opts, env });
+  }
+  go.cwd = opts.cwd || process.cwd();
+  go.get = get;
+  go.build = build;
+  go.goPath = goPath;
+  await createGoPathTree(goPath, platform, arch);
+  return go;
+}
+
+async function downloadGo(
+  dir = GO_DIR,
+  version = '1.12',
+  platform = process.platform,
+  arch = process.arch,
+) {
+  debug('Installing `go` v%s to %o for %s %s', version, dir, platform, arch);
+
+  const url = getGoUrl(version, platform, arch);
+  debug('Downloading `go` URL: %o', url);
+  const res = await fetch(url);
+
+  if (!res.ok) {
+    throw new Error(`Failed to download: ${url} (${res.status})`);
+  }
+
+  // TODO: use a zip extractor when `ext === "zip"`
+  await mkdirp(dir);
+  await new Promise((resolve, reject) => {
+    res.body
+      .on('error', reject)
+      .pipe(tar.extract({ cwd: dir, strip: 1 }))
+      .on('error', reject)
+      .on('finish', resolve);
+  });
+
+  return createGo(dir, platform, arch);
+}
+
+module.exports = {
+  createGo,
+  downloadGo,
+  getExportedFunctionName,
+};

packages/now-go/index.js

@@ -1,126 +1,186 @@
-const path = require('path');
-const { mkdirp, readFile, writeFile } = require('fs-extra');
+const { join, dirname } = require('path');
+const {
+  readFile, writeFile, pathExists, move,
+} = require('fs-extra');
 
-const execa = require('execa');
-const { createLambda } = require('@now/build-utils/lambda.js');
-const getWritableDirectory = require('@now/build-utils/fs/get-writable-directory.js');
-const download = require('@now/build-utils/fs/download.js');
-const downloadGit = require('lambda-git');
-const glob = require('@now/build-utils/fs/glob.js');
-const downloadGoBin = require('./download-go-bin');
+const glob = require('@now/build-utils/fs/glob.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 { createLambda } = require('@now/build-utils/lambda.js'); // eslint-disable-line import/no-extraneous-dependencies
+const getWritableDirectory = require('@now/build-utils/fs/get-writable-directory.js'); // eslint-disable-line import/no-extraneous-dependencies
+const { createGo, getExportedFunctionName } = require('./go-helpers');
 
-// creates a `$GOPATH` directory tree, as per
-// `go help gopath`'s instructions.
-// without this, Go won't recognize the `$GOPATH`
-async function createGoPathTree(goPath) {
-  await mkdirp(path.join(goPath, 'bin'));
-  await mkdirp(path.join(goPath, 'pkg', 'linux_amd64'));
-}
-
-exports.config = {
+const config = {
   maxLambdaSize: '10mb',
 };
 
-exports.build = async ({ files, entrypoint }) => {
-  console.log('downloading files...');
+async function build({ files, entrypoint }) {
+  console.log('Downloading user files...');
 
-  const gitPath = await getWritableDirectory();
-  const goPath = await getWritableDirectory();
-  const srcPath = path.join(goPath, 'src', 'lambda');
-  const outDir = await getWritableDirectory();
-
-  await createGoPathTree(goPath);
+  const [goPath, outDir] = await Promise.all([
+    getWritableDirectory(),
+    getWritableDirectory(),
+  ]);
 
+  const srcPath = join(goPath, 'src', 'lambda');
   const downloadedFiles = await download(files, srcPath);
 
-  console.log('downloading go binary...');
-  const goBin = await downloadGoBin();
-
-  console.log('downloading git binary...');
-  // downloads a git binary that works on Amazon Linux and sets
-  // `process.env.GIT_EXEC_PATH` so `go(1)` can see it
-  await downloadGit({ targetDirectory: gitPath });
-
-  const goEnv = {
-    ...process.env,
-    GOOS: 'linux',
-    GOARCH: 'amd64',
-    GOPATH: goPath,
-  };
-
-  console.log(`parsing AST for "${entrypoint}"`);
-  let handlerFunctionName = '';
+  console.log(`Parsing AST for "${entrypoint}"`);
+  let parseFunctionName;
   try {
-    handlerFunctionName = await execa.stdout(
-      path.join(__dirname, 'bin', 'get-exported-function-name'),
-      [downloadedFiles[entrypoint].fsPath],
+    parseFunctionName = await getExportedFunctionName(
+      downloadedFiles[entrypoint].fsPath,
     );
   } catch (err) {
-    console.log(`failed to parse AST for "${entrypoint}"`);
+    console.log(`Failed to parse AST for "${entrypoint}"`);
     throw err;
   }
 
-  if (handlerFunctionName === '') {
-    const e = new Error(
-      `Could not find an exported function on "${entrypoint}"`,
+  if (!parseFunctionName) {
+    const err = new Error(
+      `Could not find an exported function in "${entrypoint}"`,
     );
-    console.log(e.message);
-    throw e;
+    console.log(err.message);
+    throw err;
   }
 
-  console.log(
-    `Found exported function "${handlerFunctionName}" on "${entrypoint}"`,
-  );
+  const handlerFunctionName = parseFunctionName.split(',')[0];
 
-  const origianlMainGoContents = await readFile(
-    path.join(__dirname, 'main.go'),
-    'utf8',
+  console.log(
+    `Found exported function "${handlerFunctionName}" in "${entrypoint}"`,
   );
-  const mainGoContents = origianlMainGoContents.replace(
-    '__NOW_HANDLER_FUNC_NAME',
-    handlerFunctionName,
-  );
-  // in order to allow the user to have `main.go`, we need our `main.go` to be called something else
-  const mainGoFileName = 'main__now__go__.go';
 
   // we need `main.go` in the same dir as the entrypoint,
   // otherwise `go build` will refuse to build
-  const entrypointDirname = path.dirname(downloadedFiles[entrypoint].fsPath);
+  const entrypointDirname = dirname(downloadedFiles[entrypoint].fsPath);
 
-  // Go doesn't like to build files in different directories,
-  // so now we place `main.go` together with the user code
-  await writeFile(path.join(entrypointDirname, mainGoFileName), mainGoContents);
-
-  console.log('installing dependencies');
-  // `go get` will look at `*.go` (note we set `cwd`), parse
-  // the `import`s and download any packages that aren't part of the stdlib
-  try {
-    await execa(goBin, ['get'], {
-      env: goEnv,
-      cwd: entrypointDirname,
-      stdio: 'inherit',
-    });
-  } catch (err) {
-    console.log('failed to `go get`');
-    throw err;
-  }
-
-  console.log('running go build...');
-  try {
-    await execa(
-      goBin,
-      [
-        'build',
-        '-o',
-        path.join(outDir, 'handler'),
-        path.join(entrypointDirname, mainGoFileName),
-        downloadedFiles[entrypoint].fsPath,
-      ],
-      { env: goEnv, cwd: entrypointDirname, stdio: 'inherit' },
+  // check if package name other than main
+  const packageName = parseFunctionName.split(',')[1];
+  const isGoModExist = await pathExists(`${entrypointDirname}/go.mod`);
+  if (packageName !== 'main') {
+    const go = await createGo(
+      goPath,
+      process.platform,
+      process.arch,
+      {
+        cwd: entrypointDirname,
+      },
+      true,
     );
-  } catch (err) {
-    console.log('failed to `go build`');
-    throw err;
+    if (!isGoModExist) {
+      try {
+        go('mod', 'init', packageName);
+      } catch (err) {
+        console.log(`failed to \`go mod init ${packageName}\``);
+        throw err;
+      }
+    }
+
+    const mainModGoFileName = 'main__mod__.go';
+    const modMainGoContents = await readFile(
+      join(__dirname, mainModGoFileName),
+      'utf8',
+    );
+
+    let goPackageName = `${packageName}/${packageName}`;
+    const goFuncName = `${packageName}.${handlerFunctionName}`;
+
+    if (isGoModExist) {
+      const goModContents = await readFile(
+        `${entrypointDirname}/go.mod`,
+        'utf8',
+      );
+      goPackageName = `${
+        goModContents.split('\n')[0].split(' ')[1]
+      }/${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,
+    );
+
+    // move user go file to folder
+    try {
+      await move(
+        downloadedFiles[entrypoint].fsPath,
+        `${join(entrypointDirname, packageName, entrypoint)}`,
+      );
+    } catch (err) {
+      console.log('failed to move entry to package folder');
+      throw err;
+    }
+
+    console.log('tidy go.mod file');
+    try {
+      // ensure go.mod up-to-date
+      await go('mod', 'tidy');
+    } catch (err) {
+      console.log('failed to `go mod tidy`');
+      throw err;
+    }
+
+    console.log('Running `go build`...');
+    const destPath = join(outDir, 'handler');
+    try {
+      const src = [join(entrypointDirname, mainModGoFileName)];
+      await go.build({ src, dest: destPath });
+    } catch (err) {
+      console.log('failed to `go build`');
+      throw err;
+    }
+  } else {
+    const go = await createGo(
+      goPath,
+      process.platform,
+      process.arch,
+      {
+        cwd: entrypointDirname,
+      },
+      false,
+    );
+    const origianlMainGoContents = await readFile(
+      join(__dirname, 'main.go'),
+      'utf8',
+    );
+    const mainGoContents = origianlMainGoContents.replace(
+      '__NOW_HANDLER_FUNC_NAME',
+      handlerFunctionName,
+    );
+
+    // in order to allow the user to have `main.go`,
+    // we need our `main.go` to be called something else
+    const mainGoFileName = 'main__now__go__.go';
+
+    // Go doesn't like to build files in different directories,
+    // so now we place `main.go` together with the user code
+    await writeFile(join(entrypointDirname, mainGoFileName), mainGoContents);
+
+    // `go get` will look at `*.go` (note we set `cwd`), parse the `import`s
+    // and download any packages that aren't part of the stdlib
+    try {
+      await go.get();
+    } catch (err) {
+      console.log('failed to `go get`');
+      throw err;
+    }
+
+    console.log('Running `go build`...');
+    const destPath = join(outDir, 'handler');
+    try {
+      const src = [
+        join(entrypointDirname, mainGoFileName),
+        downloadedFiles[entrypoint].fsPath,
+      ];
+      await go.build({ src, dest: destPath });
+    } catch (err) {
+      console.log('failed to `go build`');
+      throw err;
+    }
   }
 
   const lambda = await createLambda({
@@ -133,4 +193,6 @@ exports.build = async ({ files, entrypoint }) => {
   return {
     [entrypoint]: lambda,
   };
-};
+}
+
+module.exports = { config, build };

packages/now-go/main.go

@@ -1,8 +1,8 @@
 package main
 
 import (
-	now "../../utils/go/bridge"
 	"net/http"
+	now "github.com/zeit/now-builders/utils/go/bridge"
 )
 
 func main() {

packages/now-go/main__mod__.go

@@ -0,0 +1,12 @@
+package main
+
+import (
+  "net/http"
+  "__NOW_HANDLER_PACKAGE_NAME"
+
+  now "github.com/zeit/now-builders/utils/go/bridge"
+)
+
+func main() {
+  now.Start(http.HandlerFunc(__NOW_HANDLER_FUNC_NAME))
+}

packages/now-go/package.json

@@ -1,30 +1,27 @@
 {
   "name": "@now/go",
-  "version": "0.2.12",
+  "version": "0.3.1-canary.1",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zeit/now-builders.git",
+    "directory": "packages/now-go"
+  },
   "scripts": {
-    "test": "best -I test/*.js",
-    "prepublish": "./build.sh"
+    "postinstall": "node ./util/install"
   },
   "files": [
-    "bin",
-    "download-go-bin.js",
-    "index.js",
-    "main.go"
+    "*.js",
+    "main.go",
+    "main__mod__.go",
+    "util"
   ],
   "dependencies": {
+    "debug": "^4.1.1",
     "execa": "^1.0.0",
     "fs-extra": "^7.0.0",
-    "lambda-git": "^0.1.2",
     "mkdirp-promise": "5.0.1",
     "node-fetch": "^2.2.1",
     "tar": "4.4.6"
-  },
-  "devDependencies": {
-    "@zeit/best": "0.4.3",
-    "rmfr": "2.0.0"
-  },
-  "peerDependencies": {
-    "@now/build-utils": ">=0.0.1"
   }
 }

packages/now-go/util/get-exported-function-name.go

@@ -34,7 +34,7 @@ func main() {
 		if fn.Name.IsExported() == true {
 			// we found the first exported function
 			// we're done!
-			fmt.Print(fn.Name.Name)
+			fmt.Print(fn.Name.Name, ",", parsed.Name.Name)
 			os.Exit(0)
 		}
 	}

packages/now-go/util/install.js

@@ -0,0 +1,18 @@
+const { join } = require('path');
+const { downloadGo } = require('../go-helpers');
+
+async function main() {
+  // First download the `go` binary for this platform/arch.
+  const go = await downloadGo();
+
+  // Build the `get-exported-function-name` helper program.
+  // `go get` is not necessary because the program has no external deps.
+  const src = join(__dirname, 'get-exported-function-name.go');
+  const dest = join(__dirname, '../get-exported-function-name');
+  await go.build({ src, dest });
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

packages/now-html-minifier/index.js

@@ -1,4 +1,4 @@
-const FileBlob = require('@now/build-utils/file-blob.js');
+const FileBlob = require('@now/build-utils/file-blob.js'); // eslint-disable-line import/no-extraneous-dependencies
 const { minify } = require('html-minifier');
 
 const defaultOptions = {

packages/now-html-minifier/package.json

@@ -1,11 +1,13 @@
 {
   "name": "@now/html-minifier",
-  "version": "1.0.7",
+  "version": "1.0.8-canary.0",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zeit/now-builders.git",
+    "directory": "packages/now-html-minifier"
+  },
   "dependencies": {
     "html-minifier": "3.5.21"
-  },
-  "peerDependencies": {
-    "@now/build-utils": ">=0.0.1"
   }
 }

packages/now-lambda/index.js

@@ -1,5 +1,5 @@
-const { Lambda } = require('@now/build-utils/lambda.js');
-const streamToBuffer = require('@now/build-utils/fs/stream-to-buffer.js');
+const { Lambda } = require('@now/build-utils/lambda.js'); // eslint-disable-line import/no-extraneous-dependencies
+const streamToBuffer = require('@now/build-utils/fs/stream-to-buffer.js'); // eslint-disable-line import/no-extraneous-dependencies
 
 exports.build = async ({ files, entrypoint, config }) => {
   if (!files[entrypoint]) throw new Error('Entrypoint not found in files');

packages/now-lambda/package.json

@@ -1,9 +1,11 @@
 {
   "name": "@now/lambda",
-  "version": "0.4.9",
+  "version": "0.4.10-canary.1",
   "license": "MIT",
-  "peerDependencies": {
-    "@now/build-utils": ">=0.0.1"
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zeit/now-builders.git",
+    "directory": "packages/now-lambda"
   },
   "scripts": {
     "test": "jest"

packages/now-lambda/test/test.js

@@ -7,7 +7,7 @@ const {
   testDeployment,
 } = require('../../../test/lib/deployment/test-deployment.js');
 
-jest.setTimeout(2 * 60 * 1000);
+jest.setTimeout(4 * 60 * 1000);
 const buildUtilsUrl = '@canary';
 let builderUrl;
 

packages/now-md/index.js

@@ -1,4 +1,4 @@
-const FileBlob = require('@now/build-utils/file-blob.js');
+const FileBlob = require('@now/build-utils/file-blob.js'); // eslint-disable-line import/no-extraneous-dependencies
 const unified = require('unified');
 const unifiedStream = require('unified-stream');
 const markdown = require('remark-parse');

packages/now-md/package.json

@@ -1,7 +1,12 @@
 {
   "name": "@now/md",
-  "version": "0.4.9",
+  "version": "0.4.10-canary.1",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zeit/now-builders.git",
+    "directory": "packages/now-md"
+  },
   "dependencies": {
     "rehype-document": "^2.2.0",
     "rehype-format": "^2.3.0",
@@ -11,9 +16,6 @@
     "unified": "^7.0.0",
     "unified-stream": "^1.0.2"
   },
-  "peerDependencies": {
-    "@now/build-utils": ">=0.0.1"
-  },
   "scripts": {
     "test": "jest"
   }

packages/now-md/test/test.js

@@ -7,7 +7,7 @@ const {
   testDeployment,
 } = require('../../../test/lib/deployment/test-deployment.js');
 
-jest.setTimeout(2 * 60 * 1000);
+jest.setTimeout(4 * 60 * 1000);
 const buildUtilsUrl = '@canary';
 let builderUrl;
 

packages/now-mdx-deck/index.js

@@ -1,10 +1,10 @@
-const download = require('@now/build-utils/fs/download.js');
+const download = require('@now/build-utils/fs/download.js'); // eslint-disable-line import/no-extraneous-dependencies
 const fs = require('fs');
 const { promisify } = require('util');
-const getWritableDirectory = require('@now/build-utils/fs/get-writable-directory.js');
-const glob = require('@now/build-utils/fs/glob.js');
+const getWritableDirectory = require('@now/build-utils/fs/get-writable-directory.js'); // eslint-disable-line import/no-extraneous-dependencies
+const glob = require('@now/build-utils/fs/glob.js'); // eslint-disable-line import/no-extraneous-dependencies
 const path = require('path');
-const { runNpmInstall } = require('@now/build-utils/fs/run-user-scripts.js');
+const { runNpmInstall } = require('@now/build-utils/fs/run-user-scripts.js'); // eslint-disable-line import/no-extraneous-dependencies
 
 const writeFile = promisify(fs.writeFile);
 

packages/now-mdx-deck/package.json

@@ -1,9 +1,11 @@
 {
   "name": "@now/mdx-deck",
-  "version": "0.4.18",
+  "version": "0.4.19-canary.1",
   "license": "MIT",
-  "peerDependencies": {
-    "@now/build-utils": ">=0.0.1"
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zeit/now-builders.git",
+    "directory": "packages/now-mdx-deck"
   },
   "scripts": {
     "test": "jest"

packages/now-mdx-deck/test/test.js

@@ -7,7 +7,7 @@ const {
   testDeployment,
 } = require('../../../test/lib/deployment/test-deployment.js');
 
-jest.setTimeout(2 * 60 * 1000);
+jest.setTimeout(4 * 60 * 1000);
 const buildUtilsUrl = '@canary';
 let builderUrl;
 

packages/now-next/index.js

@@ -1,24 +1,31 @@
-const { createLambda } = require('@now/build-utils/lambda.js');
-const download = require('@now/build-utils/fs/download.js');
-const FileFsRef = require('@now/build-utils/file-fs-ref.js');
-const FileBlob = require('@now/build-utils/file-blob');
+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 FileFsRef = require('@now/build-utils/file-fs-ref.js'); // eslint-disable-line import/no-extraneous-dependencies
+const FileBlob = require('@now/build-utils/file-blob'); // eslint-disable-line import/no-extraneous-dependencies
 const path = require('path');
-const { readFile, writeFile, unlink } = require('fs.promised');
 const {
   runNpmInstall,
   runPackageJsonScript,
-} = require('@now/build-utils/fs/run-user-scripts.js');
-const glob = require('@now/build-utils/fs/glob.js');
+} = require('@now/build-utils/fs/run-user-scripts.js'); // eslint-disable-line import/no-extraneous-dependencies
+const glob = require('@now/build-utils/fs/glob.js'); // eslint-disable-line import/no-extraneous-dependencies
+const {
+  readFile,
+  writeFile,
+  unlink: unlinkFile,
+  remove: removePath,
+  mkdirp,
+  rename: renamePath,
+  pathExists,
+} = require('fs-extra');
 const semver = require('semver');
 const nextLegacyVersions = require('./legacy-versions');
 const {
   excludeFiles,
   validateEntrypoint,
   includeOnlyEntryDirectory,
-  moveEntryDirectoryToRoot,
   normalizePackageJson,
-  excludeStaticDirectory,
   onlyStaticDirectory,
+  getNextConfig,
 } = require('./utils');
 
 /** @typedef { import('@now/build-utils/file-ref').Files } Files */
@@ -33,15 +40,17 @@ const {
 
 /**
  * Read package.json from files
- * @param {DownloadedFiles} files
+ * @param {string} entryPath
  */
-async function readPackageJson(files) {
-  if (!files['package.json']) {
+async function readPackageJson(entryPath) {
+  const packagePath = path.join(entryPath, 'package.json');
+
+  try {
+    return JSON.parse(await readFile(packagePath, 'utf8'));
+  } catch (err) {
+    console.log('package.json not found in entry');
     return {};
   }
-
-  const packageJsonPath = files['package.json'].fsPath;
-  return JSON.parse(await readFile(packageJsonPath, 'utf8'));
 }
 
 /**
@@ -68,6 +77,36 @@ async function writeNpmRc(workPath, token) {
   );
 }
 
+function getNextVersion(packageJson) {
+  let nextVersion;
+  if (packageJson.dependencies && packageJson.dependencies.next) {
+    nextVersion = packageJson.dependencies.next;
+  } else if (packageJson.devDependencies && packageJson.devDependencies.next) {
+    nextVersion = packageJson.devDependencies.next;
+  }
+  return nextVersion;
+}
+
+function isLegacyNext(nextVersion) {
+  // If version is using the dist-tag instead of a version range
+  if (nextVersion === 'canary' || nextVersion === 'latest') {
+    return false;
+  }
+
+  // If the version is an exact match with the legacy versions
+  if (nextLegacyVersions.indexOf(nextVersion) !== -1) {
+    return true;
+  }
+
+  const maxSatisfying = semver.maxSatisfying(nextLegacyVersions, nextVersion);
+  // When the version can't be matched with legacy versions, so it must be a newer version
+  if (maxSatisfying === null) {
+    return false;
+  }
+
+  return true;
+}
+
 exports.config = {
   maxLambdaSize: '5mb',
 };
@@ -81,76 +120,49 @@ exports.build = async ({ files, workPath, entrypoint }) => {
 
   console.log('downloading user files...');
   const entryDirectory = path.dirname(entrypoint);
-  const filesOnlyEntryDirectory = includeOnlyEntryDirectory(
-    files,
-    entryDirectory,
-  );
-  const filesWithEntryDirectoryRoot = moveEntryDirectoryToRoot(
-    filesOnlyEntryDirectory,
-    entryDirectory,
-  );
-  const filesWithoutStaticDirectory = excludeStaticDirectory(
-    filesWithEntryDirectoryRoot,
-  );
-  const downloadedFiles = await download(filesWithoutStaticDirectory, workPath);
+  await download(files, workPath);
+  const entryPath = path.join(workPath, entryDirectory);
 
-  const pkg = await readPackageJson(downloadedFiles);
-
-  let nextVersion;
-  if (pkg.dependencies && pkg.dependencies.next) {
-    nextVersion = pkg.dependencies.next;
-  } else if (pkg.devDependencies && pkg.devDependencies.next) {
-    nextVersion = pkg.devDependencies.next;
+  if (await pathExists(path.join(entryPath, '.next'))) {
+    console.warn(
+      'WARNING: You should probably not upload the `.next` directory. See https://zeit.co/docs/v2/deployments/official-builders/next-js-now-next/ for more information.',
+    );
   }
 
+  const pkg = await readPackageJson(entryPath);
+
+  const nextVersion = getNextVersion(pkg);
   if (!nextVersion) {
     throw new Error(
       'No Next.js version could be detected in "package.json". Make sure `"next"` is installed in "dependencies" or "devDependencies"',
     );
   }
 
-  const isLegacy = (() => {
-    // If version is using the dist-tag instead of a version range
-    if (nextVersion === 'canary' || nextVersion === 'latest') {
-      return false;
-    }
-
-    // If the version is an exact match with the legacy versions
-    if (nextLegacyVersions.indexOf(nextVersion) !== -1) {
-      return true;
-    }
-
-    const maxSatisfying = semver.maxSatisfying(nextLegacyVersions, nextVersion);
-    // When the version can't be matched with legacy versions, so it must be a newer version
-    if (maxSatisfying === null) {
-      return false;
-    }
-
-    return true;
-  })();
+  const isLegacy = isLegacyNext(nextVersion);
 
   console.log(`MODE: ${isLegacy ? 'legacy' : 'serverless'}`);
 
   if (isLegacy) {
     try {
-      await unlink(path.join(workPath, 'yarn.lock'));
+      await unlinkFile(path.join(entryPath, 'yarn.lock'));
     } catch (err) {
       console.log('no yarn.lock removed');
     }
 
     try {
-      await unlink(path.join(workPath, 'package-lock.json'));
+      await unlinkFile(path.join(entryPath, 'package-lock.json'));
     } catch (err) {
       console.log('no package-lock.json removed');
     }
 
     console.warn(
-      "WARNING: your application is being deployed in @now/next's legacy mode.",
+      "WARNING: your application is being deployed in @now/next's legacy mode. http://err.sh/zeit/now-builders/now-next-legacy-mode",
     );
+
     console.log('normalizing package.json');
     const packageJson = normalizePackageJson(pkg);
     console.log('normalized package.json result: ', packageJson);
-    await writePackageJson(workPath, 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',
@@ -160,38 +172,38 @@ exports.build = async ({ files, workPath, entrypoint }) => {
       ...(pkg.scripts || {}),
     };
     console.log('normalized package.json result: ', pkg);
-    await writePackageJson(workPath, pkg);
+    await writePackageJson(entryPath, pkg);
   }
 
   if (process.env.NPM_AUTH_TOKEN) {
     console.log('found NPM_AUTH_TOKEN in environment, creating .npmrc');
-    await writeNpmRc(workPath, process.env.NPM_AUTH_TOKEN);
+    await writeNpmRc(entryPath, process.env.NPM_AUTH_TOKEN);
   }
 
   console.log('installing dependencies...');
-  await runNpmInstall(workPath, ['--prefer-offline']);
+  await runNpmInstall(entryPath, ['--prefer-offline']);
   console.log('running user script...');
-  await runPackageJsonScript(workPath, 'now-build');
+  await runPackageJsonScript(entryPath, 'now-build');
 
   if (isLegacy) {
     console.log('running npm install --production...');
-    await runNpmInstall(workPath, ['--prefer-offline', '--production']);
+    await runNpmInstall(entryPath, ['--prefer-offline', '--production']);
   }
 
   if (process.env.NPM_AUTH_TOKEN) {
-    await unlink(path.join(workPath, '.npmrc'));
+    await unlinkFile(path.join(entryPath, '.npmrc'));
   }
 
   const lambdas = {};
 
   if (isLegacy) {
-    const filesAfterBuild = await glob('**', workPath);
+    const filesAfterBuild = await glob('**', entryPath);
 
     console.log('preparing lambda files...');
     let buildId;
     try {
       buildId = await readFile(
-        path.join(workPath, '.next', 'BUILD_ID'),
+        path.join(entryPath, '.next', 'BUILD_ID'),
         'utf8',
       );
     } catch (err) {
@@ -200,10 +212,10 @@ exports.build = async ({ files, workPath, entrypoint }) => {
       );
       throw new Error('Missing BUILD_ID');
     }
-    const dotNextRootFiles = await glob('.next/*', workPath);
-    const dotNextServerRootFiles = await glob('.next/server/*', workPath);
+    const dotNextRootFiles = await glob('.next/*', entryPath);
+    const dotNextServerRootFiles = await glob('.next/server/*', entryPath);
     const nodeModules = excludeFiles(
-      await glob('node_modules/**', workPath),
+      await glob('node_modules/**', entryPath),
       file => file.startsWith('node_modules/.cache'),
     );
     const launcherFiles = {
@@ -220,7 +232,7 @@ exports.build = async ({ files, workPath, entrypoint }) => {
     }
     const pages = await glob(
       '**/*.js',
-      path.join(workPath, '.next', 'server', 'static', buildId, 'pages'),
+      path.join(entryPath, '.next', 'server', 'static', buildId, 'pages'),
     );
     const launcherPath = path.join(__dirname, 'legacy-launcher.js');
     const launcherData = await readFile(launcherPath, 'utf8');
@@ -276,17 +288,37 @@ exports.build = async ({ files, workPath, entrypoint }) => {
     };
     const pages = await glob(
       '**/*.js',
-      path.join(workPath, '.next', 'serverless', 'pages'),
+      path.join(entryPath, '.next', 'serverless', 'pages'),
     );
 
     const pageKeys = Object.keys(pages);
 
     if (pageKeys.length === 0) {
+      const nextConfig = await getNextConfig(workPath, entryPath);
+
+      if (nextConfig != null) {
+        console.info('Found next.config.js:');
+        console.info(nextConfig);
+        console.info();
+      }
+
       throw new Error(
         'No serverless pages were built. https://err.sh/zeit/now-builders/now-next-no-serverless-pages-built',
       );
     }
 
+    // An optional assets folder that is placed alongside every page entrypoint
+    const assets = await glob(
+      'assets/**',
+      path.join(entryPath, '.next', 'serverless'),
+    );
+
+    const assetKeys = Object.keys(assets);
+    if (assetKeys.length > 0) {
+      console.log('detected assets to be bundled with lambda:');
+      assetKeys.forEach(assetFile => console.log(`\t${assetFile}`));
+    }
+
     await Promise.all(
       pageKeys.map(async (page) => {
         // These default pages don't have to be handled as they'd always 404
@@ -300,6 +332,7 @@ exports.build = async ({ files, workPath, entrypoint }) => {
         lambdas[path.join(entryDirectory, pathname)] = await createLambda({
           files: {
             ...launcherFiles,
+            ...assets,
             'page.js': pages[page],
           },
           handler: 'now__launcher.launcher',
@@ -312,7 +345,7 @@ exports.build = async ({ files, workPath, entrypoint }) => {
 
   const nextStaticFiles = await glob(
     '**',
-    path.join(workPath, '.next', 'static'),
+    path.join(entryPath, '.next', 'static'),
   );
   const staticFiles = Object.keys(nextStaticFiles).reduce(
     (mappedFiles, file) => ({
@@ -322,14 +355,46 @@ exports.build = async ({ files, workPath, entrypoint }) => {
     {},
   );
 
-  const nextStaticDirectory = onlyStaticDirectory(filesWithEntryDirectoryRoot);
-  const staticDirectoryFiles = Object.keys(nextStaticDirectory).reduce(
-    (mappedFiles, file) => ({
-      ...mappedFiles,
-      [path.join(entryDirectory, file)]: nextStaticDirectory[file],
-    }),
-    {},
+  const staticDirectoryFiles = onlyStaticDirectory(
+    includeOnlyEntryDirectory(files, entryDirectory),
+    entryDirectory,
   );
 
   return { ...lambdas, ...staticFiles, ...staticDirectoryFiles };
 };
+
+exports.prepareCache = async ({ cachePath, workPath, entrypoint }) => {
+  console.log('preparing cache ...');
+
+  const entryDirectory = path.dirname(entrypoint);
+  const entryPath = path.join(workPath, entryDirectory);
+  const cacheEntryPath = path.join(cachePath, entryDirectory);
+
+  const pkg = await readPackageJson(entryPath);
+  const nextVersion = getNextVersion(pkg);
+  const isLegacy = isLegacyNext(nextVersion);
+
+  if (isLegacy) {
+    // skip caching legacy mode (swapping deps between all and production can get bug-prone)
+    return {};
+  }
+
+  console.log('clearing old cache ...');
+  await removePath(cacheEntryPath);
+  await mkdirp(cacheEntryPath);
+
+  console.log('copying build files for cache ...');
+  await renamePath(entryPath, cacheEntryPath);
+
+  console.log('producing cache file manifest ...');
+
+  const cacheEntrypoint = path.relative(cachePath, cacheEntryPath);
+  return {
+    ...(await glob(
+      path.join(cacheEntrypoint, 'node_modules/{**,!.*,.yarn*,.cache/next-minifier/**}'),
+      cachePath,
+    )),
+    ...(await glob(path.join(cacheEntrypoint, 'package-lock.json'), cachePath)),
+    ...(await glob(path.join(cacheEntrypoint, 'yarn.lock'), cachePath)),
+  };
+};

packages/now-next/launcher.js

@@ -4,10 +4,8 @@ const { Server } = require('http');
 const { Bridge } = require('./now__bridge.js');
 const page = require('./page.js');
 
-const bridge = new Bridge();
-bridge.port = 3000;
-
 const server = new Server(page.render);
-server.listen(bridge.port);
+const bridge = new Bridge(server);
+bridge.listen();
 
 exports.launcher = bridge.launcher;

packages/now-next/legacy-launcher.js

@@ -3,9 +3,6 @@ const next = require('next-server');
 const url = require('url');
 const { Bridge } = require('./now__bridge.js');
 
-const bridge = new Bridge();
-bridge.port = 3000;
-
 process.env.NODE_ENV = 'production';
 
 const app = next({});
@@ -14,6 +11,8 @@ const server = new Server((req, res) => {
   const parsedUrl = url.parse(req.url, true);
   app.render(req, res, 'PATHNAME_PLACEHOLDER', parsedUrl.query, parsedUrl);
 });
-server.listen(bridge.port);
+
+const bridge = new Bridge(server);
+bridge.listen();
 
 exports.launcher = bridge.launcher;

packages/now-next/package.json

@@ -1,14 +1,16 @@
 {
   "name": "@now/next",
-  "version": "0.0.84",
+  "version": "0.1.3-canary.1",
   "license": "MIT",
-  "dependencies": {
-    "@now/node-bridge": "0.1.4",
-    "execa": "^1.0.0",
-    "fs.promised": "^3.0.0",
-    "semver": "^5.6.0"
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zeit/now-builders.git",
+    "directory": "packages/now-next"
   },
-  "peerDependencies": {
-    "@now/build-utils": ">=0.0.1"
+  "dependencies": {
+    "@now/node-bridge": "^1.0.0",
+    "execa": "^1.0.0",
+    "fs-extra": "^7.0.0",
+    "semver": "^5.6.0"
   }
 }

packages/now-next/utils.js

@@ -1,4 +1,5 @@
-const rename = require('@now/build-utils/fs/rename.js');
+const fs = require('fs-extra');
+const path = require('path');
 
 /** @typedef { import('@now/build-utils/file-ref') } FileRef */
 /** @typedef { import('@now/build-utils/file-fs-ref') } FileFsRef */
@@ -64,24 +65,6 @@ function includeOnlyEntryDirectory(files, entryDirectory) {
   return excludeFiles(files, matcher);
 }
 
-/**
- * Moves all files under the entry directory to the root directory
- * @param {Files} files
- * @param {string} entryDirectory
- * @returns {Files}
- */
-function moveEntryDirectoryToRoot(files, entryDirectory) {
-  if (entryDirectory === '.') {
-    return files;
-  }
-
-  function delegate(filePath) {
-    return filePath.replace(new RegExp(`^${entryDirectory}/`), '');
-  }
-
-  return rename(files, delegate);
-}
-
 /**
  * Exclude package manager lockfiles from files
  * @param {Files} files
@@ -99,26 +82,13 @@ function excludeLockFiles(files) {
 }
 
 /**
- * Exclude the static directory from files
+ * Include the static directory from files
  * @param {Files} files
  * @returns {Files}
  */
-function excludeStaticDirectory(files) {
+function onlyStaticDirectory(files, entryDir) {
   function matcher(filePath) {
-    return filePath.startsWith('static');
-  }
-
-  return excludeFiles(files, matcher);
-}
-
-/**
- * Exclude the static directory from files
- * @param {Files} files
- * @returns {Files}
- */
-function onlyStaticDirectory(files) {
-  function matcher(filePath) {
-    return !filePath.startsWith('static');
+    return !filePath.startsWith(path.join(entryDir, 'static'));
   }
 
   return excludeFiles(files, matcher);
@@ -169,13 +139,26 @@ function normalizePackageJson(defaultPackageJson = {}) {
   };
 }
 
+async function getNextConfig(workPath, entryPath) {
+  const entryConfig = path.join(entryPath, './next.config.js');
+  if (await fs.pathExists(entryConfig)) {
+    return fs.readFile(entryConfig, 'utf8');
+  }
+
+  const workConfig = path.join(workPath, './next.config.js');
+  if (await fs.pathExists(workConfig)) {
+    return fs.readFile(workConfig, 'utf8');
+  }
+
+  return null;
+}
+
 module.exports = {
   excludeFiles,
   validateEntrypoint,
   includeOnlyEntryDirectory,
-  moveEntryDirectoryToRoot,
   excludeLockFiles,
   normalizePackageJson,
-  excludeStaticDirectory,
   onlyStaticDirectory,
+  getNextConfig,
 };

packages/now-node-bridge/.eslintrc

@@ -0,0 +1,24 @@
+{
+  "extends": ["prettier", "airbnb-base"],
+  "rules": {
+    "no-console": 0,
+    "import/no-unresolved": 0,
+    "import/no-dynamic-require": 0,
+    "global-require": 0
+  },
+  "overrides": [
+    {
+      "files": ["test/**"],
+      "rules": {
+        "import/no-extraneous-dependencies": 0
+      },
+      "globals": {
+        "describe": true,
+        "it": true,
+        "test": true,
+        "expect": true
+      }
+    }
+  ]
+}
+

packages/now-node-bridge/.gitignore

@@ -0,0 +1 @@
+/bridge.*

packages/now-node-bridge/bridge.js

@@ -1,110 +0,0 @@
-const http = require('http');
-
-function normalizeEvent(event) {
-  let isApiGateway = true;
-
-  if (event.Action === 'Invoke') {
-    isApiGateway = false;
-    const invokeEvent = JSON.parse(event.body);
-
-    const {
-      method, path, headers, encoding,
-    } = invokeEvent;
-
-    let { body } = invokeEvent;
-
-    if (body) {
-      if (encoding === 'base64') {
-        body = Buffer.from(body, encoding);
-      } else if (encoding === undefined) {
-        body = Buffer.from(body);
-      } else {
-        throw new Error(`Unsupported encoding: ${encoding}`);
-      }
-    }
-
-    return {
-      isApiGateway, method, path, headers, body,
-    };
-  }
-
-  const {
-    httpMethod: method, path, headers, body,
-  } = event;
-
-  return {
-    isApiGateway, method, path, headers, body,
-  };
-}
-
-class Bridge {
-  constructor() {
-    this.launcher = this.launcher.bind(this);
-  }
-
-  launcher(event) {
-    // eslint-disable-next-line consistent-return
-    return new Promise((resolve, reject) => {
-      if (this.userError) {
-        console.error('Error while initializing entrypoint:', this.userError);
-        return resolve({ statusCode: 500, body: '' });
-      }
-
-      if (!this.port) {
-        return resolve({ statusCode: 504, body: '' });
-      }
-
-      const {
-        isApiGateway, method, path, headers, body,
-      } = normalizeEvent(event);
-
-      const opts = {
-        hostname: '127.0.0.1',
-        port: this.port,
-        path,
-        method,
-        headers,
-      };
-
-      const req = http.request(opts, (res) => {
-        const response = res;
-        const respBodyChunks = [];
-        response.on('data', chunk => respBodyChunks.push(Buffer.from(chunk)));
-        response.on('error', reject);
-        response.on('end', () => {
-          const bodyBuffer = Buffer.concat(respBodyChunks);
-          delete response.headers.connection;
-
-          if (isApiGateway) {
-            delete response.headers['content-length'];
-          } else
-          if (response.headers['content-length']) {
-            response.headers['content-length'] = bodyBuffer.length;
-          }
-
-          resolve({
-            statusCode: response.statusCode,
-            headers: response.headers,
-            body: bodyBuffer.toString('base64'),
-            encoding: 'base64',
-          });
-        });
-      });
-
-      req.on('error', (error) => {
-        setTimeout(() => {
-          // this lets express print the true error of why the connection was closed.
-          // it is probably 'Cannot set headers after they are sent to the client'
-          reject(error);
-        }, 2);
-      });
-
-      if (body) req.write(body);
-      req.end();
-    });
-  }
-}
-
-module.exports = {
-  Bridge,
-};

packages/now-node-bridge/package.json

@@ -1,8 +1,26 @@
 {
   "name": "@now/node-bridge",
-  "version": "0.1.10",
+  "version": "1.0.1-canary.0",
   "license": "MIT",
-  "peerDependencies": {
-    "@now/build-utils": ">=0.0.1"
+  "main": "./index.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zeit/now-builders.git",
+    "directory": "packages/now-node-bridge"
+  },
+  "files": [
+    "bridge.*",
+    "index.js"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "npm run build && jest",
+    "prepublish": "npm run build"
+  },
+  "devDependencies": {
+    "@types/aws-lambda": "8.10.19",
+    "@types/node": "11.9.4",
+    "jest": "24.1.0",
+    "typescript": "3.3.3"
   }
 }

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

@@ -0,0 +1,183 @@
+import { AddressInfo } from 'net';
+import { APIGatewayProxyEvent } from 'aws-lambda';
+import {
+  Server,
+  IncomingHttpHeaders,
+  OutgoingHttpHeaders,
+  request
+} from 'http';
+
+interface NowProxyEvent {
+  Action: string;
+  body: string;
+}
+
+export interface NowProxyRequest {
+  isApiGateway?: boolean;
+  method: string;
+  path: string;
+  headers: IncomingHttpHeaders;
+  body: Buffer;
+}
+
+export interface NowProxyResponse {
+  statusCode: number;
+  headers: OutgoingHttpHeaders;
+  body: string;
+  encoding: string;
+}
+
+function normalizeNowProxyEvent(event: NowProxyEvent): NowProxyRequest {
+  let bodyBuffer: Buffer | null;
+  const { method, path, headers, encoding, body } = JSON.parse(event.body);
+
+  if (body) {
+    if (encoding === 'base64') {
+      bodyBuffer = Buffer.from(body, encoding);
+    } else if (encoding === undefined) {
+      bodyBuffer = Buffer.from(body);
+    } else {
+      throw new Error(`Unsupported encoding: ${encoding}`);
+    }
+  } else {
+    bodyBuffer = Buffer.alloc(0);
+  }
+
+  return { isApiGateway: false, method, path, headers, body: bodyBuffer };
+}
+
+function normalizeAPIGatewayProxyEvent(
+  event: APIGatewayProxyEvent
+): NowProxyRequest {
+  let bodyBuffer: Buffer | null;
+  const { httpMethod: method, path, headers, body } = event;
+
+  if (body) {
+    if (event.isBase64Encoded) {
+      bodyBuffer = Buffer.from(body, 'base64');
+    } else {
+      bodyBuffer = Buffer.from(body);
+    }
+  } else {
+    bodyBuffer = Buffer.alloc(0);
+  }
+
+  return { isApiGateway: true, method, path, headers, body: bodyBuffer };
+}
+
+function normalizeEvent(
+  event: NowProxyEvent | APIGatewayProxyEvent
+): NowProxyRequest {
+  if ('Action' in event) {
+    if (event.Action === 'Invoke') {
+      return normalizeNowProxyEvent(event);
+    } else {
+      throw new Error(`Unexpected event.Action: ${event.Action}`);
+    }
+  } else {
+    return normalizeAPIGatewayProxyEvent(event);
+  }
+}
+
+export class Bridge {
+  private server: Server | null;
+  private listening: Promise<AddressInfo>;
+  private resolveListening: (info: AddressInfo) => void;
+
+  constructor(server?: Server) {
+    this.server = null;
+    if (server) {
+      this.setServer(server);
+    }
+    this.launcher = this.launcher.bind(this);
+
+    // This is just to appease TypeScript strict mode, since it doesn't
+    // understand that the Promise constructor is synchronous
+    this.resolveListening = (info: AddressInfo) => {};
+
+    this.listening = new Promise(resolve => {
+      this.resolveListening = resolve;
+    });
+  }
+
+  setServer(server: Server) {
+    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() {
+    if (!this.server) {
+      throw new Error('Server has not been set!');
+    }
+
+    return this.server.listen({
+      host: '127.0.0.1',
+      port: 0
+    });
+  }
+
+  async launcher(
+    event: NowProxyEvent | APIGatewayProxyEvent
+  ): Promise<NowProxyResponse> {
+    const { port } = await this.listening;
+
+    const { isApiGateway, method, path, headers, body } = normalizeEvent(
+      event
+    );
+
+    const opts = {
+      hostname: '127.0.0.1',
+      port,
+      path,
+      method,
+      headers
+    };
+
+    // eslint-disable-next-line consistent-return
+    return new Promise((resolve, reject) => {
+      const req = request(opts, res => {
+        const response = res;
+        const respBodyChunks: Buffer[] = [];
+        response.on('data', chunk => respBodyChunks.push(Buffer.from(chunk)));
+        response.on('error', reject);
+        response.on('end', () => {
+          const bodyBuffer = Buffer.concat(respBodyChunks);
+          delete response.headers.connection;
+
+          if (isApiGateway) {
+            delete response.headers['content-length'];
+          } else if (response.headers['content-length']) {
+            response.headers['content-length'] = String(bodyBuffer.length);
+          }
+
+          resolve({
+            statusCode: response.statusCode || 200,
+            headers: response.headers,
+            body: bodyBuffer.toString('base64'),
+            encoding: 'base64'
+          });
+        });
+      });
+
+      req.on('error', error => {
+        setTimeout(() => {
+          // this lets express print the true error of why the connection was closed.
+          // it is probably 'Cannot set headers after they are sent to the client'
+          reject(error);
+        }, 2);
+      });
+
+      if (body) req.write(body);
+      req.end();
+    });
+  }
+}

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

@@ -0,0 +1,71 @@
+const assert = require('assert');
+const { Server } = require('http');
+const { Bridge } = require('../bridge');
+
+test('port binding', async () => {
+  const server = new Server();
+  const bridge = new Bridge(server);
+  bridge.listen();
+
+  // Test port binding
+  const info = await bridge.listening;
+  assert.equal(info.address, '127.0.0.1');
+  assert.equal(typeof info.port, 'number');
+
+  server.close();
+});
+
+test('`APIGatewayProxyEvent` normalizing', async () => {
+  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,
+  });
+  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');
+
+  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 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',
+    }),
+  });
+  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');
+
+  server.close();
+});

packages/now-node-bridge/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "es6",
+    "module": "commonjs",
+    "outDir": ".",
+    "strict": true,
+    "sourceMap": true,
+    "declaration": true
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}

packages/now-node-server/index.js

@@ -1,15 +1,15 @@
-const { createLambda } = require('@now/build-utils/lambda.js');
-const download = require('@now/build-utils/fs/download.js');
-const FileBlob = require('@now/build-utils/file-blob.js');
-const FileFsRef = require('@now/build-utils/file-fs-ref.js');
+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');
+const glob = require('@now/build-utils/fs/glob.js'); // eslint-disable-line import/no-extraneous-dependencies
 const path = require('path');
-const rename = require('@now/build-utils/fs/rename.js');
+const rename = require('@now/build-utils/fs/rename.js'); // eslint-disable-line import/no-extraneous-dependencies
 const {
   runNpmInstall,
   runPackageJsonScript,
-} = require('@now/build-utils/fs/run-user-scripts.js');
+} = require('@now/build-utils/fs/run-user-scripts.js'); // eslint-disable-line import/no-extraneous-dependencies
 
 /** @typedef { import('@now/build-utils/file-ref') } FileRef */
 /** @typedef {{[filePath: string]: FileRef}} Files */
@@ -37,7 +37,7 @@ async function downloadInstallAndBundle(
   console.log('downloading user files...');
   const downloadedFiles = await download(files, userPath);
 
-  console.log('installing dependencies for user\'s code...');
+  console.log("installing dependencies for user's code...");
   const entrypointFsDirname = path.join(userPath, path.dirname(entrypoint));
   await runNpmInstall(entrypointFsDirname, npmArguments);
 
@@ -46,8 +46,9 @@ async function downloadInstallAndBundle(
     {
       'package.json': new FileBlob({
         data: JSON.stringify({
+          license: 'UNLICENSED',
           dependencies: {
-            '@zeit/ncc': '0.11.0',
+            '@zeit/ncc': '0.16.1',
           },
         }),
       }),
@@ -63,7 +64,7 @@ async function downloadInstallAndBundle(
 async function compile(workNccPath, downloadedFiles, entrypoint) {
   const input = downloadedFiles[entrypoint].fsPath;
   const ncc = require(path.join(workNccPath, 'node_modules/@zeit/ncc'));
-  const { code, assets } = await ncc(input);
+  const { code, assets } = await ncc(input, { sourceMap: true });
 
   const preparedFiles = {};
   const blob = new FileBlob({ data: code });

packages/now-node-server/launcher.js

@@ -4,22 +4,16 @@ const { Bridge } = require('./bridge.js');
 const bridge = new Bridge();
 
 const saveListen = Server.prototype.listen;
-Server.prototype.listen = function listen(...args) {
-  this.on('listening', function listening() {
-    bridge.port = this.address().port;
-  });
-  saveListen.apply(this, args);
+Server.prototype.listen = function listen() {
+  bridge.setServer(this);
+  Server.prototype.listen = saveListen;
+  return bridge.listen();
 };
 
-try {
-  if (!process.env.NODE_ENV) {
-    process.env.NODE_ENV = 'production';
-  }
-
-  // PLACEHOLDER
-} catch (error) {
-  console.error(error);
-  bridge.userError = error;
+if (!process.env.NODE_ENV) {
+  process.env.NODE_ENV = 'production';
 }
 
+// PLACEHOLDER
+
 exports.launcher = bridge.launcher;

packages/now-node-server/package.json

@@ -1,13 +1,15 @@
 {
   "name": "@now/node-server",
-  "version": "0.4.26",
+  "version": "0.5.2-canary.2",
   "license": "MIT",
-  "dependencies": {
-    "@now/node-bridge": "^0.1.10",
-    "fs-extra": "7.0.1"
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zeit/now-builders.git",
+    "directory": "packages/now-node-server"
   },
-  "peerDependencies": {
-    "@now/build-utils": ">=0.0.1"
+  "dependencies": {
+    "@now/node-bridge": "^1.0.1-canary.0",
+    "fs-extra": "7.0.1"
   },
   "scripts": {
     "test": "jest"

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

@@ -7,7 +7,7 @@ const {
   testDeployment,
 } = require('../../../test/lib/deployment/test-deployment.js');
 
-jest.setTimeout(2 * 60 * 1000);
+jest.setTimeout(4 * 60 * 1000);
 const buildUtilsUrl = '@canary';
 let builderUrl;
 

packages/now-node/.gitignore

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

packages/now-node/.npmignore

@@ -1 +0,0 @@
-/test

packages/now-node/build.sh

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

packages/now-node/launcher.js

@@ -1,22 +0,0 @@
-const { Server } = require('http');
-const { Bridge } = require('./bridge.js');
-
-const bridge = new Bridge();
-bridge.port = 3000;
-let listener;
-
-try {
-  if (!process.env.NODE_ENV) {
-    process.env.NODE_ENV = 'production';
-  }
-
-  // PLACEHOLDER
-} catch (error) {
-  console.error(error);
-  bridge.userError = error;
-}
-
-const server = new Server(listener);
-server.listen(bridge.port);
-
-exports.launcher = bridge.launcher;

packages/now-node/package.json

@@ -1,15 +1,28 @@
 {
   "name": "@now/node",
-  "version": "0.4.28",
+  "version": "0.5.2-canary.4",
   "license": "MIT",
+  "main": "./dist/index",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zeit/now-builders.git",
+    "directory": "packages/now-node"
+  },
   "dependencies": {
-    "@now/node-bridge": "^0.1.10",
+    "@now/node-bridge": "^1.0.1-canary.0",
     "fs-extra": "7.0.1"
   },
-  "peerDependencies": {
-    "@now/build-utils": ">=0.0.1"
-  },
   "scripts": {
-    "test": "jest"
+    "build": "./build.sh",
+    "test": "npm run build && jest",
+    "prepublish": "npm run build"
+  },
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@types/node": "11.9.4",
+    "jest": "24.1.0",
+    "typescript": "3.3.3"
   }
 }

packages/now-node/src/index.ts

@@ -1,14 +1,14 @@
-const { createLambda } = require('@now/build-utils/lambda.js');
-const download = require('@now/build-utils/fs/download.js');
-const FileBlob = require('@now/build-utils/file-blob.js');
-const FileFsRef = require('@now/build-utils/file-fs-ref.js');
-const fs = require('fs-extra');
-const glob = require('@now/build-utils/fs/glob.js');
-const path = require('path');
-const {
+import { join, dirname } from 'path';
+import { remove, readFile } from 'fs-extra';
+import * as glob from '@now/build-utils/fs/glob.js';
+import * as download from '@now/build-utils/fs/download.js';
+import * as FileBlob from '@now/build-utils/file-blob.js';
+import * as FileFsRef from '@now/build-utils/file-fs-ref.js';
+import { createLambda } from '@now/build-utils/lambda.js';
+import {
   runNpmInstall,
-  runPackageJsonScript,
-} = require('@now/build-utils/fs/run-user-scripts.js');
+  runPackageJsonScript
+} from '@now/build-utils/fs/run-user-scripts.js';
 
 /** @typedef { import('@now/build-utils/file-ref') } FileRef */
 /** @typedef {{[filePath: string]: FileRef}} Files */
@@ -27,16 +27,16 @@ const {
  */
 async function downloadInstallAndBundle(
   { files, entrypoint, workPath },
-  { npmArguments = [] } = {},
+  { npmArguments = [] } = {}
 ) {
-  const userPath = path.join(workPath, 'user');
-  const nccPath = path.join(workPath, 'ncc');
+  const userPath = join(workPath, 'user');
+  const nccPath = join(workPath, 'ncc');
 
   console.log('downloading user files...');
   const downloadedFiles = await download(files, userPath);
 
-  console.log('installing dependencies for user\'s code...');
-  const entrypointFsDirname = path.join(userPath, path.dirname(entrypoint));
+  console.log("installing dependencies for user's code...");
+  const entrypointFsDirname = join(userPath, dirname(entrypoint));
   await runNpmInstall(entrypointFsDirname, npmArguments);
 
   console.log('writing ncc package.json...');
@@ -44,13 +44,14 @@ async function downloadInstallAndBundle(
     {
       'package.json': new FileBlob({
         data: JSON.stringify({
+          license: 'UNLICENSED',
           dependencies: {
-            '@zeit/ncc': '0.11.0',
-          },
-        }),
-      }),
+            '@zeit/ncc': '0.16.1',
+          }
+        })
+      })
     },
-    nccPath,
+    nccPath
   );
 
   console.log('installing dependencies for ncc...');
@@ -58,43 +59,41 @@ async function downloadInstallAndBundle(
   return [downloadedFiles, nccPath, entrypointFsDirname];
 }
 
-async function compile(workNccPath, downloadedFiles, entrypoint) {
+async function compile(workNccPath: string, downloadedFiles, entrypoint: string) {
   const input = downloadedFiles[entrypoint].fsPath;
-  const ncc = require(path.join(workNccPath, 'node_modules/@zeit/ncc'));
+  const ncc = require(join(workNccPath, 'node_modules/@zeit/ncc'));
   const { code, assets } = await ncc(input);
 
   const preparedFiles = {};
   const blob = new FileBlob({ data: code });
   // move all user code to 'user' subdirectory
-  preparedFiles[path.join('user', entrypoint)] = blob;
+  preparedFiles[join('user', entrypoint)] = blob;
   // eslint-disable-next-line no-restricted-syntax
   for (const assetName of Object.keys(assets)) {
     const { source: data, permissions: mode } = assets[assetName];
     const blob2 = new FileBlob({ data, mode });
-    preparedFiles[
-      path.join('user', path.dirname(entrypoint), assetName)
-    ] = blob2;
+    preparedFiles[join('user', dirname(entrypoint), assetName)] = blob2;
   }
 
   return preparedFiles;
 }
 
-exports.config = {
-  maxLambdaSize: '5mb',
+export const config = {
+  maxLambdaSize: '5mb'
 };
 
 /**
  * @param {BuildParamsType} buildParams
  * @returns {Promise<Files>}
  */
-exports.build = async ({ files, entrypoint, workPath }) => {
+export async function build({ files, entrypoint, workPath }) {
   const [
     downloadedFiles,
     workNccPath,
-    entrypointFsDirname,
+    entrypointFsDirname
   ] = await downloadInstallAndBundle(
     { files, entrypoint, workPath },
-    { npmArguments: ['--prefer-offline'] },
+    { npmArguments: ['--prefer-offline'] }
   );
 
   console.log('running user script...');
@@ -102,36 +101,34 @@ exports.build = async ({ files, entrypoint, workPath }) => {
 
   console.log('compiling entrypoint with ncc...');
   const preparedFiles = await compile(workNccPath, downloadedFiles, entrypoint);
-  const launcherPath = path.join(__dirname, 'launcher.js');
-  let launcherData = await fs.readFile(launcherPath, 'utf8');
+  const launcherPath = join(__dirname, 'launcher.js');
+  let launcherData = await readFile(launcherPath, 'utf8');
 
   launcherData = launcherData.replace(
     '// PLACEHOLDER',
     [
       'process.chdir("./user");',
-      `listener = require("./${path.join('user', entrypoint)}");`,
-      'if (listener.default) listener = listener.default;',
-    ].join(' '),
+      `listener = require("./${join('user', entrypoint)}");`,
+      'if (listener.default) listener = listener.default;'
+    ].join(' ')
   );
 
   const launcherFiles = {
     'launcher.js': new FileBlob({ data: launcherData }),
-    'bridge.js': new FileFsRef({ fsPath: require('@now/node-bridge') }),
+    'bridge.js': new FileFsRef({ fsPath: require('@now/node-bridge') })
   };
 
   const lambda = await createLambda({
     files: { ...preparedFiles, ...launcherFiles },
     handler: 'launcher.launcher',
-    runtime: 'nodejs8.10',
+    runtime: 'nodejs8.10'
   });
 
   return { [entrypoint]: lambda };
-};
+}
 
-exports.prepareCache = async ({
-  files, entrypoint, workPath, cachePath,
-}) => {
-  await fs.remove(workPath);
+export async function prepareCache({ files, entrypoint, workPath, cachePath }) {
+  await remove(workPath);
   await downloadInstallAndBundle({ files, entrypoint, workPath: cachePath });
 
   return {
@@ -140,6 +137,6 @@ exports.prepareCache = async ({
     ...(await glob('user/yarn.lock', cachePath)),
     ...(await glob('ncc/node_modules/**', cachePath)),
     ...(await glob('ncc/package-lock.json', cachePath)),
-    ...(await glob('ncc/yarn.lock', cachePath)),
+    ...(await glob('ncc/yarn.lock', cachePath))
   };
-};
+}

packages/now-node/src/launcher.ts

@@ -0,0 +1,16 @@
+import { Server } from 'http';
+import { Bridge } from './bridge';
+
+let listener;
+
+if (!process.env.NODE_ENV) {
+  process.env.NODE_ENV = 'production';
+}
+
+// PLACEHOLDER
+
+const server = new Server(listener);
+const bridge = new Bridge(server);
+bridge.listen();
+
+exports.launcher = bridge.launcher;

packages/now-node/test/test.js

@@ -7,7 +7,7 @@ const {
   testDeployment,
 } = require('../../../test/lib/deployment/test-deployment.js');
 
-jest.setTimeout(2 * 60 * 1000);
+jest.setTimeout(4 * 60 * 1000);
 const buildUtilsUrl = '@canary';
 let builderUrl;
 

packages/now-node/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "es6",
+    "module": "commonjs",
+    "outDir": "dist",
+    "sourceMap": false,
+    "declaration": false
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}

packages/now-optipng/index.js

@@ -1,4 +1,4 @@
-const FileBlob = require('@now/build-utils/file-blob.js');
+const FileBlob = require('@now/build-utils/file-blob.js'); // eslint-disable-line import/no-extraneous-dependencies
 const OptiPng = require('optipng');
 const pipe = require('multipipe');
 

packages/now-optipng/package.json

@@ -1,12 +1,14 @@
 {
   "name": "@now/optipng",
-  "version": "0.4.8",
+  "version": "0.4.9-canary.0",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zeit/now-builders.git",
+    "directory": "packages/now-optipng"
+  },
   "dependencies": {
     "multipipe": "2.0.3",
     "optipng": "1.1.0"
-  },
-  "peerDependencies": {
-    "@now/build-utils": ">=0.0.1"
   }
 }

packages/now-php-bridge/index.js

@@ -1,23 +1,38 @@
-const FileBlob = require('@now/build-utils/file-blob.js');
-const FileFsRef = require('@now/build-utils/file-fs-ref.js');
-const glob = require('@now/build-utils/fs/glob.js');
+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 glob = require('@now/build-utils/fs/glob.js'); // eslint-disable-line import/no-extraneous-dependencies
 const path = require('path');
 
 async function getFiles() {
   const files = await glob('native/**', __dirname);
 
-  const phpConfig = await FileBlob.fromStream({ stream: files['native/php.ini'].toStream() });
-  phpConfig.data = phpConfig.data.toString()
+  const phpConfig = await FileBlob.fromStream({
+    stream: files['native/php.ini'].toStream(),
+  });
+  phpConfig.data = phpConfig.data
+    .toString()
     .replace(/\/root\/app\/modules/g, '/var/task/native/modules');
   files['native/php.ini'] = phpConfig;
 
   Object.assign(files, {
-    'fastcgi/connection.js': new FileFsRef({ fsPath: require.resolve('fastcgi-client/lib/connection.js') }),
-    'fastcgi/consts.js': new FileFsRef({ fsPath: require.resolve('fastcgi-client/lib/consts.js') }),
-    'fastcgi/stringifykv.js': new FileFsRef({ fsPath: require.resolve('fastcgi-client/lib/stringifykv.js') }),
-    'fastcgi/index.js': new FileFsRef({ fsPath: path.join(__dirname, 'fastcgi/index.js') }),
-    'fastcgi/port.js': new FileFsRef({ fsPath: path.join(__dirname, 'fastcgi/port.js') }),
-    'launcher.js': new FileFsRef({ fsPath: path.join(__dirname, 'launcher.js') }),
+    'fastcgi/connection.js': new FileFsRef({
+      fsPath: require.resolve('fastcgi-client/lib/connection.js'),
+    }),
+    'fastcgi/consts.js': new FileFsRef({
+      fsPath: require.resolve('fastcgi-client/lib/consts.js'),
+    }),
+    'fastcgi/stringifykv.js': new FileFsRef({
+      fsPath: require.resolve('fastcgi-client/lib/stringifykv.js'),
+    }),
+    'fastcgi/index.js': new FileFsRef({
+      fsPath: path.join(__dirname, 'fastcgi/index.js'),
+    }),
+    'fastcgi/port.js': new FileFsRef({
+      fsPath: path.join(__dirname, 'fastcgi/port.js'),
+    }),
+    'launcher.js': new FileFsRef({
+      fsPath: path.join(__dirname, 'launcher.js'),
+    }),
   });
 
   return files;

packages/now-php-bridge/launcher.js

@@ -64,7 +64,8 @@ async function transformFromAwsRequest({
   const { pathname, search, query: queryString } = parseUrl(path);
   let requestUri = pathname + (search || '');
 
-  let filename = pathJoin('/var/task/user', pathname);
+  let filename = pathJoin('/var/task/user',
+    process.env.NOW_ENTRYPOINT || pathname);
   if (await isDirectory(filename)) {
     if (!filename.endsWith('/')) {
       filename += '/';

packages/now-php-bridge/package.json

@@ -1,11 +1,13 @@
 {
   "name": "@now/php-bridge",
-  "version": "0.4.13",
+  "version": "0.4.16-canary.0",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zeit/now-builders.git",
+    "directory": "packages/now-php-bridge"
+  },
   "dependencies": {
     "fastcgi-client": "0.0.1"
-  },
-  "peerDependencies": {
-    "@now/build-utils": ">=0.0.1"
   }
 }

packages/now-php/index.js

@@ -1,6 +1,6 @@
-const { createLambda } = require('@now/build-utils/lambda.js');
+const { createLambda } = require('@now/build-utils/lambda.js'); // eslint-disable-line import/no-extraneous-dependencies
 const path = require('path');
-const rename = require('@now/build-utils/fs/rename.js');
+const rename = require('@now/build-utils/fs/rename.js'); // eslint-disable-line import/no-extraneous-dependencies
 const { getFiles } = require('@now/php-bridge');
 
 exports.config = {
@@ -20,6 +20,9 @@ exports.build = async ({ files, entrypoint }) => {
     files: { ...userFiles, ...bridgeFiles },
     handler: 'launcher.launcher',
     runtime: 'nodejs8.10',
+    environment: {
+      NOW_ENTRYPOINT: entrypoint,
+    },
   });
 
   return { [entrypoint]: lambda };

packages/now-php/package.json

@@ -1,12 +1,14 @@
 {
   "name": "@now/php",
-  "version": "0.4.13",
+  "version": "0.4.16-canary.0",
   "license": "MIT",
-  "dependencies": {
-    "@now/php-bridge": "^0.4.13"
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zeit/now-builders.git",
+    "directory": "packages/now-php"
   },
-  "peerDependencies": {
-    "@now/build-utils": ">=0.0.1"
+  "dependencies": {
+    "@now/php-bridge": "^0.4.16-canary.0"
   },
   "scripts": {
     "test": "jest"

packages/now-php/test/fixtures/19-routes/index.php

@@ -0,0 +1,2 @@
+<?php
+print('cow:RANDOMNESS_PLACEHOLDER:' . $_SERVER['REQUEST_URI']);

packages/now-php/test/fixtures/19-routes/now.json

@@ -0,0 +1,13 @@
+{
+  "version": 2,
+  "builds": [
+    { "src": "index.php", "use": "@now/php" }
+  ],
+  "routes": [
+    { "src": "/(.*)", "dest": "index.php" }
+  ],
+  "probes": [
+    { "path": "/any", "mustContain": "cow:RANDOMNESS_PLACEHOLDER:/any" },
+    { "path": "/any?type=some", "mustContain": "cow:RANDOMNESS_PLACEHOLDER:/any?type=some" }
+  ]
+}

packages/now-php/test/test.js

@@ -7,7 +7,7 @@ const {
   testDeployment,
 } = require('../../../test/lib/deployment/test-deployment.js');
 
-jest.setTimeout(2 * 60 * 1000);
+jest.setTimeout(4 * 60 * 1000);
 const buildUtilsUrl = '@canary';
 let builderUrl;
 

packages/now-python/download-and-install-pip.js

@@ -3,7 +3,7 @@ const fetch = require('node-fetch');
 const execa = require('execa');
 const { createWriteStream } = require('fs');
 
-const getWritableDirectory = require('@now/build-utils/fs/get-writable-directory.js');
+const getWritableDirectory = require('@now/build-utils/fs/get-writable-directory.js'); // eslint-disable-line import/no-extraneous-dependencies
 
 const url = 'https://bootstrap.pypa.io/get-pip.py';
 

packages/now-python/index.js

@@ -1,16 +1,17 @@
 const path = require('path');
 const execa = require('execa');
 const { readFile, writeFile } = require('fs.promised');
-const getWritableDirectory = require('@now/build-utils/fs/get-writable-directory.js');
-const download = require('@now/build-utils/fs/download.js');
-const glob = require('@now/build-utils/fs/glob.js');
-const { createLambda } = require('@now/build-utils/lambda.js');
+const getWritableDirectory = require('@now/build-utils/fs/get-writable-directory.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 glob = require('@now/build-utils/fs/glob.js'); // eslint-disable-line import/no-extraneous-dependencies
+const { createLambda } = require('@now/build-utils/lambda.js'); // eslint-disable-line import/no-extraneous-dependencies
 const downloadAndInstallPip = require('./download-and-install-pip');
 
 async function pipInstall(pipPath, srcDir, ...args) {
-  console.log(`running "pip install -t ${srcDir} ${args.join(' ')}"...`);
+  console.log(`running "pip install --target ${srcDir} ${args.join(' ')}"...`);
   try {
-    await execa(pipPath, ['install', '-t', srcDir, ...args], {
+    await execa(pipPath, ['install', '--target', '.', ...args], {
+      cwd: srcDir,
       stdio: 'inherit',
     });
   } catch (err) {
@@ -38,10 +39,33 @@ exports.build = async ({ files, entrypoint }) => {
 
   const pipPath = await downloadAndInstallPip();
 
+  try {
+    // See: https://stackoverflow.com/a/44728772/376773
+    //
+    // The `setup.cfg` is required for `now dev` on MacOS, where without
+    // this file being present in the src dir then this error happens:
+    //
+    // distutils.errors.DistutilsOptionError: must supply either home
+    // or prefix/exec-prefix -- not both
+    const setupCfg = path.join(srcDir, 'setup.cfg');
+    await writeFile(setupCfg, '[install]\nprefix=\n');
+  } catch (err) {
+    console.log('failed to create "setup.cfg" file');
+    throw err;
+  }
+
   await pipInstall(pipPath, srcDir, 'requests');
 
-  if (files['requirements.txt']) {
-    console.log('found "requirements.txt"');
+  const entryDirectory = path.dirname(entrypoint);
+  const requirementsTxt = path.join(entryDirectory, 'requirements.txt');
+
+  if (files[requirementsTxt]) {
+    console.log('found local "requirements.txt"');
+
+    const requirementsTxtPath = files[requirementsTxt].fsPath;
+    await pipInstall(pipPath, srcDir, '-r', requirementsTxtPath);
+  } else if (files['requirements.txt']) {
+    console.log('found global "requirements.txt"');
 
     const requirementsTxtPath = files['requirements.txt'].fsPath;
     await pipInstall(pipPath, srcDir, '-r', requirementsTxtPath);

packages/now-python/now_handler.py

@@ -1,23 +1,35 @@
+import base64
 from http.server import HTTPServer
 import json
 import requests
 from __NOW_HANDLER_FILENAME import handler
 import _thread
 
-server = HTTPServer(('', 3000), handler)
+
+server = HTTPServer(('', 0), handler)
+port = server.server_address[1]
 
 def now_handler(event, context):
     _thread.start_new_thread(server.handle_request, ())
+
     payload = json.loads(event['body'])
     path = payload['path']
     headers = payload['headers']
     method = payload['method']
-    
-    res = requests.request(method, 'http://0.0.0.0:3000' + path, headers=headers)
+    encoding = payload.get('encoding')
+    body = payload.get('body')
+
+    if (
+        (body is not None and len(body) > 0) and
+        (encoding is not None and encoding == 'base64')
+    ):
+        body = base64.b64decode(body)
+
+    res = requests.request(method, 'http://0.0.0.0:' + str(port) + path,
+                           headers=headers, data=body, allow_redirects=False)
 
     return {
         'statusCode': res.status_code,
         'headers': dict(res.headers),
-        'body': res.text
+        'body': res.text,
     }
-

packages/now-python/package.json

@@ -1,14 +1,16 @@
 {
   "name": "@now/python",
-  "version": "0.0.40",
+  "version": "0.0.42-canary.0",
   "main": "index.js",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zeit/now-builders.git",
+    "directory": "packages/now-python"
+  },
   "dependencies": {
     "execa": "^1.0.0",
     "fs.promised": "^3.0.0",
     "node-fetch": "^2.2.0"
-  },
-  "peerDependencies": {
-    "@now/build-utils": ">=0.0.1"
   }
 }

packages/now-rust/Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "now_lambda"
+version = "0.1.2"
+authors = ["Antonio Nuno Monteiro <anmonteiro@gmail.com>"]
+edition = "2018"
+description = "Rust bindings for Now.sh Lambdas"
+keywords = ["AWS", "Lambda", "Zeit", "Now", "Rust"]
+license = "MIT"
+homepage = "https://github.com/zeit/now-builders"
+repository = "https://github.com/zeit/now-builders"
+documentation = "https://docs.rs/now_lambda"
+include = [
+    "src/*.rs",
+    "Cargo.toml"
+]
+
+[dependencies]
+serde = "^1"
+serde_json = "^1"
+serde_derive = "^1"
+http = "0.1"
+tokio = "^0.1"
+base64 = "0.10"
+log = "^0.4"
+lambda_runtime = "0.2.0"

packages/now-rust/index.js

@@ -0,0 +1,336 @@
+const fs = require('fs-extra');
+const path = require('path');
+const execa = require('execa');
+const toml = require('@iarna/toml');
+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 glob = require('@now/build-utils/fs/glob.js'); // eslint-disable-line import/no-extraneous-dependencies
+const { runShellScript } = require('@now/build-utils/fs/run-user-scripts.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 FileRef = require('@now/build-utils/file-ref.js'); // eslint-disable-line import/no-extraneous-dependencies
+const installRust = require('./install-rust.js');
+
+exports.config = {
+  maxLambdaSize: '25mb',
+};
+
+const codegenFlags = [
+  '-C', 'target-cpu=ivybridge',
+  '-C', 'target-feature=-aes,-avx,+fxsr,-popcnt,+sse,+sse2,-sse3,-sse4.1,-sse4.2,-ssse3,-xsave,-xsaveopt',
+];
+
+async function inferCargoBinaries(config) {
+  try {
+    const { stdout: manifestStr } = await execa(
+      'cargo',
+      ['read-manifest'],
+      config,
+    );
+
+    const { targets } = JSON.parse(manifestStr);
+
+    return targets
+      .filter(({ kind }) => kind.includes('bin'))
+      .map(({ name }) => name);
+  } catch (err) {
+    console.error('failed to run `cargo read-manifest`');
+    throw err;
+  }
+}
+
+async function parseTOMLStream(stream) {
+  return toml.parse.stream(stream);
+}
+
+async function buildWholeProject({
+  entrypoint,
+  downloadedFiles,
+  rustEnv,
+  config,
+}) {
+  const entrypointDirname = path.dirname(downloadedFiles[entrypoint].fsPath);
+  const { debug } = config;
+  console.log('running `cargo build`...');
+  try {
+    await execa('cargo', ['build', '--verbose'].concat(debug ? [] : ['--release']), {
+      env: rustEnv,
+      cwd: entrypointDirname,
+      stdio: 'inherit',
+    });
+  } catch (err) {
+    console.error('failed to `cargo build`');
+    throw err;
+  }
+
+  const targetPath = path.join(
+    entrypointDirname,
+    'target',
+    debug ? 'debug' : 'release',
+  );
+  const binaries = await inferCargoBinaries({
+    env: rustEnv,
+    cwd: entrypointDirname,
+  });
+
+  const lambdas = {};
+  const lambdaPath = path.dirname(entrypoint);
+  await Promise.all(
+    binaries.map(async (binary) => {
+      const fsPath = path.join(targetPath, binary);
+      const lambda = await createLambda({
+        files: {
+          bootstrap: new FileFsRef({ mode: 0o755, fsPath }),
+        },
+        handler: 'bootstrap',
+        runtime: 'provided',
+      });
+
+      lambdas[path.join(lambdaPath, binary)] = lambda;
+    }),
+  );
+
+  return lambdas;
+}
+
+async function runUserScripts(entrypoint) {
+  const entryDir = path.dirname(entrypoint);
+  const buildScriptPath = path.join(entryDir, 'build.sh');
+  const buildScriptExists = await fs.exists(buildScriptPath);
+
+  if (buildScriptExists) {
+    console.log('running `build.sh`...');
+    await runShellScript(buildScriptPath);
+  }
+}
+
+async function cargoLocateProject(config) {
+  try {
+    const { stdout: projectDescriptionStr } = await execa(
+      'cargo',
+      ['locate-project'],
+      config,
+    );
+    const projectDescription = JSON.parse(projectDescriptionStr);
+    if (projectDescription != null && projectDescription.root != null) {
+      return projectDescription.root;
+    }
+  } catch (e) {
+    if (!/could not find/g.test(e.stderr)) {
+      console.error("Couldn't run `cargo locate-project`");
+      throw e;
+    }
+  }
+
+  return null;
+}
+
+async function buildSingleFile({
+  workPath,
+  entrypoint,
+  downloadedFiles,
+  rustEnv,
+  config,
+}) {
+  console.log('building single file');
+  const launcherPath = path.join(__dirname, 'launcher.rs');
+  let launcherData = await fs.readFile(launcherPath, 'utf8');
+
+  const entrypointPath = downloadedFiles[entrypoint].fsPath;
+  const entrypointDirname = path.dirname(entrypointPath);
+  launcherData = launcherData.replace(
+    '// PLACEHOLDER',
+    await fs.readFile(path.join(workPath, entrypoint)),
+  );
+  // replace the entrypoint with one that includes the the imports + lambda.start
+  await fs.remove(entrypointPath);
+  await fs.writeFile(entrypointPath, launcherData);
+
+  // Find a Cargo.toml file or TODO: create one
+  const cargoTomlFile = await cargoLocateProject({
+    env: rustEnv,
+    cwd: entrypointDirname,
+  });
+
+  // TODO: we're assuming there's a Cargo.toml file. We need to create one
+  // otherwise
+  let cargoToml;
+  try {
+    cargoToml = await parseTOMLStream(fs.createReadStream(cargoTomlFile));
+  } catch (err) {
+    console.error('Failed to parse TOML from entrypoint:', entrypoint);
+    throw err;
+  }
+
+  const binName = path
+    .basename(entrypointPath)
+    .replace(path.extname(entrypointPath), '');
+  const { package: pkg, dependencies } = cargoToml;
+  // default to latest now_lambda
+  dependencies.now_lambda = '*';
+  const tomlToWrite = toml.stringify({
+    package: pkg,
+    dependencies,
+    bin: [
+      {
+        name: binName,
+        path: entrypointPath,
+      },
+    ],
+  });
+  console.log('toml to write:', tomlToWrite);
+
+  // Overwrite the Cargo.toml file with one that includes the `now_lambda`
+  // dependency and our binary. `dependencies` is a map so we don't run the
+  // risk of having 2 `now_lambda`s in there.
+  await fs.writeFile(cargoTomlFile, tomlToWrite);
+
+  const { debug } = config;
+  console.log('running `cargo build`...');
+  try {
+    await execa(
+      'cargo',
+      ['build', '--bin', binName, '--verbose'].concat(debug ? [] : ['--release']),
+      {
+        env: rustEnv,
+        cwd: entrypointDirname,
+        stdio: 'inherit',
+      },
+    );
+  } catch (err) {
+    console.error('failed to `cargo build`');
+    throw err;
+  }
+
+  const bin = path.join(
+    path.dirname(cargoTomlFile),
+    'target',
+    debug ? 'debug' : 'release',
+    binName,
+  );
+
+  const lambda = await createLambda({
+    files: {
+      bootstrap: new FileFsRef({ mode: 0o755, fsPath: bin }),
+    },
+    handler: 'bootstrap',
+    runtime: 'provided',
+  });
+
+  return {
+    [entrypoint]: lambda,
+  };
+}
+
+exports.build = async (m) => {
+  const { files, entrypoint, workPath } = m;
+  console.log('downloading files');
+  const downloadedFiles = await download(files, workPath);
+
+  await installRust();
+  const { PATH, HOME } = process.env;
+  const rustEnv = {
+    ...process.env,
+    PATH: `${path.join(HOME, '.cargo/bin')}:${PATH}`,
+    RUSTFLAGS: [process.env.RUSTFLAGS, ...codegenFlags].filter(Boolean).join(' '),
+  };
+
+  await runUserScripts(downloadedFiles[entrypoint].fsPath);
+
+  const newM = Object.assign(m, { downloadedFiles, rustEnv });
+  if (path.extname(entrypoint) === '.toml') {
+    return buildWholeProject(newM);
+  }
+  return buildSingleFile(newM);
+};
+
+exports.prepareCache = async ({ cachePath, entrypoint, workPath }) => {
+  console.log('preparing cache...');
+
+  let targetFolderDir;
+  if (path.extname(entrypoint) === '.toml') {
+    targetFolderDir = path.dirname(path.join(workPath, entrypoint));
+  } else {
+    const { PATH, HOME } = process.env;
+    const rustEnv = {
+      ...process.env,
+      PATH: `${path.join(HOME, '.cargo/bin')}:${PATH}`,
+      RUSTFLAGS: [process.env.RUSTFLAGS, ...codegenFlags].filter(Boolean).join(' '),
+    };
+    const entrypointDirname = path.dirname(path.join(workPath, entrypoint));
+    const cargoTomlFile = await cargoLocateProject({
+      env: rustEnv,
+      cwd: entrypointDirname,
+    });
+
+    if (cargoTomlFile != null) {
+      targetFolderDir = path.dirname(cargoTomlFile);
+    } else {
+      // `Cargo.toml` doesn't exist, in `build` we put it in the same
+      // path as the entrypoint.
+      targetFolderDir = path.dirname(path.join(workPath, entrypoint));
+    }
+  }
+
+  const cacheEntrypointDirname = path.join(
+    cachePath,
+    path.relative(workPath, targetFolderDir),
+  );
+
+  // Remove the target folder to avoid 'directory already exists' errors
+  fs.removeSync(path.join(cacheEntrypointDirname, 'target'));
+  fs.mkdirpSync(cacheEntrypointDirname);
+  // Move the target folder to the cache location
+  fs.renameSync(
+    path.join(targetFolderDir, 'target'),
+    path.join(cacheEntrypointDirname, 'target'),
+  );
+
+  const cacheFiles = await glob('**/**', cachePath);
+
+  // eslint-disable-next-line no-restricted-syntax
+  for (const f of Object.keys(cacheFiles)) {
+    const accept = (/(?:^|\/)target\/release\/\.fingerprint\//.test(f))
+      || (/(?:^|\/)target\/release\/build\//.test(f))
+      || (/(?:^|\/)target\/release\/deps\//.test(f))
+      || (/(?:^|\/)target\/debug\/\.fingerprint\//.test(f))
+      || (/(?:^|\/)target\/debug\/build\//.test(f))
+      || (/(?:^|\/)target\/debug\/deps\//.test(f));
+    if (!accept) {
+      delete cacheFiles[f];
+    }
+  }
+
+  return cacheFiles;
+};
+
+function findCargoToml(files, entrypoint) {
+  let currentPath = path.dirname(entrypoint);
+  let cargoTomlPath;
+
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    cargoTomlPath = path.join(currentPath, 'Cargo.toml');
+    if (files[cargoTomlPath]) break;
+    const newPath = path.dirname(currentPath);
+    if (currentPath === newPath) break;
+    currentPath = newPath;
+  }
+
+  return cargoTomlPath;
+}
+
+/*
+console.log(findCargoToml({
+  'rust/src/main.rs': true,
+  'rust/Cargo.toml': true,
+  'Cargo.toml': true
+}, 'rust/src/main.rs'));
+*/
+
+exports.getDefaultCache = ({ files, entrypoint }) => {
+  const cargoTomlPath = findCargoToml(files, entrypoint);
+  if (!cargoTomlPath) return undefined;
+  const targetFolderDir = path.dirname(cargoTomlPath);
+  const defaultCacheRef = new FileRef({ digest: 'sha:204e0c840c43473bbd130d7bc704fe5588b4eab43cda9bc940f10b2a0ae14b16' });
+  return { [targetFolderDir]: defaultCacheRef };
+};

packages/now-rust/install-rust.js

@@ -0,0 +1,48 @@
+const tar = require('tar');
+const fetch = require('node-fetch');
+const execa = require('execa');
+
+const rustUrl = 'https://dmmcy0pwk6bqi.cloudfront.net/rust.tar.gz';
+
+async function downloadRustToolchain() {
+  console.log('downloading the rust toolchain');
+  const res = await fetch(rustUrl);
+
+  if (!res.ok) {
+    throw new Error(`Failed to download: ${rustUrl}`);
+  }
+
+  const { HOME } = process.env;
+  return new Promise((resolve, reject) => {
+    res.body
+      .on('error', reject)
+      .pipe(tar.extract({ gzip: true, cwd: HOME }))
+      .on('finish', () => resolve());
+  });
+}
+
+async function installOpenSSL() {
+  console.log('installing openssl-devel...');
+  try {
+    // need to downgrade otherwise yum can't resolve the dependencies given
+    // a later version is already installed in the machine.
+    await execa(
+      'yum',
+      ['downgrade', '-y', 'krb5-libs-1.14.1-27.41.amzn1.x86_64'],
+      {
+        stdio: 'inherit',
+      },
+    );
+    await execa('yum', ['install', '-y', 'openssl-devel'], {
+      stdio: 'inherit',
+    });
+  } catch (err) {
+    console.error('failed to `yum install -y openssl-devel`');
+    throw err;
+  }
+}
+
+module.exports = async () => {
+  await downloadRustToolchain();
+  await installOpenSSL();
+};

packages/now-rust/launcher.rs

@@ -0,0 +1,8 @@
+use now_lambda::lambda;
+use std::error::Error;
+
+// PLACEHOLDER
+
+fn main() -> Result<(), Box<dyn Error>> {
+    Ok(lambda!(handler))
+}

packages/now-rust/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@now/rust",
+  "version": "0.1.2-canary.0",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zeit/now-builders.git",
+    "directory": "packages/now-rust"
+  },
+  "files": [
+    "index.js",
+    "install-rust.js",
+    "launcher.rs"
+  ],
+  "dependencies": {
+    "@iarna/toml": "^2.2.1",
+    "execa": "^1.0.0",
+    "fs-extra": "^7.0.1",
+    "node-fetch": "^2.3.0",
+    "tar": "^4.4.8"
+  }
+}

packages/now-rust/src/body.rs

@@ -0,0 +1,196 @@
+//! Provides a Now Lambda oriented request and response body entity interface
+
+use std::{borrow::Cow, ops::Deref, str};
+
+use base64::display::Base64Display;
+use serde::ser::{Error as SerError, Serialize, Serializer};
+
+/// Representation of http request and response bodies as supported
+/// by Zeit Now v2.
+///
+/// These come in three flavors
+/// * `Empty` ( no body )
+/// * `Text` ( text data )
+/// * `Binary` ( binary data )
+///
+/// Body types can be `Deref` and `AsRef`'d into `[u8]` types much like the `hyper` crate
+///
+/// # Examples
+///
+/// Body types are inferred with `From` implementations.
+///
+/// ## Text
+///
+/// Types like `String`, `str` whose type reflects
+/// text produce `Body::Text` variants
+///
+/// ```
+/// assert!(match now_lambda::Body::from("text") {
+///   now_lambda::Body::Text(_) => true,
+///   _ => false
+/// })
+/// ```
+///
+/// ## Binary
+///
+/// Types like `Vec<u8>` and `&[u8]` whose types reflect raw bytes produce `Body::Binary` variants
+///
+/// ```
+/// assert!(match now_lambda::Body::from("text".as_bytes()) {
+///   now_lambda::Body::Binary(_) => true,
+///   _ => false
+/// })
+/// ```
+///
+/// `Binary` responses bodies will automatically get base64 encoded.
+///
+/// ## Empty
+///
+/// The unit type ( `()` ) whose type represents an empty value produces `Body::Empty` variants
+///
+/// ```
+/// assert!(match now_lambda::Body::from(()) {
+///   now_lambda::Body::Empty => true,
+///   _ => false
+/// })
+/// ```
+#[derive(Debug, PartialEq)]
+pub enum Body {
+    /// An empty body
+    Empty,
+    /// A body containing string data
+    Text(String),
+    /// A body containing binary data
+    Binary(Vec<u8>),
+}
+
+impl Default for Body {
+    fn default() -> Self {
+        Body::Empty
+    }
+}
+
+impl From<()> for Body {
+    fn from(_: ()) -> Self {
+        Body::Empty
+    }
+}
+
+impl From<Body> for () {
+    fn from(_: Body) -> Self {
+        ()
+    }
+}
+
+impl<'a> From<&'a str> for Body {
+    fn from(s: &'a str) -> Self {
+        Body::Text(s.into())
+    }
+}
+
+impl From<String> for Body {
+    fn from(b: String) -> Self {
+        Body::Text(b)
+    }
+}
+impl From<Body> for String {
+    fn from(b: Body) -> String {
+        match b {
+            Body::Empty => String::from(""),
+            Body::Text(t) => t,
+            Body::Binary(b) => str::from_utf8(&b).unwrap().to_owned(),
+        }
+    }
+}
+
+impl From<Cow<'static, str>> for Body {
+    #[inline]
+    fn from(cow: Cow<'static, str>) -> Body {
+        match cow {
+            Cow::Borrowed(b) => Body::from(b.to_owned()),
+            Cow::Owned(o) => Body::from(o),
+        }
+    }
+}
+
+impl From<Body> for Cow<'static, str> {
+    #[inline]
+    fn from(b: Body) -> Cow<'static, str> {
+        Cow::Owned(String::from(b))
+    }
+}
+
+impl From<Cow<'static, [u8]>> for Body {
+    #[inline]
+    fn from(cow: Cow<'static, [u8]>) -> Body {
+        match cow {
+            Cow::Borrowed(b) => Body::from(b),
+            Cow::Owned(o) => Body::from(o),
+        }
+    }
+}
+
+impl From<Body> for Cow<'static, [u8]> {
+    #[inline]
+    fn from(b: Body) -> Self {
+        Cow::Owned(b.as_ref().to_owned())
+    }
+}
+
+impl From<Vec<u8>> for Body {
+    fn from(b: Vec<u8>) -> Self {
+        Body::Binary(b)
+    }
+}
+
+impl From<Body> for Vec<u8> {
+    fn from(b: Body) -> Self {
+        match b {
+            Body::Empty => "".as_bytes().to_owned(),
+            Body::Text(t) => t.into_bytes(),
+            Body::Binary(b) => b.to_owned(),
+        }
+    }
+}
+
+impl<'a> From<&'a [u8]> for Body {
+    fn from(b: &'a [u8]) -> Self {
+        Body::Binary(b.to_vec())
+    }
+}
+
+impl Deref for Body {
+    type Target = [u8];
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        self.as_ref()
+    }
+}
+
+impl AsRef<[u8]> for Body {
+    #[inline]
+    fn as_ref(&self) -> &[u8] {
+        match self {
+            Body::Empty => &[],
+            Body::Text(ref bytes) => bytes.as_ref(),
+            Body::Binary(ref bytes) => bytes.as_ref(),
+        }
+    }
+}
+
+impl<'a> Serialize for Body {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            Body::Text(data) => serializer
+                .serialize_str(::std::str::from_utf8(data.as_ref()).map_err(S::Error::custom)?),
+            Body::Binary(data) => {
+                serializer.collect_str(&Base64Display::with_config(data, base64::STANDARD))
+            }
+            Body::Empty => serializer.serialize_unit(),
+        }
+    }
+}

packages/now-rust/src/error.rs

@@ -0,0 +1,44 @@
+use http;
+use lambda_runtime::error::LambdaErrorExt;
+use std::{error::Error, fmt};
+
+/// This module implements a custom error currently over the AWS Lambda runtime,
+/// which can be extended later to support more service providers.
+#[derive(Debug)]
+pub struct NowError {
+    msg: String,
+}
+impl NowError {
+    pub fn new(message: &str) -> NowError {
+        NowError {
+            msg: message.to_owned(),
+        }
+    }
+}
+impl fmt::Display for NowError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.msg)
+    }
+}
+
+impl Error for NowError {}
+
+impl From<std::num::ParseIntError> for NowError {
+    fn from(i: std::num::ParseIntError) -> Self {
+        NowError::new(&format!("{}", i))
+    }
+}
+
+impl From<http::Error> for NowError {
+    fn from(i: http::Error) -> Self {
+        NowError::new(&format!("{}", i))
+    }
+}
+
+// the value returned by the error_type function is included as the
+// `errorType` in the AWS Lambda response
+impl LambdaErrorExt for NowError {
+    fn error_type(&self) -> &str {
+        "NowError"
+    }
+}

packages/now-rust/src/lib.rs

@@ -0,0 +1,91 @@
+pub use http::{self, Response};
+use lambda_runtime::{self as lambda, Context};
+use log::{self, debug, error};
+use serde_json::Error;
+use tokio::runtime::Runtime as TokioRuntime;
+
+mod body;
+pub mod error;
+pub mod request;
+mod response;
+mod strmap;
+
+pub use crate::{body::Body, response::IntoResponse, strmap::StrMap};
+use crate::{
+    error::NowError,
+    request::{NowEvent, NowRequest},
+    response::NowResponse,
+};
+
+/// Type alias for `http::Request`s with a fixed `now_lambda::Body` body
+pub type Request = http::Request<Body>;
+
+/// Functions acting as Now Lambda handlers must conform to this type.
+pub trait Handler<R, B, E> {
+    /// Method to execute the handler function
+    fn run(&mut self, event: http::Request<B>) -> Result<R, E>;
+}
+
+impl<Function, R, B, E> Handler<R, B, E> for Function
+where
+    Function: FnMut(http::Request<B>) -> Result<R, E>,
+{
+    fn run(&mut self, event: http::Request<B>) -> Result<R, E> {
+        (*self)(event)
+    }
+}
+
+/// Creates a new `lambda_runtime::Runtime` and begins polling for Now Lambda events
+///
+/// # Arguments
+///
+/// * `f` A type that conforms to the `Handler` interface.
+///
+/// # Panics
+/// The function panics if the Lambda environment variables are not set.
+pub fn start<R, B, E>(f: impl Handler<R, B, E>, runtime: Option<TokioRuntime>)
+where
+    B: From<Body>,
+    E: Into<NowError>,
+    R: IntoResponse,
+{
+    // handler requires a mutable ref
+    let mut func = f;
+    lambda::start(
+        |e: NowEvent, _ctx: Context| {
+            let req_str = e.body;
+            let parse_result: Result<NowRequest, Error> = serde_json::from_str(&req_str);
+            match parse_result {
+                Ok(req) => {
+                    debug!("Deserialized Now proxy request successfully");
+                    let request: http::Request<Body> = req.into();
+                    func.run(request.map(|b| b.into()))
+                        .map(|resp| NowResponse::from(resp.into_response()))
+                        .map_err(|e| e.into())
+                }
+                Err(e) => {
+                    error!("Could not deserialize event body to NowRequest {}", e);
+                    panic!("Could not deserialize event body to NowRequest {}", e);
+                }
+            }
+        },
+        runtime,
+    )
+}
+
+/// A macro for starting new handler's poll for Now Lambda events
+#[macro_export]
+macro_rules! lambda {
+    ($handler:expr) => {
+        $crate::start($handler, None)
+    };
+    ($handler:expr, $runtime:expr) => {
+        $crate::start($handler, Some($runtime))
+    };
+    ($handler:ident) => {
+        $crate::start($handler, None)
+    };
+    ($handler:ident, $runtime:expr) => {
+        $crate::start($handler, Some($runtime))
+    };
+}

packages/now-rust/src/request.rs

@@ -0,0 +1,122 @@
+use std::{borrow::Cow, fmt, mem};
+
+use http::{self, header::HeaderValue, HeaderMap, Method, Request as HttpRequest};
+use serde::de::{Deserializer, Error as DeError, MapAccess, Visitor};
+use serde_derive::Deserialize;
+
+use crate::body::Body;
+
+/// Representation of a Now Lambda proxy event data
+#[doc(hidden)]
+#[derive(Deserialize, Debug, Default)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct NowRequest<'a> {
+    pub(crate) host: Cow<'a, str>,
+    pub(crate) path: Cow<'a, str>,
+    #[serde(deserialize_with = "deserialize_method")]
+    pub(crate) method: Method,
+    #[serde(deserialize_with = "deserialize_headers")]
+    pub(crate) headers: HeaderMap<HeaderValue>,
+    pub(crate) body: Option<Cow<'a, str>>,
+    pub(crate) encoding: Option<String>,
+}
+
+#[doc(hidden)]
+#[derive(Deserialize, Debug, Default)]
+pub(crate) struct NowEvent<'a> {
+    #[serde(rename = "Action")]
+    action: Cow<'a, str>,
+    pub(crate) body: Cow<'a, str>,
+}
+
+fn deserialize_method<'de, D>(deserializer: D) -> Result<Method, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    struct MethodVisitor;
+
+    impl<'de> Visitor<'de> for MethodVisitor {
+        type Value = Method;
+
+        fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+            write!(formatter, "a Method")
+        }
+
+        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+        where
+            E: DeError,
+        {
+            v.parse().map_err(E::custom)
+        }
+    }
+
+    deserializer.deserialize_str(MethodVisitor)
+}
+
+fn deserialize_headers<'de, D>(deserializer: D) -> Result<HeaderMap<HeaderValue>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    struct HeaderVisitor;
+
+    impl<'de> Visitor<'de> for HeaderVisitor {
+        type Value = HeaderMap<HeaderValue>;
+
+        fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+            write!(formatter, "a HeaderMap<HeaderValue>")
+        }
+
+        fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+        where
+            A: MapAccess<'de>,
+        {
+            let mut headers = http::HeaderMap::new();
+            while let Some((key, value)) = map.next_entry::<Cow<'_, str>, Cow<'_, str>>()? {
+                let header_name = key
+                    .parse::<http::header::HeaderName>()
+                    .map_err(A::Error::custom)?;
+                let header_value =
+                    http::header::HeaderValue::from_shared(value.into_owned().into())
+                        .map_err(A::Error::custom)?;
+                headers.append(header_name, header_value);
+            }
+            Ok(headers)
+        }
+    }
+
+    deserializer.deserialize_map(HeaderVisitor)
+}
+
+impl<'a> From<NowRequest<'a>> for HttpRequest<Body> {
+    fn from(value: NowRequest<'_>) -> Self {
+        let NowRequest {
+            host,
+            path,
+            method,
+            headers,
+            body,
+            encoding,
+        } = value;
+
+        // build an http::Request<now_lambda::Body> from a now_lambda::NowRequest
+        let mut builder = HttpRequest::builder();
+        builder.method(method);
+        builder.uri({ format!("https://{}{}", host, path) });
+
+        let mut req = builder
+            .body(match (body, encoding) {
+                (Some(ref b), Some(ref encoding)) if encoding == "base64" => {
+                    // todo: document failure behavior
+                    Body::from(::base64::decode(b.as_ref()).unwrap_or_default())
+                }
+                (Some(b), _) => Body::from(b.into_owned()),
+                _ => Body::from(()),
+            })
+            .expect("failed to build request");
+
+        // no builder method that sets headers in batch
+        mem::replace(req.headers_mut(), headers);
+
+        req
+    }
+}

packages/now-rust/src/response.rs

@@ -0,0 +1,122 @@
+//! Response types
+
+use http::{
+    header::{HeaderMap, HeaderValue},
+    Response,
+};
+use serde::ser::{Error as SerError, SerializeMap, Serializer};
+use serde_derive::Serialize;
+
+use crate::body::Body;
+
+/// Representation of a Now Lambda response
+#[derive(Serialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct NowResponse {
+    pub status_code: u16,
+    #[serde(
+        skip_serializing_if = "HeaderMap::is_empty",
+        serialize_with = "serialize_headers"
+    )]
+    pub headers: HeaderMap<HeaderValue>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub body: Option<Body>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub encoding: Option<String>,
+}
+
+impl Default for NowResponse {
+    fn default() -> Self {
+        Self {
+            status_code: 200,
+            headers: Default::default(),
+            body: Default::default(),
+            encoding: Default::default(),
+        }
+    }
+}
+
+fn serialize_headers<S>(headers: &HeaderMap<HeaderValue>, serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    let mut map = serializer.serialize_map(Some(headers.keys_len()))?;
+    for key in headers.keys() {
+        let map_value = headers[key].to_str().map_err(S::Error::custom)?;
+        map.serialize_entry(key.as_str(), map_value)?;
+    }
+    map.end()
+}
+
+impl<T> From<Response<T>> for NowResponse
+where
+    T: Into<Body>,
+{
+    fn from(value: Response<T>) -> Self {
+        let (parts, bod) = value.into_parts();
+        let (encoding, body) = match bod.into() {
+            Body::Empty => (None, None),
+            b @ Body::Text(_) => (None, Some(b)),
+            b @ Body::Binary(_) => (Some("base64".to_string()), Some(b)),
+        };
+        NowResponse {
+            status_code: parts.status.as_u16(),
+            body,
+            headers: parts.headers,
+            encoding,
+        }
+    }
+}
+
+/// A conversion of self into a `Response`
+///
+/// Implementations for `Response<B> where B: Into<Body>`,
+/// `B where B: Into<Body>` and `serde_json::Value` are provided
+/// by default
+///
+/// # example
+///
+/// ```rust
+/// use now_lambda::{Body, IntoResponse, Response};
+///
+/// assert_eq!(
+///   "hello".into_response().body(),
+///   Response::new(Body::from("hello")).body()
+/// );
+/// ```
+pub trait IntoResponse {
+    /// Return a translation of `self` into a `Response<Body>`
+    fn into_response(self) -> Response<Body>;
+}
+
+impl<B> IntoResponse for Response<B>
+where
+    B: Into<Body>,
+{
+    fn into_response(self) -> Response<Body> {
+        let (parts, body) = self.into_parts();
+        Response::from_parts(parts, body.into())
+    }
+}
+
+impl<B> IntoResponse for B
+where
+    B: Into<Body>,
+{
+    fn into_response(self) -> Response<Body> {
+        Response::new(self.into())
+    }
+}
+
+impl IntoResponse for serde_json::Value {
+    fn into_response(self) -> Response<Body> {
+        Response::builder()
+            .header(http::header::CONTENT_TYPE, "application/json")
+            .body(
+                serde_json::to_string(&self)
+                    .expect("unable to serialize serde_json::Value")
+                    .into(),
+            )
+            .expect("unable to build http::Response")
+    }
+}

packages/now-rust/src/strmap.rs

@@ -0,0 +1,90 @@
+use std::{
+    collections::{hash_map::Keys, HashMap},
+    fmt,
+    sync::Arc,
+};
+
+use serde::de::{Deserialize, Deserializer, MapAccess, Visitor};
+
+/// A read-only view into a map of string data
+#[derive(Default, Debug, PartialEq)]
+pub struct StrMap(pub(crate) Arc<HashMap<String, String>>);
+
+impl StrMap {
+    /// Return a named value where available
+    pub fn get(&self, key: &str) -> Option<&str> {
+        self.0.get(key).map(|value| value.as_ref())
+    }
+
+    /// Return true if the underlying map is empty
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+
+    /// Return an iterator over keys and values
+    pub fn iter(&self) -> StrMapIter<'_> {
+        StrMapIter {
+            data: self,
+            keys: self.0.keys(),
+        }
+    }
+}
+
+impl Clone for StrMap {
+    fn clone(&self) -> Self {
+        // only clone the inner data
+        StrMap(self.0.clone())
+    }
+}
+impl From<HashMap<String, String>> for StrMap {
+    fn from(inner: HashMap<String, String>) -> Self {
+        StrMap(Arc::new(inner))
+    }
+}
+
+/// A read only reference to `StrMap` key and value slice pairings
+pub struct StrMapIter<'a> {
+    data: &'a StrMap,
+    keys: Keys<'a, String, String>,
+}
+
+impl<'a> Iterator for StrMapIter<'a> {
+    type Item = (&'a str, &'a str);
+
+    #[inline]
+    fn next(&mut self) -> Option<(&'a str, &'a str)> {
+        self.keys
+            .next()
+            .and_then(|k| self.data.get(k).map(|v| (k.as_str(), v)))
+    }
+}
+
+impl<'de> Deserialize<'de> for StrMap {
+    fn deserialize<D>(deserializer: D) -> Result<StrMap, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct StrMapVisitor;
+
+        impl<'de> Visitor<'de> for StrMapVisitor {
+            type Value = StrMap;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+                write!(formatter, "a StrMap")
+            }
+
+            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+            where
+                A: MapAccess<'de>,
+            {
+                let mut inner = HashMap::new();
+                while let Some((key, value)) = map.next_entry()? {
+                    inner.insert(key, value);
+                }
+                Ok(StrMap(Arc::new(inner)))
+            }
+        }
+
+        deserializer.deserialize_map(StrMapVisitor)
+    }
+}

packages/now-static-build/index.js

@@ -1,11 +1,21 @@
-const download = require('@now/build-utils/fs/download.js');
-const glob = require('@now/build-utils/fs/glob.js');
+const download = require('@now/build-utils/fs/download.js'); // eslint-disable-line import/no-extraneous-dependencies
+const glob = require('@now/build-utils/fs/glob.js'); // eslint-disable-line import/no-extraneous-dependencies
 const path = require('path');
+const { existsSync } = require('fs');
 const {
   runNpmInstall,
   runPackageJsonScript,
   runShellScript,
-} = require('@now/build-utils/fs/run-user-scripts.js');
+} = require('@now/build-utils/fs/run-user-scripts.js'); // eslint-disable-line import/no-extraneous-dependencies
+
+function validateDistDir(distDir) {
+  const distDirName = path.basename(distDir);
+  if (!existsSync(distDir)) {
+    const message = `Build was unable to create the distDir: ${distDirName}.`
+      + '\nMake sure you mentioned the correct dist directory: https://zeit.co/docs/v2/deployments/official-builders/static-build-now-static-build/#configuring-the-dist-directory';
+    throw new Error(message);
+  }
+}
 
 exports.build = async ({
   files, entrypoint, workPath, config,
@@ -24,6 +34,7 @@ exports.build = async ({
   if (path.basename(entrypoint) === 'package.json') {
     await runNpmInstall(entrypointFsDirname, ['--prefer-offline']);
     if (await runPackageJsonScript(entrypointFsDirname, 'now-build')) {
+      validateDistDir(distPath);
       return glob('**', distPath, mountpoint);
     }
     throw new Error(`An error running "now-build" script in "${entrypoint}"`);
@@ -31,6 +42,7 @@ exports.build = async ({
 
   if (path.extname(entrypoint) === '.sh') {
     await runShellScript(path.join(workPath, entrypoint));
+    validateDistDir(distPath);
     return glob('**', distPath, mountpoint);
   }
 

packages/now-static-build/package.json

@@ -1,9 +1,11 @@
 {
   "name": "@now/static-build",
-  "version": "0.4.17",
+  "version": "0.4.19-canary.1",
   "license": "MIT",
-  "peerDependencies": {
-    "@now/build-utils": ">=0.0.1"
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zeit/now-builders.git",
+    "directory": "packages/now-static-build"
   },
   "scripts": {
     "test": "jest"

packages/now-static-build/test/fixtures/04-wrong-dist-dir/now.json

@@ -0,0 +1,6 @@
+{
+  "version": 2,
+  "builds": [
+    { "src": "package.json", "use": "@now/static-build", "config": {"distDir": "out"} }
+  ]
+}