Publish

- @now/build-utils@0.4.41-canary.5
 - @now/next@0.1.3-canary.15
 - @now/node@0.5.4-canary.4

.circleci/config.yml

@@ -20,15 +20,15 @@ jobs:
       - run:
           name: Bootstrapping
           command: yarn bootstrap
-      - run:
-          name: Linting
-          command: yarn lint
       - run:
           name: Building
           command: ./.circleci/build.sh
       - run:
-          name: Tests
-          command: yarn test
+          name: Linting
+          command: yarn lint
+      - run:
+          name: Tests and Coverage
+          command: yarn test-coverage
       - run:
           name: Potentially save npm token
           command: "([[ ! -z $NPM_TOKEN ]] && echo \"//registry.npmjs.org/:_authToken=$NPM_TOKEN\" >> ~/.npmrc) || echo \"Did not write npm token\""

.eslintignore

@@ -2,3 +2,7 @@
 /node_modules/*
 /**/node_modules/*
 /packages/now-go/go/*
+/packages/now-build-utils/dist/*
+/packages/now-node/dist/*
+/packages/now-node-bridge/*
+/packages/now-python/*

.prettierrc.json

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

.vscode/settings.json

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

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

@@ -29,11 +29,13 @@ npm install next --save
 ```js
 module.exports = {
   target: 'serverless'
-  // Other options are still valid
+  // Other options
 }
 ```
 
-4. Optionally make sure the `"src"` in `"builds"` points to your application `package.json`
+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
 {

package.json

@@ -14,14 +14,17 @@
     "bootstrap": "lerna bootstrap",
     "publish-stable": "lerna version",
     "publish-canary": "lerna version prerelease --preid canary",
-    "lint": "tsc && eslint .",
+    "build": "./.circleci/build.sh",
+    "lint": "eslint .",
+    "codecov": "codecov",
     "test": "jest --runInBand --verbose",
+    "test-coverage": "jest --runInBand --verbose --coverage --globals \"{\\\"coverage\\\":true}\" && codecov",
     "lint-staged": "lint-staged"
   },
   "pre-commit": "lint-staged",
   "lint-staged": {
     "*.js": [
-      "prettier --write --single-quote",
+      "prettier --write",
       "eslint --fix",
       "git add"
     ]
@@ -33,6 +36,7 @@
     "@types/node": "^10.12.8",
     "async-retry": "1.2.3",
     "buffer-replace": "^1.0.0",
+    "codecov": "^3.2.0",
     "eslint": "^5.9.0",
     "eslint-config-airbnb-base": "^13.1.0",
     "eslint-config-prettier": "^3.1.0",
@@ -43,7 +47,6 @@
     "lint-staged": "^8.0.4",
     "node-fetch": "^2.3.0",
     "pre-commit": "^1.2.2",
-    "prettier": "^1.15.2",
-    "typescript": "^3.1.6"
+    "prettier": "^1.15.2"
   }
 }

packages/now-bash/bootstrap

@@ -7,7 +7,9 @@ export IMPORT_CACHE="$LAMBDA_TASK_ROOT/.import-cache"
 export PATH="$IMPORT_CACHE/bin:$PATH"
 
 # Load `import` and runtime
+# shellcheck disable=SC1090
 . "$(which import)"
+# shellcheck disable=SC1090
 . "$IMPORT_CACHE/runtime.sh"
 
 # Load user code and process events in a loop forever

packages/now-bash/index.js

@@ -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,6 +1,6 @@
 {
   "name": "@now/bash",
-  "version": "0.1.2",
+  "version": "0.1.5-canary.1",
   "description": "Now 2.0 builder for HTTP endpoints written in Bash",
   "main": "index.js",
   "author": "Nathan Rajlich <nate@zeit.co>",

packages/now-bash/runtime.sh

@@ -1,3 +1,4 @@
+#!/bin/bash
 import "static-binaries@1.0.0"
 static_binaries jq
 
@@ -13,12 +14,14 @@ _lambda_runtime_api() {
 
 _lambda_runtime_init() {
 	# Initialize user code
+	# shellcheck disable=SC1090
 	. "$SCRIPT_FILENAME" || {
 		local exit_code="$?"
-		local error
-		error='{"exitCode":'"$exit_code"'}'
+		local error_message="Initialization failed for '$SCRIPT_FILENAME' (exit code $exit_code)"
+		echo "$error_message" >&2
+		local error='{"errorMessage":"'"$error_message"'"}'
 		_lambda_runtime_api "init/error" -X POST -d "$error"
-		exit "$EXIT_CODE"
+		exit "$exit_code"
 	}
 
 	# Process events
@@ -45,18 +48,17 @@ _lambda_runtime_next() {
 	local body
 	body="$(mktemp)"
 
-	local exit_code=0
-	REQUEST="$event"
-
 	# Stdin of the `handler` function is the HTTP request body.
 	# Need to use a fifo here instead of bash <() because Lambda
 	# errors with "/dev/fd/63 not found" for some reason :/
 	local stdin
 	stdin="$(mktemp -u)"
 	mkfifo "$stdin"
-	_lambda_runtime_body "$event" > "$stdin" &
+	_lambda_runtime_body < "$event" > "$stdin" &
 
+	local exit_code=0
 	handler "$event" < "$stdin" > "$body" || exit_code="$?"
+
 	rm -f "$event" "$stdin"
 
 	if [ "$exit_code" -eq 0 ]; then
@@ -68,18 +70,21 @@ _lambda_runtime_next() {
 			| _lambda_runtime_api "invocation/$request_id/response" -X POST -d @- > /dev/null
 		rm -f "$body" "$_HEADERS"
 	else
-		echo "\`handler\` function return code: $exit_code"
-		_lambda_runtime_api "invocation/$request_id/error" -X POST -d @- > /dev/null <<< '{"exitCode":'"$exit_code"'}'
+		local error_message="Invocation failed for 'handler' function in '$SCRIPT_FILENAME' (exit code $exit_code)"
+		echo "$error_message" >&2
+		_lambda_runtime_api "invocation/$request_id/error" -X POST -d '{"errorMessage":"'"$error_message"'"}' > /dev/null
 	fi
 }
 
 _lambda_runtime_body() {
-	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
 }
@@ -97,7 +102,10 @@ http_response_header() {
 	local value="$2"
 	local tmp
 	tmp="$(mktemp)"
-	jq --arg name "$name" --arg value "$value" '.[$name] = $value' < "$_HEADERS" > "$tmp"
+	jq \
+		--arg name "$name" \
+		--arg value "$value" \
+		'.[$name] = $value' < "$_HEADERS" > "$tmp"
 	mv -f "$tmp" "$_HEADERS"
 }
 

packages/now-build-utils/.gitignore

@@ -0,0 +1,3 @@
+dist
+test/symlinks-out
+test/symlinks.zip

packages/now-build-utils/.npmignore

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

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

@@ -1,33 +1 @@
-const assert = require('assert');
-const intoStream = require('into-stream');
-
-class FileBlob {
-  constructor({ mode = 0o100644, data }) {
-    assert(typeof mode === 'number');
-    assert(typeof data === 'string' || Buffer.isBuffer(data));
-    this.type = 'FileBlob';
-    this.mode = mode;
-    this.data = data;
-  }
-
-  static async fromStream({ mode = 0o100644, stream }) {
-    assert(typeof mode === 'number');
-    assert(typeof stream.pipe === 'function'); // is-stream
-    const chunks = [];
-
-    await new Promise((resolve, reject) => {
-      stream.on('data', chunk => chunks.push(Buffer.from(chunk)));
-      stream.on('error', error => reject(error));
-      stream.on('end', () => resolve());
-    });
-
-    const data = Buffer.concat(chunks);
-    return new FileBlob({ mode, data });
-  }
-
-  toStream() {
-    return intoStream(this.data);
-  }
-}
-
-module.exports = FileBlob;
+module.exports = require('./dist/index').FileBlob;

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

@@ -1,100 +1 @@
-const assert = require('assert');
-const fs = require('fs-extra');
-const multiStream = require('multistream');
-const path = require('path');
-const Sema = require('async-sema');
-
-/** @typedef {{[filePath: string]: FileFsRef}} FsFiles */
-
-const semaToPreventEMFILE = new Sema(30);
-
-/**
- * @constructor
- * @argument {Object} options
- * @argument {number} [options.mode=0o100644]
- * @argument {string} options.fsPath
- */
-class FileFsRef {
-  constructor({ mode = 0o100644, fsPath }) {
-    assert(typeof mode === 'number');
-    assert(typeof fsPath === 'string');
-    /** @type {string} */
-    this.type = 'FileFsRef';
-    /** @type {number} */
-    this.mode = mode;
-    /** @type {string} */
-    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]
-   * @argument {NodeJS.ReadableStream} options.stream
-   * @argument {string} options.fsPath
-   * @returns {Promise<FileFsRef>}
-   */
-  static async fromStream({ mode = 0o100644, stream, fsPath }) {
-    assert(typeof mode === 'number');
-    assert(typeof stream.pipe === 'function'); // is-stream
-    assert(typeof fsPath === 'string');
-    await fs.mkdirp(path.dirname(fsPath));
-
-    await new Promise((resolve, reject) => {
-      const dest = fs.createWriteStream(fsPath);
-      stream.pipe(dest);
-      stream.on('error', reject);
-      dest.on('finish', resolve);
-      dest.on('error', reject);
-    });
-
-    await fs.chmod(fsPath, mode.toString(8).slice(-3));
-    return new FileFsRef({ mode, fsPath });
-  }
-
-  /**
-   * @returns {Promise<NodeJS.ReadableStream>}
-   */
-  async toStreamAsync() {
-    await semaToPreventEMFILE.acquire();
-    const release = () => semaToPreventEMFILE.release();
-    const stream = fs.createReadStream(this.fsPath);
-    stream.on('close', release);
-    stream.on('error', release);
-    return stream;
-  }
-
-  /**
-   * @returns {NodeJS.ReadableStream}
-   */
-  toStream() {
-    let flag;
-
-    // eslint-disable-next-line consistent-return
-    return multiStream((cb) => {
-      if (flag) return cb(null, null);
-      flag = true;
-
-      this.toStreamAsync()
-        .then((stream) => {
-          cb(null, stream);
-        })
-        .catch((error) => {
-          cb(error, null);
-        });
-    });
-  }
-}
-
-module.exports = FileFsRef;
+module.exports = require('./dist/index').FileFsRef;

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

@@ -1,96 +1 @@
-const assert = require('assert');
-const fetch = require('node-fetch');
-const multiStream = require('multistream');
-const retry = require('async-retry');
-const Sema = require('async-sema');
-
-/** @typedef {{[filePath: string]: FileRef}} Files */
-
-const semaToDownloadFromS3 = new Sema(10);
-
-class BailableError extends Error {
-  constructor(...args) {
-    super(...args);
-    /** @type {boolean} */
-    this.bail = false;
-  }
-}
-
-/**
- * @constructor
- * @argument {Object} options
- * @argument {number} [options.mode=0o100644]
- * @argument {string} options.digest
- */
-class FileRef {
-  constructor({ mode = 0o100644, digest }) {
-    assert(typeof mode === 'number');
-    assert(typeof digest === 'string');
-    /** @type {string} */
-    this.type = 'FileRef';
-    /** @type {number} */
-    this.mode = mode;
-    /** @type {string} */
-    this.digest = digest;
-  }
-
-  /**
-   * @returns {Promise<NodeJS.ReadableStream>}
-   */
-  async toStreamAsync() {
-    let url;
-    // sha:24be087eef9fac01d61b30a725c1a10d7b45a256
-    const digestParts = this.digest.split(':');
-    if (digestParts[0] === 'sha') {
-      // url = `https://s3.amazonaws.com/now-files/${digestParts[1]}`;
-      url = `https://dmmcy0pwk6bqi.cloudfront.net/${digestParts[1]}`;
-    }
-
-    assert(url);
-
-    await semaToDownloadFromS3.acquire();
-    // console.time(`downloading ${url}`);
-    try {
-      return await retry(
-        async () => {
-          const resp = await fetch(url);
-          if (!resp.ok) {
-            const error = new BailableError(
-              `download: ${resp.status} ${resp.statusText} for ${url}`,
-            );
-            if (resp.status === 403) error.bail = true;
-            throw error;
-          }
-          return resp.body;
-        },
-        { factor: 1, retries: 3 },
-      );
-    } finally {
-      // console.timeEnd(`downloading ${url}`);
-      semaToDownloadFromS3.release();
-    }
-  }
-
-  /**
-   * @returns {NodeJS.ReadableStream}
-   */
-  toStream() {
-    let flag;
-
-    // eslint-disable-next-line consistent-return
-    return multiStream((cb) => {
-      if (flag) return cb(null, null);
-      flag = true;
-
-      this.toStreamAsync()
-        .then((stream) => {
-          cb(null, stream);
-        })
-        .catch((error) => {
-          cb(error, null);
-        });
-    });
-  }
-}
-
-module.exports = FileRef;
+module.exports = require('./dist/index').FileRef;

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

@@ -1,38 +1 @@
-const path = require('path');
-const FileFsRef = require('../file-fs-ref.js');
-
-/** @typedef {import('../file-ref')} FileRef */
-/** @typedef {import('../file-fs-ref')} FileFsRef */
-/** @typedef {{[filePath: string]: FileRef|FileFsRef}} Files */
-/** @typedef {{[filePath: string]: FileFsRef}|{}} DownloadedFiles */
-
-/**
- * @param {FileRef|FileFsRef} file
- * @param {string} fsPath
- * @returns {Promise<FileFsRef>}
- */
-async function downloadFile(file, fsPath) {
-  const { mode } = file;
-  const stream = file.toStream();
-  return FileFsRef.fromStream({ mode, stream, fsPath });
-}
-
-/**
- * Download files to disk
- * @argument {Files} files
- * @argument {string} basePath
- * @returns {Promise<DownloadedFiles>}
- */
-module.exports = async function download(files, basePath) {
-  const files2 = {};
-
-  await Promise.all(
-    Object.keys(files).map(async (name) => {
-      const file = files[name];
-      const fsPath = path.join(basePath, name);
-      files2[name] = await downloadFile(file, fsPath);
-    }),
-  );
-
-  return files2;
-};
+module.exports = require('../dist/fs/download').default;

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

@@ -1,12 +1 @@
-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');
-
-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);
-  return directory;
-};
+module.exports = require('../dist/fs/get-writable-directory').default;

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

@@ -1,67 +1 @@
-const assert = require('assert');
-const path = require('path');
-const vanillaGlob = require('glob');
-const FileFsRef = require('../file-fs-ref.js');
-
-/** @typedef {import('fs').Stats} Stats */
-/** @typedef {import('glob').IOptions} GlobOptions */
-/** @typedef {import('../file-fs-ref').FsFiles|{}} GlobFiles */
-
-/**
- * @argument {string} pattern
- * @argument {GlobOptions|string} opts
- * @argument {string} [mountpoint]
- * @returns {Promise<GlobFiles>}
- */
-module.exports = function glob(pattern, opts = {}, mountpoint) {
-  return new Promise((resolve, reject) => {
-    /** @type {GlobOptions} */
-    let options;
-    if (typeof opts === 'string') {
-      options = { cwd: opts };
-    } else {
-      options = opts;
-    }
-
-    if (!options.cwd) {
-      throw new Error(
-        'Second argument (basePath) must be specified for names of resulting files',
-      );
-    }
-
-    if (!path.isAbsolute(options.cwd)) {
-      throw new Error(`basePath/cwd must be an absolute path (${options.cwd})`);
-    }
-
-    options.statCache = {};
-    options.stat = true;
-    options.dot = true;
-
-    // eslint-disable-next-line consistent-return
-    vanillaGlob(pattern, options, (error, files) => {
-      if (error) return reject(error);
-
-      resolve(
-        files.reduce((files2, relativePath) => {
-          const fsPath = path.join(options.cwd, relativePath);
-          /** @type {Stats|any} */
-          const stat = options.statCache[fsPath];
-          assert(
-            stat,
-            `statCache does not contain value for ${relativePath} (resolved to ${fsPath})`,
-          );
-          if (stat && stat.isFile()) {
-            let finalPath = relativePath;
-            if (mountpoint) finalPath = path.join(mountpoint, finalPath);
-            return {
-              ...files2,
-              [finalPath]: new FileFsRef({ mode: stat.mode, fsPath }),
-            };
-          }
-
-          return files2;
-        }, {}),
-      );
-    });
-  });
-};
+module.exports = require('../dist/fs/glob').default;

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

@@ -1,25 +1 @@
-/** @typedef { import('@now/build-utils/file-ref') } FileRef */
-/** @typedef { import('@now/build-utils/file-fs-ref') } FileFsRef */
-/** @typedef {{[filePath: string]: FileRef|FileFsRef}} Files */
-
-/**
- * @callback delegate
- * @argument {string} name
- * @returns {string}
- */
-
-/**
- * Rename files using delegate function
- * @argument {Files} files
- * @argument {delegate} delegate
- * @returns {Files}
- */
-module.exports = function rename(files, delegate) {
-  return Object.keys(files).reduce(
-    (newFiles, name) => ({
-      ...newFiles,
-      [delegate(name)]: files[name],
-    }),
-    {},
-  );
-};
+module.exports = require('../dist/fs/rename').default;

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

@@ -1,96 +1 @@
-const assert = require('assert');
-const fs = require('fs-extra');
-const path = require('path');
-const { spawn } = require('child_process');
-
-function spawnAsync(command, args, cwd) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(command, args, { stdio: 'inherit', cwd });
-    child.on('error', reject);
-    child.on('close', (code, signal) => (code !== 0
-      ? reject(new Error(`Exited with ${code || signal}`))
-      : resolve()));
-  });
-}
-
-async function runShellScript(fsPath) {
-  assert(path.isAbsolute(fsPath));
-  const destPath = path.dirname(fsPath);
-  await spawnAsync(`./${path.basename(fsPath)}`, [], destPath);
-  return true;
-}
-
-async function scanParentDirs(destPath, scriptName) {
-  assert(path.isAbsolute(destPath));
-
-  let hasScript = false;
-  let hasPackageLockJson = false;
-  let currentDestPath = destPath;
-
-  // eslint-disable-next-line no-constant-condition
-  while (true) {
-    const packageJsonPath = path.join(currentDestPath, 'package.json');
-    // eslint-disable-next-line no-await-in-loop
-    if (await fs.exists(packageJsonPath)) {
-      // eslint-disable-next-line no-await-in-loop
-      const packageJson = JSON.parse(await fs.readFile(packageJsonPath));
-      hasScript = Boolean(
-        packageJson.scripts && scriptName && packageJson.scripts[scriptName],
-      );
-      // eslint-disable-next-line no-await-in-loop
-      hasPackageLockJson = await fs.exists(
-        path.join(currentDestPath, 'package-lock.json'),
-      );
-      break;
-    }
-
-    const newDestPath = path.dirname(currentDestPath);
-    if (currentDestPath === newDestPath) break;
-    currentDestPath = newDestPath;
-  }
-
-  return { hasScript, hasPackageLockJson };
-}
-
-async function installDependencies(destPath, args = []) {
-  assert(path.isAbsolute(destPath));
-
-  let commandArgs = args;
-  console.log(`installing to ${destPath}`);
-  const { hasPackageLockJson } = await scanParentDirs(destPath);
-
-  if (hasPackageLockJson) {
-    commandArgs = args.filter(a => a !== '--prefer-offline');
-    await spawnAsync('npm', ['install'].concat(commandArgs), destPath);
-    await spawnAsync('npm', ['cache', 'clean', '--force'], destPath);
-  } else {
-    await spawnAsync('yarn', ['--cwd', destPath].concat(commandArgs), destPath);
-    await spawnAsync('yarn', ['cache', 'clean'], destPath);
-  }
-}
-
-async function runPackageJsonScript(destPath, scriptName) {
-  assert(path.isAbsolute(destPath));
-  const { hasScript, hasPackageLockJson } = await scanParentDirs(
-    destPath,
-    scriptName,
-  );
-  if (!hasScript) return false;
-
-  if (hasPackageLockJson) {
-    console.log(`running "npm run ${scriptName}"`);
-    await spawnAsync('npm', ['run', scriptName], destPath);
-  } else {
-    console.log(`running "yarn run ${scriptName}"`);
-    await spawnAsync('yarn', ['--cwd', destPath, 'run', scriptName], destPath);
-  }
-
-  return true;
-}
-
-module.exports = {
-  runShellScript,
-  installDependencies,
-  runNpmInstall: installDependencies,
-  runPackageJsonScript,
-};
+module.exports = require('../dist/fs/run-user-scripts');

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

@@ -1,4 +1 @@
-const fastStreamToBuffer = require('fast-stream-to-buffer');
-const { promisify } = require('util');
-
-module.exports = promisify(fastStreamToBuffer);
+module.exports = require('../dist/fs/stream-to-buffer').default;

packages/now-build-utils/lambda.js

@@ -1,60 +1 @@
-const assert = require('assert');
-const Sema = require('async-sema');
-const { ZipFile } = require('yazl');
-const streamToBuffer = require('./fs/stream-to-buffer.js');
-
-class Lambda {
-  constructor({
-    zipBuffer, handler, runtime, environment,
-  }) {
-    this.type = 'Lambda';
-    this.zipBuffer = zipBuffer;
-    this.handler = handler;
-    this.runtime = runtime;
-    this.environment = environment;
-  }
-}
-
-const sema = new Sema(10);
-const mtime = new Date(1540000000000);
-
-async function createLambda({
-  files, handler, runtime, environment = {},
-}) {
-  assert(typeof files === 'object', '"files" must be an object');
-  assert(typeof handler === 'string', '"handler" is not a string');
-  assert(typeof runtime === 'string', '"runtime" is not a string');
-  assert(typeof environment === 'object', '"environment" is not an object');
-
-  await sema.acquire();
-  try {
-    const zipFile = new ZipFile();
-    const zipBuffer = await new Promise((resolve, reject) => {
-      Object.keys(files)
-        .sort()
-        .forEach((name) => {
-          const file = files[name];
-          const stream = file.toStream();
-          stream.on('error', reject);
-          zipFile.addReadStream(stream, name, { mode: file.mode, mtime });
-        });
-
-      zipFile.end();
-      streamToBuffer(zipFile.outputStream).then(resolve).catch(reject);
-    });
-
-    return new Lambda({
-      zipBuffer,
-      handler,
-      runtime,
-      environment,
-    });
-  } finally {
-    sema.release();
-  }
-}
-
-module.exports = {
-  Lambda,
-  createLambda,
-};
+module.exports = require('./dist/index');

packages/now-build-utils/package.json

@@ -1,7 +1,9 @@
 {
   "name": "@now/build-utils",
-  "version": "0.4.35-canary.2",
+  "version": "0.4.41-canary.5",
   "license": "MIT",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.js",
   "repository": {
     "type": "git",
     "url": "https://github.com/zeit/now-builders.git",
@@ -10,16 +12,28 @@
   "dependencies": {
     "async-retry": "1.2.3",
     "async-sema": "2.1.4",
-    "fast-stream-to-buffer": "1.0.0",
+    "end-of-stream": "1.4.1",
     "fs-extra": "7.0.0",
     "glob": "7.1.3",
-    "into-stream": "4.0.0",
+    "into-stream": "5.0.0",
     "memory-fs": "0.4.1",
     "multistream": "2.1.1",
     "node-fetch": "2.2.0",
     "yazl": "2.4.3"
   },
   "scripts": {
-    "test": "jest"
+    "build": "tsc",
+    "test": "tsc && jest",
+    "prepublish": "tsc"
+  },
+  "devDependencies": {
+    "@types/async-retry": "^1.2.1",
+    "@types/end-of-stream": "^1.4.0",
+    "@types/fs-extra": "^5.0.5",
+    "@types/glob": "^7.1.1",
+    "@types/node-fetch": "^2.1.6",
+    "@types/yazl": "^2.4.1",
+    "execa": "^1.0.0",
+    "typescript": "3.3.4000"
   }
 }

packages/now-build-utils/src/file-blob.ts

@@ -0,0 +1,46 @@
+import assert from 'assert';
+import intoStream from 'into-stream';
+import { File } from './types';
+
+interface FileBlobOptions {
+  mode?: number;
+  data: string | Buffer;
+}
+
+interface FromStreamOptions {
+  mode?: number;
+  stream: NodeJS.ReadableStream;
+}
+
+export default class FileBlob implements File {
+  public type: 'FileBlob';
+  public mode: number;
+  public data: string | Buffer;
+
+  constructor({ mode = 0o100644, data }: FileBlobOptions) {
+    assert(typeof mode === 'number');
+    assert(typeof data === 'string' || Buffer.isBuffer(data));
+    this.type = 'FileBlob';
+    this.mode = mode;
+    this.data = data;
+  }
+
+  static async fromStream({ mode = 0o100644, stream }: FromStreamOptions) {
+    assert(typeof mode === 'number');
+    assert(typeof stream.pipe === 'function'); // is-stream
+    const chunks: Buffer[] = [];
+
+    await new Promise<void>((resolve, reject) => {
+      stream.on('data', chunk => chunks.push(Buffer.from(chunk)));
+      stream.on('error', error => reject(error));
+      stream.on('end', () => resolve());
+    });
+
+    const data = Buffer.concat(chunks);
+    return new FileBlob({ mode, data });
+  }
+
+  toStream(): NodeJS.ReadableStream {
+    return intoStream(this.data);
+  }
+}

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

@@ -0,0 +1,90 @@
+import assert from 'assert';
+import fs from 'fs-extra';
+import multiStream from 'multistream';
+import path from 'path';
+import Sema from 'async-sema';
+import { File } from './types';
+
+const semaToPreventEMFILE = new Sema(20);
+
+interface FileFsRefOptions {
+  mode?: number;
+  fsPath: string;
+}
+
+interface FromStreamOptions {
+  mode: number;
+  stream: NodeJS.ReadableStream;
+  fsPath: string;
+}
+
+class FileFsRef implements File {
+  public type: 'FileFsRef';
+  public mode: number;
+  public fsPath: string;
+
+  constructor({ mode = 0o100644, fsPath }: FileFsRefOptions) {
+    assert(typeof mode === 'number');
+    assert(typeof fsPath === 'string');
+    this.type = 'FileFsRef';
+    this.mode = mode;
+    this.fsPath = fsPath;
+  }
+
+  static async fromFsPath({ mode, fsPath }: FileFsRefOptions): Promise<FileFsRef> {
+    let m = mode;
+    if (!m) {
+      const stat = await fs.lstat(fsPath);
+      m = stat.mode;
+    }
+    return new FileFsRef({ mode: m, fsPath });
+  }
+
+  static async fromStream({ mode = 0o100644, stream, fsPath }: FromStreamOptions): Promise<FileFsRef> {
+    assert(typeof mode === 'number');
+    assert(typeof stream.pipe === 'function'); // is-stream
+    assert(typeof fsPath === 'string');
+    await fs.mkdirp(path.dirname(fsPath));
+
+    await new Promise<void>((resolve, reject) => {
+      const dest = fs.createWriteStream(fsPath, {
+        mode: mode & 0o777
+      });
+      stream.pipe(dest);
+      stream.on('error', reject);
+      dest.on('finish', resolve);
+      dest.on('error', reject);
+    });
+
+    return new FileFsRef({ mode, fsPath });
+  }
+
+  async toStreamAsync(): Promise<NodeJS.ReadableStream> {
+    await semaToPreventEMFILE.acquire();
+    const release = () => semaToPreventEMFILE.release();
+    const stream = fs.createReadStream(this.fsPath);
+    stream.on('close', release);
+    stream.on('error', release);
+    return stream;
+  }
+
+  toStream(): NodeJS.ReadableStream {
+    let flag = false;
+
+    // eslint-disable-next-line consistent-return
+    return multiStream((cb) => {
+      if (flag) return cb(null, null);
+      flag = true;
+
+      this.toStreamAsync()
+        .then((stream) => {
+          cb(null, stream);
+        })
+        .catch((error) => {
+          cb(error, null);
+        });
+    });
+  }
+}
+
+export = FileFsRef;

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

@@ -0,0 +1,93 @@
+import assert from 'assert';
+import fetch from 'node-fetch';
+import multiStream from 'multistream';
+import retry from 'async-retry';
+import Sema from 'async-sema';
+import { File } from './types';
+
+interface FileRefOptions {
+  mode?: number;
+  digest: string;
+  mutable?: boolean;
+}
+
+const semaToDownloadFromS3 = new Sema(5);
+
+class BailableError extends Error {
+  public bail: boolean;
+
+  constructor(...args: string[]) {
+    super(...args);
+    this.bail = false;
+  }
+}
+
+export default class FileRef implements File {
+  public type: 'FileRef';
+  public mode: number;
+  public digest: string;
+  public mutable: boolean;
+
+  constructor({ mode = 0o100644, digest, mutable = false }: FileRefOptions) {
+    assert(typeof mode === 'number');
+    assert(typeof digest === 'string');
+    assert(typeof mutable === 'boolean');
+    this.type = 'FileRef';
+    this.mode = mode;
+    this.digest = digest;
+    this.mutable = mutable;
+  }
+
+  async toStreamAsync(): Promise<NodeJS.ReadableStream> {
+    let url = '';
+    // sha:24be087eef9fac01d61b30a725c1a10d7b45a256
+    const digestParts = this.digest.split(':');
+    if (digestParts[0] === 'sha') {
+      url = this.mutable
+        ? `https://s3.amazonaws.com/now-files/${digestParts[1]}`
+        : `https://dmmcy0pwk6bqi.cloudfront.net/${digestParts[1]}`;
+    } else {
+      throw new Error('Expected digest to be sha');
+    }
+
+    await semaToDownloadFromS3.acquire();
+    // console.time(`downloading ${url}`);
+    try {
+      return await retry(
+        async () => {
+          const resp = await fetch(url);
+          if (!resp.ok) {
+            const error = new BailableError(
+              `download: ${resp.status} ${resp.statusText} for ${url}`,
+            );
+            if (resp.status === 403) error.bail = true;
+            throw error;
+          }
+          return resp.body;
+        },
+        { factor: 1, retries: 3 },
+      );
+    } finally {
+      // console.timeEnd(`downloading ${url}`);
+      semaToDownloadFromS3.release();
+    }
+  }
+
+  toStream(): NodeJS.ReadableStream {
+    let flag = false;
+
+    // eslint-disable-next-line consistent-return
+    return multiStream((cb) => {
+      if (flag) return cb(null, null);
+      flag = true;
+
+      this.toStreamAsync()
+        .then((stream) => {
+          cb(null, stream);
+        })
+        .catch((error) => {
+          cb(error, null);
+        });
+    });
+  }
+}

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

@@ -0,0 +1,44 @@
+import path from 'path';
+import FileFsRef from '../file-fs-ref';
+import { File, Files } from '../types';
+import { mkdirp, readlink, symlink } from 'fs-extra';
+
+export interface DownloadedFiles {
+  [filePath: string]: FileFsRef
+}
+
+const S_IFMT = 61440;   /* 0170000 type of file */
+const S_IFLNK = 40960;  /* 0120000 symbolic link */
+
+export function isSymbolicLink(mode: number): boolean {
+  return (mode & S_IFMT) === S_IFLNK;
+}
+
+async function downloadFile(file: File, fsPath: string): Promise<FileFsRef> {
+  const { mode } = file;
+  if (mode && isSymbolicLink(mode) && file.type === 'FileFsRef') {
+    const [ target ] = await Promise.all([
+      readlink((file as FileFsRef).fsPath),
+      mkdirp(path.dirname(fsPath))
+    ]);
+    await symlink(target, fsPath);
+    return FileFsRef.fromFsPath({ mode, fsPath });
+  } else {
+    const stream = file.toStream();
+    return FileFsRef.fromStream({ mode, stream, fsPath });
+  }
+}
+
+export default async function download(files: Files, basePath: string): Promise<DownloadedFiles> {
+  const files2: DownloadedFiles = {};
+
+  await Promise.all(
+    Object.keys(files).map(async (name) => {
+      const file = files[name];
+      const fsPath = path.join(basePath, name);
+      files2[name] = await downloadFile(file, fsPath);
+    }),
+  );
+
+  return files2;
+}

packages/now-build-utils/src/fs/get-writable-directory.ts

@@ -0,0 +1,10 @@
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { mkdirp } from 'fs-extra';
+
+export default async function getWritableDirectory() {
+  const name = Math.floor(Math.random() * 0x7fffffff).toString(16);
+  const directory = join(tmpdir(), name);
+  await mkdirp(directory);
+  return directory;
+}

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

@@ -0,0 +1,66 @@
+import path from 'path';
+import assert from 'assert';
+import vanillaGlob_ from 'glob';
+import { promisify } from 'util';
+import { lstat, Stats } from 'fs-extra';
+import FileFsRef from '../file-fs-ref';
+
+type GlobOptions = vanillaGlob_.IOptions;
+
+interface FsFiles {
+  [filePath: string]: FileFsRef
+}
+
+const vanillaGlob = promisify(vanillaGlob_);
+
+export default async function glob(pattern: string, opts: GlobOptions | string, mountpoint?: string): Promise<FsFiles> {
+  let options: GlobOptions;
+  if (typeof opts === 'string') {
+    options = { cwd: opts };
+  } else {
+    options = opts;
+  }
+
+  if (!options.cwd) {
+    throw new Error(
+      'Second argument (basePath) must be specified for names of resulting files',
+    );
+  }
+
+  if (!path.isAbsolute(options.cwd)) {
+    throw new Error(`basePath/cwd must be an absolute path (${options.cwd})`);
+  }
+
+  const results: FsFiles = {};
+
+  options.symlinks = {};
+  options.statCache = {};
+  options.stat = true;
+  options.dot = true;
+
+  const files = await vanillaGlob(pattern, options);
+
+  for (const relativePath of files) {
+    const fsPath = path.join(options.cwd!, relativePath);
+    let stat: Stats = options.statCache![fsPath] as Stats;
+    assert(
+      stat,
+      `statCache does not contain value for ${relativePath} (resolved to ${fsPath})`,
+    );
+    if (stat.isFile()) {
+      const isSymlink = options.symlinks![fsPath];
+      if (isSymlink) {
+        stat = await lstat(fsPath);
+      }
+
+      let finalPath = relativePath;
+      if (mountpoint) {
+        finalPath = path.join(mountpoint, finalPath);
+      }
+
+      results[finalPath] = new FileFsRef({ mode: stat.mode, fsPath });
+    }
+  }
+
+  return results;
+}

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

@@ -0,0 +1,12 @@
+import { Files } from '../types';
+type Delegate = (name: string) => string;
+
+export default function rename(files: Files, delegate: Delegate): Files {
+  return Object.keys(files).reduce(
+    (newFiles, name) => ({
+      ...newFiles,
+      [delegate(name)]: files[name],
+    }),
+    {},
+  );
+}

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

@@ -0,0 +1,134 @@
+import assert from 'assert';
+import fs from 'fs-extra';
+import path from 'path';
+import { spawn, SpawnOptions } from 'child_process';
+
+function spawnAsync(command: string, args: string[], cwd: string, opts: SpawnOptions = {}) {
+  return new Promise<void>((resolve, reject) => {
+    const stderrLogs: Buffer[] = []
+    opts = { stdio: 'inherit', cwd, ...opts };
+    const child = spawn(command, args, opts);
+
+    if (opts.stdio === 'pipe'){
+      child.stderr.on('data', data => stderrLogs.push(data));
+    }
+
+    child.on('error', reject);
+    child.on('close', (code, signal) => {
+      if (code === 0) {
+        return resolve()
+      }
+
+      const errorLogs = stderrLogs.map(line => line.toString()).join('');
+      if (opts.stdio !== 'inherit') {
+        reject(new Error(`Exited with ${code || signal}\n${errorLogs}`));
+      } else {
+        reject(new Error(`Exited with ${code || signal}`));
+      }
+    });
+  });
+}
+
+async function chmodPlusX(fsPath: string) {
+  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);
+}
+
+export async function runShellScript(fsPath: string) {
+  assert(path.isAbsolute(fsPath));
+  const destPath = path.dirname(fsPath);
+  await chmodPlusX(fsPath);
+  await spawnAsync(`./${path.basename(fsPath)}`, [], destPath);
+  return true;
+}
+
+async function scanParentDirs(destPath: string, scriptName?: string) {
+  assert(path.isAbsolute(destPath));
+
+  let hasScript = false;
+  let hasPackageLockJson = false;
+  let currentDestPath = destPath;
+
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    const packageJsonPath = path.join(currentDestPath, 'package.json');
+    // eslint-disable-next-line no-await-in-loop
+    if (await fs.pathExists(packageJsonPath)) {
+      // eslint-disable-next-line no-await-in-loop
+      const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf8'));
+      hasScript = Boolean(
+        packageJson.scripts && scriptName && packageJson.scripts[scriptName],
+      );
+      // eslint-disable-next-line no-await-in-loop
+      hasPackageLockJson = await fs.pathExists(
+        path.join(currentDestPath, 'package-lock.json'),
+      );
+      break;
+    }
+
+    const newDestPath = path.dirname(currentDestPath);
+    if (currentDestPath === newDestPath) break;
+    currentDestPath = newDestPath;
+  }
+
+  return { hasScript, hasPackageLockJson };
+}
+
+export async function installDependencies(destPath: string, args: string[] = []) {
+  assert(path.isAbsolute(destPath));
+
+  let commandArgs = 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',
+    },
+    stdio: 'pipe'
+  };
+
+  if (hasPackageLockJson) {
+    commandArgs = args.filter(a => a !== '--prefer-offline');
+    await spawnAsync(
+      'npm',
+      ['install'].concat(commandArgs),
+      destPath,
+      opts as SpawnOptions
+    );
+  } else {
+    await spawnAsync(
+      'yarn',
+      ['--cwd', destPath].concat(commandArgs),
+      destPath,
+      opts as SpawnOptions,
+    );
+  }
+}
+
+export async function runPackageJsonScript(destPath: string, scriptName: string) {
+  assert(path.isAbsolute(destPath));
+  const { hasScript, hasPackageLockJson } = await scanParentDirs(
+    destPath,
+    scriptName,
+  );
+  if (!hasScript) return false;
+
+  if (hasPackageLockJson) {
+    console.log(`running "npm run ${scriptName}"`);
+    await spawnAsync('npm', ['run', scriptName], destPath);
+  } else {
+    console.log(`running "yarn run ${scriptName}"`);
+    await spawnAsync('yarn', ['--cwd', destPath, 'run', scriptName], destPath);
+  }
+
+  return true;
+}
+
+export const runNpmInstall = installDependencies;

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

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

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

@@ -0,0 +1,33 @@
+import FileBlob from './file-blob';
+import FileFsRef from './file-fs-ref';
+import FileRef from './file-ref';
+import { File, Files, AnalyzeOptions, BuildOptions, PrepareCacheOptions, ShouldServeOptions } from './types';
+import { Lambda, createLambda } from './lambda';
+import download from './fs/download';
+import getWriteableDirectory from './fs/get-writable-directory'
+import glob from './fs/glob';
+import rename from './fs/rename';
+import { installDependencies, runPackageJsonScript, runNpmInstall, runShellScript } from './fs/run-user-scripts';
+import streamToBuffer from './fs/stream-to-buffer';
+import shouldServe from './should-serve';
+
+export {
+    FileBlob,
+    FileFsRef,
+    FileRef,
+    Files,
+    File,
+    Lambda,
+    createLambda,
+    download,
+    getWriteableDirectory,
+    glob,
+    rename,
+    installDependencies, runPackageJsonScript, runNpmInstall, runShellScript,
+    streamToBuffer,
+    AnalyzeOptions,
+    BuildOptions,
+    PrepareCacheOptions,
+    ShouldServeOptions,
+    shouldServe,
+};

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

@@ -0,0 +1,104 @@
+import assert from 'assert';
+import Sema from 'async-sema';
+import { ZipFile } from 'yazl';
+import { readlink } from 'fs-extra';
+import { Files } from './types';
+import FileFsRef from './file-fs-ref';
+import { isSymbolicLink } from './fs/download';
+import streamToBuffer from './fs/stream-to-buffer';
+
+interface Environment {
+  [key: string]: string;
+}
+
+interface LambdaOptions {
+  zipBuffer: Buffer;
+  handler: string;
+  runtime: string;
+  environment: Environment;
+}
+
+interface CreateLambdaOptions {
+  files: Files;
+  handler: string;
+  runtime: string;
+  environment?: Environment;
+}
+
+export class Lambda {
+  public type: 'Lambda';
+  public zipBuffer: Buffer;
+  public handler: string;
+  public runtime: string;
+  public environment: Environment;
+
+  constructor({
+    zipBuffer, handler, runtime, environment,
+  }: LambdaOptions) {
+    this.type = 'Lambda';
+    this.zipBuffer = zipBuffer;
+    this.handler = handler;
+    this.runtime = runtime;
+    this.environment = environment;
+  }
+}
+
+const sema = new Sema(10);
+const mtime = new Date(1540000000000);
+
+export async function createLambda({
+  files, handler, runtime, environment = {},
+}: CreateLambdaOptions): Promise<Lambda> {
+  assert(typeof files === 'object', '"files" must be an object');
+  assert(typeof handler === 'string', '"handler" is not a string');
+  assert(typeof runtime === 'string', '"runtime" is not a string');
+  assert(typeof environment === 'object', '"environment" is not an object');
+
+  await sema.acquire();
+
+  try {
+    const zipBuffer = await createZip(files);
+    return new Lambda({
+      zipBuffer,
+      handler,
+      runtime,
+      environment,
+    });
+  } finally {
+    sema.release();
+  }
+}
+
+export async function createZip(files: Files): Promise<Buffer> {
+  const names = Object.keys(files).sort();
+
+  const symlinkTargets = new Map<string, string>();
+  for (const name of names) {
+    const file = files[name];
+    if (file.mode && isSymbolicLink(file.mode) && file.type === 'FileFsRef') {
+      const symlinkTarget = await readlink((file as FileFsRef).fsPath);
+      symlinkTargets.set(name, symlinkTarget);
+    }
+  }
+
+  const zipFile = new ZipFile();
+  const zipBuffer = await new Promise<Buffer>((resolve, reject) => {
+    for (const name of names) {
+      const file = files[name];
+      const opts = { mode: file.mode, mtime };
+      const symlinkTarget = symlinkTargets.get(name);
+      if (typeof symlinkTarget === 'string') {
+        zipFile.addBuffer(Buffer.from(symlinkTarget, 'utf8'), name, opts);
+      } else {
+        const stream = file.toStream() as import('stream').Readable;
+        stream.on('error', reject);
+        zipFile.addReadStream(stream, name, opts);
+      }
+    }
+
+    zipFile.end();
+    streamToBuffer(zipFile.outputStream).then(resolve).catch(reject);
+  });
+
+  return zipBuffer;
+}

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

@@ -0,0 +1,27 @@
+import { parse } from 'path';
+import { ShouldServeOptions } from './types';
+import FileFsRef from './file-fs-ref';
+
+export default function shouldServe({
+  entrypoint,
+  files,
+  requestPath
+}: ShouldServeOptions): boolean {
+  requestPath = requestPath.replace(/\/$/, ''); // sanitize trailing '/'
+  entrypoint = entrypoint.replace(/\\/, '/'); // windows compatibility
+
+  if (entrypoint === requestPath && hasProp(files, entrypoint)) {
+    return true;
+  }
+
+  const { dir, name } = parse(entrypoint);
+  if (name === 'index' && dir === requestPath && hasProp(files, entrypoint)) {
+    return true;
+  }
+
+  return false;
+}
+
+function hasProp(obj: { [path: string]: FileFsRef }, key: string): boolean {
+  return Object.hasOwnProperty.call(obj, key)
+}

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

@@ -0,0 +1,128 @@
+import FileFsRef from './file-fs-ref';
+
+export interface File {
+  type: string;
+  mode: number;
+  toStream: () => NodeJS.ReadableStream;
+}
+
+export interface Files {
+  [filePath: string]: File
+}
+
+export interface Config {
+  [key: string]: string
+}
+
+export interface AnalyzeOptions {
+  /**
+   * All source files of the project
+   */
+  files: Files;
+
+  /**
+   * Name of entrypoint file for this particular build job. Value
+   * `files[entrypoint]` is guaranteed to exist and be a valid File reference.
+   * `entrypoint` is always a discrete file and never a glob, since globs are
+   * expanded into separate builds at deployment time.
+   */
+  entrypoint: string;
+
+  /**
+   * A writable temporary directory where you are encouraged to perform your
+   * build process. This directory will be populated with the restored cache.
+   */
+  workPath: string;
+
+  /**
+   * An arbitrary object passed by the user in the build definition defined
+   * in `now.json`.
+   */
+  config: Config;
+}
+
+
+export interface BuildOptions {
+  /**
+   * All source files of the project
+   */
+  files: Files;
+
+  /**
+   * Name of entrypoint file for this particular build job. Value
+   * `files[entrypoint]` is guaranteed to exist and be a valid File reference.
+   * `entrypoint` is always a discrete file and never a glob, since globs are
+   * expanded into separate builds at deployment time.
+   */
+  entrypoint: string;
+
+  /**
+   * A writable temporary directory where you are encouraged to perform your
+   * build process. This directory will be populated with the restored cache.
+   */
+  workPath: string;
+
+  /**
+   * An arbitrary object passed by the user in the build definition defined
+   * in `now.json`.
+   */
+  config: Config;
+}
+
+export interface PrepareCacheOptions {
+  /**
+   * All source files of the project
+   */
+  files: Files;
+
+  /**
+   * Name of entrypoint file for this particular build job. Value
+   * `files[entrypoint]` is guaranteed to exist and be a valid File reference.
+   * `entrypoint` is always a discrete file and never a glob, since globs are
+   * expanded into separate builds at deployment time.
+   */
+  entrypoint: string;
+
+  /**
+   * A writable temporary directory where you are encouraged to perform your
+   * build process.
+   */
+  workPath: string;
+
+  /**
+   * A writable temporary directory where you can build a cache to use for
+   * the next run.
+   */
+  cachePath: string;
+
+  /**
+   * An arbitrary object passed by the user in the build definition defined
+   * in `now.json`.
+   */
+  config: Config;
+}
+
+export interface ShouldServeOptions {
+  /**
+   * A path string from a request.
+   */
+  requestPath: string;
+  /**
+   * Name of entrypoint file for this particular build job. Value
+   * `files[entrypoint]` is guaranteed to exist and be a valid File reference.
+   * `entrypoint` is always a discrete file and never a glob, since globs are
+   * expanded into separate builds at deployment time.
+   */
+  entrypoint: string;
+  /**
+   * All source files of the project
+   */
+  files: {
+    [path: string]: FileFsRef
+  };
+  /**
+   * An arbitrary object passed by the user in the build definition defined
+   * in `now.json`.
+   */
+  config: Config;
+}

packages/now-build-utils/test/symlinks/a.txt

@@ -0,0 +1 @@
+contents

packages/now-build-utils/test/symlinks/link.txt

@@ -0,0 +1 @@
+./a.txt

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

@@ -1,6 +1,11 @@
 /* global beforeAll, expect, it, jest */
-const fs = require('fs');
 const path = require('path');
+const fs = require('fs-extra');
+// eslint-disable-next-line import/no-extraneous-dependencies
+const execa = require('execa');
+const assert = require('assert');
+const { glob, download } = require('../');
+const { createZip } = require('../dist/lambda');
 
 const {
   packAndDeploy,
@@ -17,6 +22,48 @@ beforeAll(async () => {
   console.log('buildUtilsUrl', buildUtilsUrl);
 });
 
+// unit tests
+
+it('should re-create symlinks properly', async () => {
+  const files = await glob('**', path.join(__dirname, 'symlinks'));
+  assert.equal(Object.keys(files).length, 2);
+
+  const outDir = path.join(__dirname, 'symlinks-out');
+  await fs.remove(outDir);
+
+  const files2 = await download(files, outDir);
+  assert.equal(Object.keys(files2).length, 2);
+
+  const [linkStat, aStat] = await Promise.all([
+    fs.lstat(path.join(outDir, 'link.txt')),
+    fs.lstat(path.join(outDir, 'a.txt')),
+  ]);
+  assert(linkStat.isSymbolicLink());
+  assert(aStat.isFile());
+});
+
+it('should create zip files with symlinks properly', async () => {
+  const files = await glob('**', path.join(__dirname, 'symlinks'));
+  assert.equal(Object.keys(files).length, 2);
+
+  const outFile = path.join(__dirname, 'symlinks.zip');
+  await fs.remove(outFile);
+
+  const outDir = path.join(__dirname, 'symlinks-out');
+  await fs.remove(outDir);
+  await fs.mkdirp(outDir);
+
+  await fs.writeFile(outFile, await createZip(files));
+  await execa('unzip', [outFile], { cwd: outDir });
+
+  const [linkStat, aStat] = await Promise.all([
+    fs.lstat(path.join(outDir, 'link.txt')),
+    fs.lstat(path.join(outDir, 'a.txt')),
+  ]);
+  assert(linkStat.isSymbolicLink());
+  assert(aStat.isFile());
+});
+
 // own fixtures
 
 const fixturesPath = path.resolve(__dirname, 'fixtures');

packages/now-build-utils/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "declaration": true,
+    "esModuleInterop": true,
+    "lib": ["esnext"],
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "noEmitOnError": true,
+    "noFallthroughCasesInSwitch": true,
+    "noImplicitReturns": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "outDir": "./dist",
+    "types": ["node"],
+    "strict": true,
+    "target": "esnext"
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}

packages/now-go/go-helpers.js

@@ -21,12 +21,12 @@ const getGoUrl = (version, platform, arch) => {
   return `https://dl.google.com/go/go${version}.${goPlatform}-${goArch}.${ext}`;
 };
 
-function getExportedFunctionName(filePath) {
+async function getExportedFunctionName(filePath) {
   debug('Detecting handler name for %o', filePath);
   const bin = join(__dirname, 'get-exported-function-name');
   const args = [filePath];
-  const name = execa.stdout(bin, args);
-  debug('Detected exported name %o', filePath);
+  const name = await execa.stdout(bin, args);
+  debug('Detected exported name %o', name);
   return name;
 }
 
@@ -68,6 +68,7 @@ async function createGo(
   platform = process.platform,
   arch = process.arch,
   opts = {},
+  goMod = false,
 ) {
   const env = {
     ...process.env,
@@ -76,6 +77,10 @@ async function createGo(
     ...opts.env,
   };
 
+  if (goMod) {
+    env.GO111MODULE = 'on';
+  }
+
   function go(...args) {
     debug('Exec %o', `go ${args.join(' ')}`);
     return execa('go', args, { stdio: 'inherit', ...opts, env });
@@ -90,7 +95,7 @@ async function createGo(
 
 async function downloadGo(
   dir = GO_DIR,
-  version = '1.11.5',
+  version = '1.12',
   platform = process.platform,
   arch = process.arch,
 ) {

packages/now-go/index.js

@@ -1,5 +1,7 @@
-const { join, dirname } = require('path');
-const { readFile, writeFile } = require('fs-extra');
+const { join, sep, dirname } = require('path');
+const {
+  readFile, writeFile, pathExists, move,
+} = require('fs-extra');
 
 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
@@ -23,9 +25,9 @@ async function build({ files, entrypoint }) {
   const downloadedFiles = await download(files, srcPath);
 
   console.log(`Parsing AST for "${entrypoint}"`);
-  let handlerFunctionName;
+  let parseFunctionName;
   try {
-    handlerFunctionName = await getExportedFunctionName(
+    parseFunctionName = await getExportedFunctionName(
       downloadedFiles[entrypoint].fsPath,
     );
   } catch (err) {
@@ -33,7 +35,7 @@ async function build({ files, entrypoint }) {
     throw err;
   }
 
-  if (!handlerFunctionName) {
+  if (!parseFunctionName) {
     const err = new Error(
       `Could not find an exported function in "${entrypoint}"`,
     );
@@ -41,53 +43,156 @@ async function build({ files, entrypoint }) {
     throw err;
   }
 
+  const handlerFunctionName = parseFunctionName.split(',')[0];
+
   console.log(
     `Found exported function "${handlerFunctionName}" in "${entrypoint}"`,
   );
 
-  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';
-
   // we need `main.go` in the same dir as the entrypoint,
   // otherwise `go build` will refuse to build
   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(join(entrypointDirname, mainGoFileName), mainGoContents);
+  // check if package name other than main
+  const packageName = parseFunctionName.split(',')[1];
+  const isGoModExist = await pathExists(join(entrypointDirname, 'go.mod'));
+  if (packageName !== 'main') {
+    const go = await createGo(
+      goPath,
+      process.platform,
+      process.arch,
+      {
+        cwd: entrypointDirname,
+      },
+      true,
+    );
+    if (!isGoModExist) {
+      try {
+        const defaultGoModContent = `module ${packageName}`;
 
-  const go = await createGo(goPath, process.platform, process.arch, {
-    cwd: entrypointDirname,
-  });
+        await writeFile(join(entrypointDirname, 'go.mod'), defaultGoModContent);
+      } catch (err) {
+        console.log(`failed to create default go.mod for ${packageName}`);
+        throw err;
+      }
+    }
 
-  // `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;
-  }
+    const mainModGoFileName = 'main__mod__.go';
+    const modMainGoContents = await readFile(
+      join(__dirname, mainModGoFileName),
+      'utf8',
+    );
 
-  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;
+    let goPackageName = `${packageName}/${packageName}`;
+    const goFuncName = `${packageName}.${handlerFunctionName}`;
+
+    if (isGoModExist) {
+      const goModContents = await readFile(
+        join(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 {
+      // default path
+      let finalDestination = join(entrypointDirname, packageName, entrypoint);
+      const entrypointArr = entrypoint.split(sep);
+
+      // if `entrypoint` include folder, only use filename
+      if (entrypointArr.length > 1) {
+        finalDestination = join(
+          entrypointDirname,
+          packageName,
+          entrypointArr.pop(),
+        );
+      }
+
+      await move(downloadedFiles[entrypoint].fsPath, finalDestination);
+    } 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({

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,6 +1,6 @@
 {
   "name": "@now/go",
-  "version": "0.2.13-canary.1",
+  "version": "0.3.1-canary.3",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -13,6 +13,7 @@
   "files": [
     "*.js",
     "main.go",
+    "main__mod__.go",
     "util"
   ],
   "dependencies": {

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

@@ -0,0 +1,13 @@
+package cowsay
+
+import (
+	"fmt"
+	"net/http"
+
+	say "github.com/dhruvbird/go-cowsay"
+)
+
+// Handler function
+func Handler(w http.ResponseWriter, r *http.Request) {
+	fmt.Fprintf(w, say.Format("cow:RANDOMNESS_PLACEHOLDER"))
+}

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

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

packages/now-go/test/fixtures/01-cowsay/subdirectory/index.go

@@ -0,0 +1,13 @@
+package subcow
+
+import (
+	"fmt"
+	"net/http"
+
+	say "github.com/dhruvbird/go-cowsay"
+)
+
+// Handler function
+func Handler(w http.ResponseWriter, r *http.Request) {
+	fmt.Fprintf(w, say.Format("subcow:RANDOMNESS_PLACEHOLDER"))
+}

packages/now-go/test/test.js

@@ -0,0 +1,33 @@
+/* global beforeAll, expect, it, jest */
+const fs = require('fs');
+const path = require('path');
+
+const {
+  packAndDeploy,
+  testDeployment,
+} = require('../../../test/lib/deployment/test-deployment.js');
+
+jest.setTimeout(4 * 60 * 1000);
+const buildUtilsUrl = '@canary';
+let builderUrl;
+
+beforeAll(async () => {
+  const builderPath = path.resolve(__dirname, '..');
+  builderUrl = await packAndDeploy(builderPath);
+  console.log('builderUrl', builderUrl);
+});
+
+const fixturesPath = path.resolve(__dirname, 'fixtures');
+
+// eslint-disable-next-line no-restricted-syntax
+for (const fixture of fs.readdirSync(fixturesPath)) {
+  // eslint-disable-next-line no-loop-func
+  it(`should build ${fixture}`, async () => {
+    await expect(
+      testDeployment(
+        { builderUrl, buildUtilsUrl },
+        path.join(fixturesPath, fixture),
+      ),
+    ).resolves.toBeDefined();
+  });
+}

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-html-minifier/index.js

@@ -11,7 +11,6 @@ const defaultOptions = {
   removeRedundantAttributes: true,
   useShortDoctype: true,
   collapseWhitespace: true,
-  collapseInlineTagWhitespace: true,
   collapseBooleanAttributes: true,
   caseSensitive: true,
 };

packages/now-html-minifier/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@now/html-minifier",
-  "version": "1.0.8-canary.0",
+  "version": "1.0.8-canary.1",
   "license": "MIT",
   "repository": {
     "type": "git",

packages/now-md/index.js

@@ -34,8 +34,6 @@ exports.build = async ({ files, entrypoint, config }) => {
     stream: stream.pipe(unifiedStream(processor)),
   });
 
-  console.log(result.data.toString());
-
   const replacedEntrypoint = entrypoint.replace(/\.[^.]+$/, '.html');
 
   return { [replacedEntrypoint]: result };

packages/now-md/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@now/md",
-  "version": "0.4.10-canary.1",
+  "version": "0.4.10-canary.2",
   "license": "MIT",
   "repository": {
     "type": "git",

packages/now-mdx-deck/index.js

@@ -43,17 +43,8 @@ exports.build = async ({ files, entrypoint, workPath }) => {
   return glob('**', outDir, mountpoint);
 };
 
-exports.prepareCache = async ({ cachePath }) => {
-  console.log('writing package.json...');
-  const packageJson = { dependencies: { 'mdx-deck': '1.7.15' } };
-  const packageJsonPath = path.join(cachePath, 'package.json');
-  await writeFile(packageJsonPath, JSON.stringify(packageJson));
-  console.log('running npm install...');
-  await runNpmInstall(path.dirname(packageJsonPath), ['--prod']);
-
-  return {
-    ...(await glob('node_modules/**', cachePath)),
-    ...(await glob('package-lock.json', cachePath)),
-    ...(await glob('yarn.lock', cachePath)),
-  };
-};
+exports.prepareCache = async ({ workPath }) => ({
+  ...(await glob('node_modules/**', workPath)),
+  ...(await glob('package-lock.json', workPath)),
+  ...(await glob('yarn.lock', workPath)),
+});

packages/now-mdx-deck/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@now/mdx-deck",
-  "version": "0.4.19-canary.1",
+  "version": "0.4.19-canary.2",
   "license": "MIT",
   "repository": {
     "type": "git",

packages/now-next/index.js

@@ -1,14 +1,22 @@
-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 { createLambda } = require('@now/build-utils/lambda'); // eslint-disable-line import/no-extraneous-dependencies
+const download = require('@now/build-utils/fs/download'); // eslint-disable-line import/no-extraneous-dependencies
+const FileFsRef = require('@now/build-utils/file-fs-ref'); // eslint-disable-line import/no-extraneous-dependencies
 const FileBlob = require('@now/build-utils/file-blob'); // eslint-disable-line import/no-extraneous-dependencies
+const resolveFrom = require('resolve-from');
 const path = require('path');
-const { readFile, writeFile, unlink } = require('fs.promised');
+const url = require('url');
 const {
   runNpmInstall,
   runPackageJsonScript,
-} = 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
+} = require('@now/build-utils/fs/run-user-scripts'); // eslint-disable-line import/no-extraneous-dependencies
+const glob = require('@now/build-utils/fs/glob'); // eslint-disable-line import/no-extraneous-dependencies
+const {
+  readFile,
+  writeFile,
+  unlink: unlinkFile,
+  remove: removePath,
+  pathExists,
+} = require('fs-extra');
 const semver = require('semver');
 const nextLegacyVersions = require('./legacy-versions');
 const {
@@ -17,16 +25,24 @@ const {
   includeOnlyEntryDirectory,
   normalizePackageJson,
   onlyStaticDirectory,
+  getNextConfig,
 } = require('./utils');
 
 /** @typedef { import('@now/build-utils/file-ref').Files } Files */
 /** @typedef { import('@now/build-utils/fs/download').DownloadedFiles } DownloadedFiles */
 
+/**
+ * @typedef {Object} BuildParamsMeta
+ * @property {boolean} [isDev] - Files object
+ * @property {?string} [requestPath] - Entrypoint specified for the builder
+ */
+
 /**
  * @typedef {Object} BuildParamsType
  * @property {Files} files - Files object
  * @property {string} entrypoint - Entrypoint specified for the builder
  * @property {string} workPath - Working directory for this build
+ * @property {BuildParamsMeta} [meta] - Various meta settings
  */
 
 /**
@@ -68,6 +84,63 @@ 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;
+}
+
+function setNextExperimentalPage(files, entry, meta) {
+  if (meta.requestPath) {
+    if (meta.requestPath.startsWith(path.join(entry, 'static'))) {
+      return onlyStaticDirectory(
+        includeOnlyEntryDirectory(files, entry),
+        entry,
+      );
+    }
+
+    const { pathname } = url.parse(meta.requestPath);
+    const assetPath = pathname.match(
+      /^\/?_next\/static\/[^/]+\/pages\/(.+)\.js$/,
+    );
+    // eslint-disable-next-line no-underscore-dangle
+    process.env.__NEXT_BUILDER_EXPERIMENTAL_PAGE = assetPath
+      ? assetPath[1]
+      : pathname;
+  }
+
+  if (meta.isDev) {
+    // eslint-disable-next-line no-underscore-dangle
+    process.env.__NEXT_BUILDER_EXPERIMENTAL_DEBUG = 'true';
+  }
+
+  return null;
+}
+
 exports.config = {
   maxLambdaSize: '5mb',
 };
@@ -76,60 +149,54 @@ exports.config = {
  * @param {BuildParamsType} buildParams
  * @returns {Promise<Files>}
  */
-exports.build = async ({ files, workPath, entrypoint }) => {
+exports.build = async ({
+  files, workPath, entrypoint, meta = {},
+}) => {
   validateEntrypoint(entrypoint);
 
-  console.log('downloading user files...');
   const entryDirectory = path.dirname(entrypoint);
+  const maybeStaticFiles = setNextExperimentalPage(files, entryDirectory, meta);
+  if (maybeStaticFiles) return maybeStaticFiles; // return early if requestPath is static file
+
+  console.log('downloading user files...');
   await download(files, workPath);
   const entryPath = path.join(workPath, entryDirectory);
+  const dotNext = path.join(entryPath, '.next');
+
+  if (await pathExists(dotNext)) {
+    if (meta.isDev) {
+      await removePath(dotNext).catch((e) => {
+        if (e.code !== 'ENOENT') throw e;
+      });
+    } else {
+      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);
 
-  let nextVersion;
-  if (pkg.dependencies && pkg.dependencies.next) {
-    nextVersion = pkg.dependencies.next;
-  } else if (pkg.devDependencies && pkg.devDependencies.next) {
-    nextVersion = pkg.devDependencies.next;
-  }
-
+  let 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(entryPath, 'yarn.lock'));
+      await unlinkFile(path.join(entryPath, 'yarn.lock'));
     } catch (err) {
       console.log('no yarn.lock removed');
     }
 
     try {
-      await unlink(path.join(entryPath, 'package-lock.json'));
+      await unlinkFile(path.join(entryPath, 'package-lock.json'));
     } catch (err) {
       console.log('no package-lock.json removed');
     }
@@ -161,6 +228,29 @@ exports.build = async ({ files, workPath, entrypoint }) => {
 
   console.log('installing dependencies...');
   await runNpmInstall(entryPath, ['--prefer-offline']);
+
+  nextVersion = JSON.parse(
+    await readFile(resolveFrom(entryPath, 'next/package.json'), 'utf8'),
+  ).version;
+
+  const isUpdated = (v) => {
+    if (v === 'canary') return true;
+
+    try {
+      return semver.satisfies(v, '>=8.0.5-canary.14', {
+        includePrerelease: true,
+      });
+    } catch (e) {
+      return false;
+    }
+  };
+
+  if ((meta.isDev || meta.requestPath) && !isUpdated(nextVersion)) {
+    throw new Error(
+      '`now dev` can only be used with Next.js >=8.0.5-canary.14!',
+    );
+  }
+
   console.log('running user script...');
   await runPackageJsonScript(entryPath, 'now-build');
 
@@ -170,7 +260,7 @@ exports.build = async ({ files, workPath, entrypoint }) => {
   }
 
   if (process.env.NPM_AUTH_TOKEN) {
-    await unlink(path.join(entryPath, '.npmrc'));
+    await unlinkFile(path.join(entryPath, '.npmrc'));
   }
 
   const lambdas = {};
@@ -273,11 +363,31 @@ exports.build = async ({ files, workPath, entrypoint }) => {
     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
@@ -291,6 +401,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',
@@ -313,16 +424,55 @@ exports.build = async ({ files, workPath, entrypoint }) => {
     {},
   );
 
-  const nextStaticDirectory = onlyStaticDirectory(
+  const staticDirectoryFiles = onlyStaticDirectory(
     includeOnlyEntryDirectory(files, entryDirectory),
-  );
-  const staticDirectoryFiles = Object.keys(nextStaticDirectory).reduce(
-    (mappedFiles, file) => ({
-      ...mappedFiles,
-      [path.join(entryDirectory, file)]: nextStaticDirectory[file],
-    }),
-    {},
+    entryDirectory,
   );
 
   return { ...lambdas, ...staticFiles, ...staticDirectoryFiles };
 };
+
+exports.prepareCache = async ({ workPath, entrypoint }) => {
+  console.log('preparing cache ...');
+  const entryDirectory = path.dirname(entrypoint);
+  const entryPath = path.join(workPath, 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('producing cache file manifest ...');
+  const cacheEntrypoint = path.relative(workPath, entryPath);
+  const cache = {
+    ...(await glob(path.join(cacheEntrypoint, 'node_modules/**'), workPath)),
+    ...(await glob(path.join(cacheEntrypoint, '.next/cache/**'), workPath)),
+    ...(await glob(path.join(cacheEntrypoint, 'package-lock.json'), workPath)),
+    ...(await glob(path.join(cacheEntrypoint, 'yarn.lock'), workPath)),
+  };
+  console.log('cache file manifest produced');
+  return cache;
+};
+
+exports.subscribe = async ({ entrypoint, files }) => {
+  const entryDirectory = path.dirname(entrypoint);
+  const pageFiles = includeOnlyEntryDirectory(
+    files,
+    path.join(entryDirectory, 'pages'),
+  );
+
+  return [
+    path.join(entryDirectory, '_next/static/unoptimized-build/pages/**'),
+    path.join(entryDirectory, 'static/**'),
+    // List all pages without their extensions
+    ...Object.keys(pageFiles).map(page => page
+      .replace(/^pages\//i, '')
+      .split('.')
+      .slice(0, -1)
+      .join('.')),
+  ];
+};

packages/now-next/launcher.js

@@ -1,8 +1,10 @@
-process.env.NODE_ENV = 'production';
+if (!process.env.NODE_ENV) {
+  process.env.NODE_ENV = process.env.NOW_REGION === 'dev1' ? 'development' : 'production';
+}
 
 const { Server } = require('http');
-const { Bridge } = require('./now__bridge.js');
-const page = require('./page.js');
+const { Bridge } = require('./now__bridge');
+const page = require('./page');
 
 const server = new Server(page.render);
 const bridge = new Bridge(server);

packages/now-next/legacy-launcher.js

@@ -1,9 +1,11 @@
 const { Server } = require('http');
 const next = require('next-server');
 const url = require('url');
-const { Bridge } = require('./now__bridge.js');
+const { Bridge } = require('./now__bridge');
 
-process.env.NODE_ENV = 'production';
+if (!process.env.NODE_ENV) {
+  process.env.NODE_ENV = process.env.NOW_REGION === 'dev1' ? 'development' : 'production';
+}
 
 const app = next({});
 

packages/now-next/package.json

@@ -1,16 +1,20 @@
 {
   "name": "@now/next",
-  "version": "0.0.85-canary.6",
+  "version": "0.1.3-canary.15",
   "license": "MIT",
+  "scripts": {
+    "build": "tsc"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/zeit/now-builders.git",
     "directory": "packages/now-next"
   },
   "dependencies": {
-    "@now/node-bridge": "1.0.0-canary.2",
+    "@now/node-bridge": "^1.0.2-canary.2",
     "execa": "^1.0.0",
-    "fs.promised": "^3.0.0",
+    "fs-extra": "^7.0.0",
+    "resolve-from": "^4.0.0",
     "semver": "^5.6.0"
   }
 }

packages/now-next/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2017",
+    "module": "commonjs",
+    "lib": ["es2017"],
+    "allowJs": true,
+    "checkJs": true,
+    "noEmit": true,
+    "strict": false,
+    "types": ["node"],
+    "esModuleInterop": true
+  },
+  "include": [
+    "./"
+  ],
+  "exclude": [
+    "./launcher.js",
+    "./legacy-launcher.js"
+  ]
+}

packages/now-next/utils.js

@@ -1,3 +1,6 @@
+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 */
 /** @typedef {{[filePath: string]: FileRef|FileFsRef}} Files */
@@ -79,13 +82,13 @@ function excludeLockFiles(files) {
 }
 
 /**
- * Exclude the static directory from files
+ * Include the static directory from files
  * @param {Files} files
  * @returns {Files}
  */
-function onlyStaticDirectory(files) {
+function onlyStaticDirectory(files, entryDir) {
   function matcher(filePath) {
-    return !filePath.startsWith('static');
+    return !filePath.startsWith(path.join(entryDir, 'static'));
   }
 
   return excludeFiles(files, matcher);
@@ -136,6 +139,20 @@ 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,
@@ -143,4 +160,5 @@ module.exports = {
   excludeLockFiles,
   normalizePackageJson,
   onlyStaticDirectory,
+  getNextConfig,
 };

packages/now-node-bridge/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@now/node-bridge",
-  "version": "1.0.0-canary.2",
+  "version": "1.0.2-canary.2",
   "license": "MIT",
   "main": "./index.js",
   "repository": {

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

@@ -27,6 +27,18 @@ export interface NowProxyResponse {
   encoding: string;
 }
 
+/**
+ * If the `http.Server` handler function throws an error asynchronously,
+ * then it ends up being an unhandled rejection which doesn't kill the node
+ * process which causes the HTTP request to hang indefinitely. So print the
+ * error here and force the process to exit so that the lambda invocation
+ * returns an Unhandled error quickly.
+ */
+process.on('unhandledRejection', (err: Error) => {
+  console.error('Unhandled rejection:', err);
+  process.exit(1);
+});
+
 function normalizeNowProxyEvent(event: NowProxyEvent): NowProxyRequest {
   let bodyBuffer: Buffer | null;
   const { method, path, headers, encoding, body } = JSON.parse(event.body);

packages/now-node-bridge/tsconfig.json

@@ -1,6 +1,8 @@
 {
   "compilerOptions": {
-    "target": "es6",
+    "esModuleInterop": true,
+    "lib": ["esnext"],
+    "target": "esnext",
     "module": "commonjs",
     "outDir": ".",
     "strict": true,

packages/now-node-server/index.js

@@ -5,7 +5,6 @@ const FileFsRef = require('@now/build-utils/file-fs-ref.js'); // eslint-disable-
 const fs = require('fs-extra');
 const glob = require('@now/build-utils/fs/glob.js'); // eslint-disable-line import/no-extraneous-dependencies
 const path = require('path');
-const rename = require('@now/build-utils/fs/rename.js'); // eslint-disable-line import/no-extraneous-dependencies
 const {
   runNpmInstall,
   runPackageJsonScript,
@@ -31,51 +30,52 @@ async function downloadInstallAndBundle(
   { files, entrypoint, workPath },
   { npmArguments = [] } = {},
 ) {
-  const userPath = path.join(workPath, 'user');
-  const nccPath = path.join(workPath, 'ncc');
-
   console.log('downloading user files...');
-  const downloadedFiles = await download(files, userPath);
+  const downloadedFiles = await download(files, workPath);
 
   console.log("installing dependencies for user's code...");
-  const entrypointFsDirname = path.join(userPath, path.dirname(entrypoint));
+  const entrypointFsDirname = path.join(workPath, path.dirname(entrypoint));
   await runNpmInstall(entrypointFsDirname, npmArguments);
-
-  console.log('writing ncc package.json...');
-  await download(
-    {
-      'package.json': new FileBlob({
-        data: JSON.stringify({
-          license: 'UNLICENSED',
-          dependencies: {
-            '@zeit/ncc': '0.15.2',
-          },
-        }),
-      }),
-    },
-    nccPath,
-  );
-
-  console.log('installing dependencies for ncc...');
-  await runNpmInstall(nccPath, npmArguments);
-  return [downloadedFiles, userPath, nccPath, entrypointFsDirname];
+  return [downloadedFiles, entrypointFsDirname];
 }
 
-async function compile(workNccPath, downloadedFiles, entrypoint) {
+async function compile(workPath, downloadedFiles, entrypoint, config) {
   const input = downloadedFiles[entrypoint].fsPath;
-  const ncc = require(path.join(workNccPath, 'node_modules/@zeit/ncc'));
+  const inputDir = path.dirname(input);
+  const ncc = require('@zeit/ncc');
   const { code, assets } = await ncc(input, { sourceMap: true });
 
+  if (config && config.includeFiles) {
+    // eslint-disable-next-line no-restricted-syntax
+    for (const pattern of config.includeFiles) {
+      // eslint-disable-next-line no-await-in-loop
+      const files = await glob(pattern, inputDir);
+
+      // eslint-disable-next-line no-restricted-syntax
+      for (const assetName of Object.keys(files)) {
+        const stream = files[assetName].toStream();
+        const { mode } = files[assetName];
+        // eslint-disable-next-line no-await-in-loop
+        const { data } = await FileBlob.fromStream({ stream });
+
+        assets[assetName] = {
+          source: data,
+          permissions: mode,
+        };
+      }
+    }
+  }
+
   const preparedFiles = {};
   const blob = new FileBlob({ data: code });
   // move all user code to 'user' subdirectory
-  preparedFiles[path.join('user', entrypoint)] = blob;
+  preparedFiles[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)
+      path.join(path.dirname(entrypoint), assetName)
     ] = blob2;
   }
 
@@ -95,8 +95,6 @@ exports.build = async ({
 }) => {
   const [
     downloadedFiles,
-    workUserPath,
-    workNccPath,
     entrypointFsDirname,
   ] = await downloadInstallAndBundle(
     { files, entrypoint, workPath },
@@ -110,12 +108,15 @@ exports.build = async ({
   let preparedFiles;
 
   if (config && config.bundle === false) {
-    // move all user code to 'user' subdirectory
-    preparedFiles = await glob('**', workUserPath);
-    preparedFiles = rename(preparedFiles, name => path.join('user', name));
+    preparedFiles = await glob('**', workPath);
   } else {
     console.log('compiling entrypoint with ncc...');
-    preparedFiles = await compile(workNccPath, downloadedFiles, entrypoint);
+    preparedFiles = await compile(
+      workPath,
+      downloadedFiles,
+      entrypoint,
+      config,
+    );
   }
 
   const launcherPath = path.join(__dirname, 'launcher.js');
@@ -123,8 +124,7 @@ exports.build = async ({
   launcherData = launcherData.replace(
     '// PLACEHOLDER',
     [
-      'process.chdir("./user");',
-      `require("./${path.join('user', entrypoint)}");`,
+      `require("./${entrypoint}");`,
     ].join(' '),
   );
 
@@ -142,18 +142,8 @@ exports.build = async ({
   return { [entrypoint]: lambda };
 };
 
-exports.prepareCache = async ({
-  files, entrypoint, workPath, cachePath,
-}) => {
-  await fs.remove(workPath);
-  await downloadInstallAndBundle({ files, entrypoint, workPath: cachePath });
-
-  return {
-    ...(await glob('user/node_modules/**', cachePath)),
-    ...(await glob('user/package-lock.json', cachePath)),
-    ...(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)),
-  };
-};
+exports.prepareCache = async ({ workPath }) => ({
+  ...(await glob('node_modules/**', workPath)),
+  ...(await glob('package-lock.json', workPath)),
+  ...(await glob('yarn.lock', workPath)),
+});

packages/now-node-server/launcher.js

@@ -11,9 +11,22 @@ Server.prototype.listen = function listen() {
 };
 
 if (!process.env.NODE_ENV) {
-  process.env.NODE_ENV = 'production';
+  process.env.NODE_ENV = process.env.NOW_REGION === 'dev1' ? 'development' : 'production';
 }
 
-// PLACEHOLDER
+try {
+  // PLACEHOLDER
+} catch (err) {
+  if (err.code === 'MODULE_NOT_FOUND') {
+    console.error(err.message);
+    console.error(
+      'Did you forget to add it to "dependencies" in `package.json`?',
+    );
+    process.exit(1);
+  } else {
+    console.error(err);
+    process.exit(1);
+  }
+}
 
 exports.launcher = bridge.launcher;

packages/now-node-server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@now/node-server",
-  "version": "0.5.0-canary.3",
+  "version": "0.5.4-canary.3",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -8,7 +8,8 @@
     "directory": "packages/now-node-server"
   },
   "dependencies": {
-    "@now/node-bridge": "1.0.0-canary.2",
+    "@now/node-bridge": "^1.0.2-canary.2",
+    "@zeit/ncc": "0.17.3",
     "fs-extra": "7.0.1"
   },
   "scripts": {

packages/now-node-server/test/fixtures/11-include-files/index.js

@@ -0,0 +1,6 @@
+const express = require('express');
+
+const app = express();
+app.use(express.static('templates'));
+
+app.listen();

packages/now-node-server/test/fixtures/11-include-files/now.json

@@ -0,0 +1,20 @@
+{
+  "version": 2,
+  "builds": [
+    {
+      "src": "index.js",
+      "use": "@now/node-server",
+      "config": {
+        "includeFiles": [
+          "templates/**"
+        ]
+      }
+    }
+  ],
+  "probes": [
+    {
+      "path": "/",
+      "mustContain": "Hello Now!"
+    }
+  ]
+}

packages/now-node-server/test/fixtures/11-include-files/package.json

@@ -0,0 +1,5 @@
+{
+  "dependencies": {
+    "express": "^4.16.4"
+  }
+}

packages/now-node-server/test/fixtures/11-include-files/templates/index.html

@@ -0,0 +1 @@
+Hello Now!

packages/now-node/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@now/node",
-  "version": "0.5.0-canary.5",
+  "version": "0.5.4-canary.4",
   "license": "MIT",
   "main": "./dist/index",
   "repository": {
@@ -9,12 +9,14 @@
     "directory": "packages/now-node"
   },
   "dependencies": {
-    "@now/node-bridge": "1.0.0-canary.2",
+    "@now/node-bridge": "^1.0.2-canary.2",
+    "@zeit/ncc": "0.17.3",
     "fs-extra": "7.0.1"
   },
   "scripts": {
     "build": "./build.sh",
-    "test": "jest"
+    "test": "npm run build && jest",
+    "prepublish": "npm run build"
   },
   "files": [
     "dist"

packages/now-node/src/index.ts

@@ -1,78 +1,86 @@
-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 { join, dirname, sep } from 'path';
+import { readFile } from 'fs-extra';
 import {
+  glob,
+  download,
+  FileBlob,
+  FileFsRef,
+  Files,
+  createLambda,
   runNpmInstall,
-  runPackageJsonScript
-} from '@now/build-utils/fs/run-user-scripts.js';
+  runPackageJsonScript,
+  PrepareCacheOptions,
+  BuildOptions,
+} from '@now/build-utils';
 
-/** @typedef { import('@now/build-utils/file-ref') } FileRef */
-/** @typedef {{[filePath: string]: FileRef}} Files */
-
-/**
- * @typedef {Object} BuildParamsType
- * @property {Files} files - Files object
- * @property {string} entrypoint - Entrypoint specified for the builder
- * @property {string} workPath - Working directory for this build
- */
-
-/**
- * @param {BuildParamsType} buildParams
- * @param {Object} [options]
- * @param {string[]} [options.npmArguments]
- */
-async function downloadInstallAndBundle(
-  { files, entrypoint, workPath },
-  { npmArguments = [] } = {}
-) {
-  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 = join(userPath, dirname(entrypoint));
-  await runNpmInstall(entrypointFsDirname, npmArguments);
-
-  console.log('writing ncc package.json...');
-  await download(
-    {
-      'package.json': new FileBlob({
-        data: JSON.stringify({
-          license: 'UNLICENSED',
-          dependencies: {
-            '@zeit/ncc': '0.15.2',
-          }
-        })
-      })
-    },
-    nccPath
-  );
-
-  console.log('installing dependencies for ncc...');
-  await runNpmInstall(nccPath, npmArguments);
-  return [downloadedFiles, nccPath, entrypointFsDirname];
+interface CompilerConfig {
+  includeFiles?: string[]
 }
 
-async function compile(workNccPath: string, downloadedFiles, entrypoint: string) {
-  const input = downloadedFiles[entrypoint].fsPath;
-  const ncc = require(join(workNccPath, 'node_modules/@zeit/ncc'));
+interface DownloadOptions {
+  files: Files,
+  entrypoint: string;
+  workPath: string;
+  npmArguments?: string[];
+}
+
+async function downloadInstallAndBundle({
+  files,
+  entrypoint,
+  workPath,
+  npmArguments = []
+}: DownloadOptions) {
+  console.log('downloading user files...');
+  const downloadedFiles = await download(files, workPath);
+
+  console.log("installing dependencies for user's code...");
+  const entrypointFsDirname = join(workPath, dirname(entrypoint));
+  await runNpmInstall(entrypointFsDirname, npmArguments);
+
+  const entrypointPath = downloadedFiles[entrypoint].fsPath;
+  return { entrypointPath, entrypointFsDirname };
+}
+
+async function compile(entrypointPath: string, entrypoint: string, config: CompilerConfig): Promise<Files> {
+  const input = entrypointPath;
+  const inputDir = dirname(input);
+  const rootIncludeFiles = inputDir.split(sep).pop() || '';
+  const ncc = require('@zeit/ncc');
   const { code, assets } = await ncc(input);
 
-  const preparedFiles = {};
+  if (config && config.includeFiles) {
+    for (const pattern of config.includeFiles) {
+      const files = await glob(pattern, inputDir);
+
+      for (const assetName of Object.keys(files)) {
+        const stream = files[assetName].toStream();
+        const { mode } = files[assetName];
+        const { data } = await FileBlob.fromStream({ stream });
+        let fullPath = join(rootIncludeFiles, assetName);
+
+        // if asset contain directory
+        // no need to use `rootIncludeFiles`
+        if (assetName.includes(sep)) {
+          fullPath = assetName
+        }
+
+        assets[fullPath] = {
+          'source': data,
+          'permissions': mode
+        };
+      }
+    }
+  }
+
+  const preparedFiles: Files = {};
   const blob = new FileBlob({ data: code });
   // move all user code to 'user' subdirectory
-  preparedFiles[join('user', entrypoint)] = blob;
+  preparedFiles[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[join('user', dirname(entrypoint), assetName)] = blob2;
+    preparedFiles[join(dirname(entrypoint), assetName)] = blob2;
   }
 
   return preparedFiles;
@@ -82,33 +90,26 @@ export const config = {
   maxLambdaSize: '5mb'
 };
 
-/**
- * @param {BuildParamsType} buildParams
- * @returns {Promise<Files>}
- */
-export async function build({ files, entrypoint, workPath }) {
-  const [
-    downloadedFiles,
-    workNccPath,
+export async function build({ files, entrypoint, workPath, config }: BuildOptions) {
+  const {
+    entrypointPath,
     entrypointFsDirname
-  ] = await downloadInstallAndBundle(
-    { files, entrypoint, workPath },
-    { npmArguments: ['--prefer-offline'] }
+  } = await downloadInstallAndBundle(
+    { files, entrypoint, workPath, npmArguments: ['--prefer-offline'] }
   );
 
   console.log('running user script...');
   await runPackageJsonScript(entrypointFsDirname, 'now-build');
 
   console.log('compiling entrypoint with ncc...');
-  const preparedFiles = await compile(workNccPath, downloadedFiles, entrypoint);
+  const preparedFiles = await compile(entrypointPath, entrypoint, config);
   const launcherPath = join(__dirname, 'launcher.js');
   let launcherData = await readFile(launcherPath, 'utf8');
 
   launcherData = launcherData.replace(
     '// PLACEHOLDER',
     [
-      'process.chdir("./user");',
-      `listener = require("./${join('user', entrypoint)}");`,
+      `listener = require("./${entrypoint}");`,
       'if (listener.default) listener = listener.default;'
     ].join(' ')
   );
@@ -127,16 +128,10 @@ export async function build({ files, entrypoint, workPath }) {
   return { [entrypoint]: lambda };
 }
 
-export async function prepareCache({ files, entrypoint, workPath, cachePath }) {
-  await remove(workPath);
-  await downloadInstallAndBundle({ files, entrypoint, workPath: cachePath });
-
+export async function prepareCache({ workPath }: PrepareCacheOptions) {
   return {
-    ...(await glob('user/node_modules/**', cachePath)),
-    ...(await glob('user/package-lock.json', cachePath)),
-    ...(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('node_modules/**', workPath)),
+    ...(await glob('package-lock.json', workPath)),
+    ...(await glob('yarn.lock', workPath))
   };
 }

packages/now-node/src/launcher.ts

@@ -4,10 +4,21 @@ import { Bridge } from './bridge';
 let listener;
 
 if (!process.env.NODE_ENV) {
-  process.env.NODE_ENV = 'production';
+  process.env.NODE_ENV = process.env.NOW_REGION === 'dev1' ? 'development' : 'production';
 }
 
+try {
 // PLACEHOLDER
+} catch (err) {
+  if (err.code === 'MODULE_NOT_FOUND') {
+    console.error(err.message);
+    console.error('Did you forget to add it to "dependencies" in `package.json`?');
+    process.exit(1);
+  } else {
+    console.error(err);
+    process.exit(1);
+  }
+}
 
 const server = new Server(listener);
 const bridge = new Bridge(server);

packages/now-node/test/fixtures/07-content-length/probe.js

@@ -21,7 +21,7 @@ async function test3({ deploymentUrl, fetch, randomness }) {
   const resp = await fetch(`https://${deploymentUrl}/test3.js`);
   assert.equal(resp.status, 401);
   assert.equal(await resp.text(), bodyMustBe);
-  assert.equal(resp.headers.get('content-length'), null);
+  assert.equal(resp.headers.get('content-length'), bodyMustBe.length);
 }
 
 module.exports = async ({ deploymentUrl, fetch, randomness }) => {

packages/now-node/test/fixtures/09-include-files/index.js

@@ -0,0 +1,7 @@
+const edge = require('edge.js');
+
+module.exports = (req, resp) => {
+  edge.registerViews('templates');
+
+  resp.end(edge.render('index', { name: 'Now!' }));
+};

packages/now-node/test/fixtures/09-include-files/now.json

@@ -0,0 +1,33 @@
+{
+  "version": 2,
+  "builds": [
+    {
+      "src": "index.js",
+      "use": "@now/node",
+      "config": {
+        "includeFiles": [
+          "templates/**"
+        ]
+      }
+    },
+    {
+      "src": "root.js",
+      "use": "@now/node",
+      "config": {
+        "includeFiles": [
+          "root.edge"
+        ]
+      }
+    }
+  ],
+  "probes": [
+    {
+      "path": "/",
+      "mustContain": "hello Now!"
+    },
+    {
+      "path": "/root.js",
+      "mustContain": "hello Root!"
+    }
+  ]
+}

packages/now-node/test/fixtures/09-include-files/package.json

@@ -0,0 +1,5 @@
+{
+  "dependencies": {
+    "edge.js": "^1.1.4"
+  }
+}

packages/now-node/test/fixtures/09-include-files/root.edge

@@ -0,0 +1 @@
+hello {{ text }}

packages/now-node/test/fixtures/09-include-files/root.js

@@ -0,0 +1,7 @@
+const edge = require('edge.js');
+
+module.exports = (req, resp) => {
+  edge.registerViews(__dirname);
+
+  resp.end(edge.render('root', { text: 'Root!' }));
+};

packages/now-node/test/fixtures/09-include-files/templates/index.edge

@@ -0,0 +1 @@
+hello {{ name }}

packages/now-node/tsconfig.json

@@ -1,6 +1,9 @@
 {
   "compilerOptions": {
-    "target": "es6",
+    "strict": true,
+    "esModuleInterop": true,
+    "lib": ["esnext"],
+    "target": "esnext",
     "module": "commonjs",
     "outDir": "dist",
     "sourceMap": false,

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,6 +1,6 @@
 {
   "name": "@now/php-bridge",
-  "version": "0.4.14-canary.0",
+  "version": "0.4.16-canary.0",
   "license": "MIT",
   "repository": {
     "type": "git",

packages/now-php/index.js

@@ -1,15 +1,40 @@
-const { createLambda } = require('@now/build-utils/lambda.js'); // eslint-disable-line import/no-extraneous-dependencies
+const {
+  createLambda, rename, glob, download,
+} = require('@now/build-utils'); // eslint-disable-line import/no-extraneous-dependencies
 const path = require('path');
-const rename = require('@now/build-utils/fs/rename.js'); // eslint-disable-line import/no-extraneous-dependencies
 const { getFiles } = require('@now/php-bridge');
 
 exports.config = {
   maxLambdaSize: '10mb',
 };
 
-exports.build = async ({ files, entrypoint }) => {
-  // move all user code to 'user' subdirectory
-  const userFiles = rename(files, name => path.join('user', name));
+exports.build = async ({
+  files, entrypoint, workPath, config,
+}) => {
+  // Download all files to workPath
+  const fileDir = path.join(workPath, 'userfiles');
+  const downloadedFiles = await download(files, fileDir);
+
+  let includedFiles = {};
+  if (config && config.includeFiles) {
+    // Find files for each glob
+    // eslint-disable-next-line no-restricted-syntax
+    for (const pattern of config.includeFiles) {
+      // eslint-disable-next-line no-await-in-loop
+      const matchedFiles = await glob(pattern, fileDir);
+      Object.assign(includedFiles, matchedFiles);
+    }
+    // explicit and always include the entrypoint
+    Object.assign(includedFiles, {
+      [entrypoint]: files[entrypoint],
+    });
+  } else {
+    // Backwards compatibility
+    includedFiles = downloadedFiles;
+  }
+  console.log('Included files:', Object.keys(includedFiles));
+
+  const userFiles = rename(includedFiles, name => path.join('user', name));
   const bridgeFiles = await getFiles();
 
   // TODO config.extensions. OR php.ini from user
@@ -20,6 +45,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,6 +1,6 @@
 {
   "name": "@now/php",
-  "version": "0.4.14-canary.1",
+  "version": "0.4.17-canary.1",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -8,7 +8,7 @@
     "directory": "packages/now-php"
   },
   "dependencies": {
-    "@now/php-bridge": "^0.4.14-canary.0"
+    "@now/php-bridge": "^0.4.16-canary.0"
   },
   "scripts": {
     "test": "jest"

packages/now-php/test/fixtures/04-include-files/excluded_file.php

@@ -0,0 +1,3 @@
+<?php
+
+echo 'Excluded!';

packages/now-php/test/fixtures/04-include-files/included_file.php

@@ -0,0 +1,3 @@
+<?php
+
+echo 'included:RANDOMNESS_PLACEHOLDER';

packages/now-php/test/fixtures/04-include-files/index.php

@@ -0,0 +1,9 @@
+<?php
+
+echo 'mainfile:';
+if (file_exists('included_file.php') && !file_exists('excluded_file.php')) {
+  require_once 'included_file.php';
+} else {
+  echo PHP_EOL;
+  print_r(array_diff(scandir('.'), array('..', '.')));
+}

packages/now-php/test/fixtures/04-include-files/now.json

@@ -0,0 +1,9 @@
+{
+  "version": 2,
+  "builds": [
+    { "src": "index.php", "use": "@now/php", "config": { "includeFiles": ["included*.php"] } }
+  ],
+  "probes": [
+    { "path": "/", "mustContain": "mainfile:included:RANDOMNESS_PLACEHOLDER" }
+  ]
+}

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-python/.gitignore

@@ -0,0 +1 @@
+*.js

packages/now-python/.npmignore

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

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

@@ -1,9 +1,8 @@
-const path = require('path');
-const fetch = require('node-fetch');
-const execa = require('execa');
-const { createWriteStream } = require('fs');
-
-const getWritableDirectory = require('@now/build-utils/fs/get-writable-directory.js'); // eslint-disable-line import/no-extraneous-dependencies
+import { join } from 'path';
+import fetch from 'node-fetch';
+import execa from 'execa';
+import { createWriteStream } from 'fs';
+import { getWriteableDirectory } from '@now/build-utils';
 
 const url = 'https://bootstrap.pypa.io/get-pip.py';
 
@@ -16,11 +15,11 @@ async function downloadGetPipScript() {
     throw new Error(`Could not download "get-pip.py" from "${url}"`);
   }
 
-  const dir = await getWritableDirectory();
-  const filePath = path.join(dir, 'get-pip.py');
+  const dir = await getWriteableDirectory();
+  const filePath = join(dir, 'get-pip.py');
   const writeStream = createWriteStream(filePath);
 
-  return new Promise((resolve, reject) => {
+  return new Promise<string>((resolve, reject) => {
     res.body
       .on('error', reject)
       .pipe(writeStream)
@@ -31,8 +30,9 @@ async function downloadGetPipScript() {
 // downloads and installs `pip` (respecting
 // process.env.PYTHONUSERBASE), and returns
 // the absolute path to it
-async function downloadAndInstallPip() {
-  if (!process.env.PYTHONUSERBASE) {
+export async function downloadAndInstallPip() {
+  const { PYTHONUSERBASE } = process.env;
+  if (!PYTHONUSERBASE) {
     // this is the directory in which `pip` will be
     // installed to. `--user` will assume `~` if this
     // is not set, and `~` is not writeable on AWS Lambda.
@@ -43,7 +43,7 @@ async function downloadAndInstallPip() {
   }
   const getPipFilePath = await downloadGetPipScript();
 
-  console.log('runing "python get-pip.py"...');
+  console.log('running "python get-pip.py"...');
   try {
     await execa('python3', [getPipFilePath, '--user'], { stdio: 'inherit' });
   } catch (err) {
@@ -51,7 +51,6 @@ async function downloadAndInstallPip() {
     throw err;
   }
 
-  return path.join(process.env.PYTHONUSERBASE, 'bin', 'pip');
+  return join(PYTHONUSERBASE, 'bin', 'pip');
 }
 
-module.exports = downloadAndInstallPip;

packages/now-python/index.js

@@ -1,92 +0,0 @@
-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'); // 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(' ')}"...`);
-  try {
-    await execa(pipPath, ['install', '-t', srcDir, ...args], {
-      stdio: 'inherit',
-    });
-  } catch (err) {
-    console.log(`failed to run "pip install -t ${srcDir} ${args.join(' ')}"`);
-    throw err;
-  }
-}
-
-exports.config = {
-  maxLambdaSize: '5mb',
-};
-
-exports.build = async ({ files, entrypoint }) => {
-  console.log('downloading files...');
-
-  const srcDir = await getWritableDirectory();
-
-  // eslint-disable-next-line no-param-reassign
-  files = await download(files, srcDir);
-
-  // this is where `pip` will be installed to
-  // we need it to be under `/tmp`
-  const pyUserBase = await getWritableDirectory();
-  process.env.PYTHONUSERBASE = pyUserBase;
-
-  const pipPath = await downloadAndInstallPip();
-
-  await pipInstall(pipPath, srcDir, 'requests');
-
-  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);
-  }
-
-  const originalNowHandlerPyContents = await readFile(
-    path.join(__dirname, 'now_handler.py'),
-    'utf8',
-  );
-  // will be used on `from $here import handler`
-  // for example, `from api.users import handler`
-  console.log('entrypoint is', entrypoint);
-  const userHandlerFilePath = entrypoint
-    .replace(/\//g, '.')
-    .replace(/\.py$/, '');
-  const nowHandlerPyContents = originalNowHandlerPyContents.replace(
-    '__NOW_HANDLER_FILENAME',
-    userHandlerFilePath,
-  );
-
-  // in order to allow the user to have `server.py`, we need our `server.py` to be called
-  // somethig else
-  const nowHandlerPyFilename = 'now__handler__python';
-
-  await writeFile(
-    path.join(srcDir, `${nowHandlerPyFilename}.py`),
-    nowHandlerPyContents,
-  );
-
-  const lambda = await createLambda({
-    files: await glob('**', srcDir),
-    handler: `${nowHandlerPyFilename}.now_handler`,
-    runtime: 'python3.6',
-    environment: {},
-  });
-
-  return {
-    [entrypoint]: lambda,
-  };
-};

packages/now-python/index.ts

@@ -0,0 +1,147 @@
+import { join, dirname } from 'path';
+import execa from 'execa';
+import fs from 'fs';
+import { promisify } from 'util';
+const readFile = promisify(fs.readFile);
+const writeFile = promisify(fs.writeFile);
+import {
+  getWriteableDirectory,
+  download,
+  glob,
+  createLambda,
+  BuildOptions,
+} from '@now/build-utils';
+import { downloadAndInstallPip } from './download-and-install-pip';
+
+async function pipInstall(pipPath: string, workDir: string, ...args: string[]) {
+  const target = '.';
+  console.log(`running "pip install --target ${target} --upgrade ${args.join(' ')}"...`);
+  try {
+    await execa(pipPath, ['install', '--target', target, '--upgrade', ...args], {
+      cwd: workDir,
+      stdio: 'inherit',
+    });
+  } catch (err) {
+    console.log(`failed to run "pip install --target ${target} --upgrade ${args.join(' ')}"...`);
+    throw err;
+  }
+}
+
+async function pipInstallUser(pipPath: string, ...args: string[]) {
+  console.log(`running "pip install --user ${args.join(' ')}"...`);
+  try {
+    await execa(pipPath, ['install', '--user', ...args], {
+      stdio: 'inherit',
+    });
+  } catch (err) {
+    console.log(`failed to run "pip install --user ${args.join(' ')}"`);
+    throw err;
+  }
+}
+
+async function pipenvInstall(pyUserBase: string, srcDir: string) {
+  console.log('running "pipenv_to_requirements -f');
+  try {
+    await execa(
+      join(pyUserBase, 'bin', 'pipenv_to_requirements'),
+      ['-f'],
+      { cwd: srcDir, stdio: 'inherit' },
+    );
+  } catch (err) {
+    console.log('failed to run "pipenv_to_requirements -f"');
+    throw err;
+  }
+}
+
+export const config = {
+  maxLambdaSize: '5mb',
+};
+
+export const build = async ({ workPath, files, entrypoint }: BuildOptions) => {
+  console.log('downloading files...');
+
+  // eslint-disable-next-line no-param-reassign
+  files = await download(files, workPath);
+
+  // this is where `pip` will be installed to
+  // we need it to be under `/tmp`
+  const pyUserBase = await getWriteableDirectory();
+  process.env.PYTHONUSERBASE = pyUserBase;
+  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 = join(workPath, 'setup.cfg');
+    await writeFile(setupCfg, '[install]\nprefix=\n');
+  } catch (err) {
+    console.log('failed to create "setup.cfg" file');
+    throw err;
+  }
+
+  await pipInstall(pipPath, workPath, 'werkzeug');
+  await pipInstall(pipPath, workPath, 'requests');
+
+  const entryDirectory = dirname(entrypoint);
+  const requirementsTxt = join(entryDirectory, 'requirements.txt');
+
+  if (files['Pipfile.lock']) {
+    console.log('found "Pipfile.lock"');
+
+    // Install pipenv.
+    await pipInstallUser(pipPath, ' pipenv_to_requirements');
+
+    await pipenvInstall(pyUserBase, workPath);
+  }
+
+  const fsFiles = await glob('**', workPath);
+
+  if (fsFiles[requirementsTxt]) {
+    console.log('found local "requirements.txt"');
+    const requirementsTxtPath = fsFiles[requirementsTxt].fsPath;
+    await pipInstall(pipPath, workPath, '-r', requirementsTxtPath);
+  } else if (fsFiles['requirements.txt']) {
+    console.log('found global "requirements.txt"');
+    const requirementsTxtPath = fsFiles['requirements.txt'].fsPath;
+    await pipInstall(pipPath, workPath, '-r', requirementsTxtPath);
+  }
+
+  const originalPyPath = join(__dirname, 'now_init.py');
+  const originalNowHandlerPyContents = await readFile(originalPyPath, 'utf8');
+
+  // will be used on `from $here import handler`
+  // for example, `from api.users import handler`
+  console.log('entrypoint is', entrypoint);
+  const userHandlerFilePath = entrypoint
+    .replace(/\//g, '.')
+    .replace(/\.py$/, '');
+  const nowHandlerPyContents = originalNowHandlerPyContents.replace(
+    /__NOW_HANDLER_FILENAME/g,
+    userHandlerFilePath,
+  );
+
+  // in order to allow the user to have `server.py`, we need our `server.py` to be called
+  // somethig else
+  const nowHandlerPyFilename = 'now__handler__python';
+
+  await writeFile(
+    join(workPath, `${nowHandlerPyFilename}.py`),
+    nowHandlerPyContents,
+  );
+
+  const lambda = await createLambda({
+    files: await glob('**', workPath),
+    handler: `${nowHandlerPyFilename}.now_handler`,
+    runtime: 'python3.6',
+    environment: {},
+  });
+
+  return {
+    [entrypoint]: lambda,
+  };
+};

packages/now-python/now_handler.py

@@ -1,35 +0,0 @@
-import base64
-from http.server import HTTPServer
-import json
-import requests
-from __NOW_HANDLER_FILENAME import handler
-import _thread
-
-
-server = HTTPServer(('', 3000), handler)
-
-
-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']
-    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:3000' + path,
-                           headers=headers, data=body, allow_redirects=False)
-
-    return {
-        'statusCode': res.status_code,
-        'headers': dict(res.headers),
-        'body': res.text,
-    }

packages/now-python/now_init.py

@@ -0,0 +1,125 @@
+from http.server import BaseHTTPRequestHandler
+
+import base64
+import json
+
+def _now_get_import():
+    try:
+        from __NOW_HANDLER_FILENAME import Handler
+        assert issubclass(Handler, BaseHTTPRequestHandler)
+        return Handler, True
+    except:
+        try:
+            from __NOW_HANDLER_FILENAME import handler
+            assert issubclass(handler, BaseHTTPRequestHandler)
+            return handler, True
+        except:
+            from __NOW_HANDLER_FILENAME import app
+            return app, False
+
+_now_imported, _now_is_legacy = _now_get_import()
+
+if _now_is_legacy:
+    print('using HTTP Handler')
+    from http.server import HTTPServer
+    import requests
+    import _thread
+    server = HTTPServer(('', 0), _now_imported)
+    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']
+        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,
+        }
+else:
+    print('using Web Server Gateway Interface (WSGI)')
+    import sys
+    try:
+        from urllib.parse import urlparse
+    except ImportError:
+        from urlparse import urlparse
+    from werkzeug._compat import BytesIO
+    from werkzeug._compat import string_types
+    from werkzeug._compat import to_bytes
+    from werkzeug._compat import wsgi_encoding_dance
+    from werkzeug.datastructures import Headers
+    from werkzeug.wrappers import Response
+    def now_handler(event, context):
+        payload = json.loads(event['body'])
+
+        headers = Headers(payload.get('headers', {}))
+
+        body = payload.get('body', '')
+        if body != '':
+            if payload.get('encoding') == 'base64':
+                body = base64.b64decode(body)
+        if isinstance(body, string_types):
+            body = to_bytes(body, charset='utf-8')
+
+        urlinfo = urlparse(payload['path'])
+
+        environ = {
+            'CONTENT_LENGTH': str(len(body)),
+            'CONTENT_TYPE': headers.get('content-type', ''),
+            'PATH_INFO': payload['path'],
+            'QUERY_STRING': urlinfo.query,
+            'REMOTE_ADDR': headers.get(
+                'x-forwarded-for', headers.get(
+                    'x-real-ip', payload.get(
+                        'true-client-ip', ''))),
+            'REQUEST_METHOD': payload['method'],
+            'SERVER_NAME': headers.get('host', 'lambda'),
+            'SERVER_PORT': headers.get('x-forwarded-port', '80'),
+            'SERVER_PROTOCOL': 'HTTP/1.1',
+            'event': event,
+            'context': context,
+            'wsgi.errors': sys.stderr,
+            'wsgi.input': BytesIO(body),
+            'wsgi.multiprocess': False,
+            'wsgi.multithread': False,
+            'wsgi.run_once': False,
+            'wsgi.url_scheme': headers.get('x-forwarded-proto', 'http'),
+            'wsgi.version': (1, 0),
+        }
+
+        for key, value in environ.items():
+            if isinstance(value, string_types):
+                environ[key] = wsgi_encoding_dance(value)
+
+        for key, value in headers.items():
+            key = 'HTTP_' + key.upper().replace('-', '_')
+            if key not in ('HTTP_CONTENT_TYPE', 'HTTP_CONTENT_LENGTH'):
+                environ[key] = value
+
+        response = Response.from_app(_now_imported, environ)
+
+        return_dict = {
+            'statusCode': response.status_code,
+            'headers': dict(response.headers)
+        }
+
+        if response.data:
+            return_dict['body'] = base64.b64encode(response.data).decode('utf-8')
+            return_dict['encoding'] = 'base64'
+
+        return return_dict
+

packages/now-python/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@now/python",
-  "version": "0.0.41-canary.2",
+  "version": "0.1.0-canary.2",
   "main": "index.js",
   "license": "MIT",
   "repository": {
@@ -8,9 +8,17 @@
     "url": "https://github.com/zeit/now-builders.git",
     "directory": "packages/now-python"
   },
+  "scripts": {
+    "build": "tsc",
+    "test": "tsc && jest",
+    "prepublish": "tsc"
+  },
   "dependencies": {
     "execa": "^1.0.0",
-    "fs.promised": "^3.0.0",
     "node-fetch": "^2.2.0"
+  },
+  "devDependencies": {
+    "@types/execa": "^0.9.0",
+    "typescript": "3.3.4000"
   }
 }