Publish

- @now/bash@0.2.0
 - @now/build-utils@0.5.0
 - @now/cgi@0.1.0
 - @now/go@0.4.0
 - @now/html-minifier@1.1.0
 - @now/lambda@0.5.0
 - @now/md@0.5.0
 - @now/mdx-deck@0.5.0
 - @now/next@0.2.0
 - @now/node-bridge@1.1.0
 - @now/node-server@0.6.0
 - @now/node@0.6.0
 - @now/optipng@0.5.0
 - @now/php-bridge@0.5.0
 - @now/php@0.5.0
 - @now/python@0.1.0
 - @now/rust@0.2.0
 - @now/static-build@0.5.0
 - @now/wordpress@0.5.0

.circleci/config.yml

@@ -27,8 +27,8 @@ jobs:
           name: Linting
           command: yarn lint
       - run:
-          name: Tests
+          name: Tests and Coverage
-          command: yarn test
+          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

@@ -4,4 +4,7 @@
 /packages/now-go/go/*
 /packages/now-build-utils/dist/*
 /packages/now-node/dist/*
+/packages/now-next/dist/*
 /packages/now-node-bridge/*
+/packages/now-python/*
+/packages/now-optipng/dist/*

.eslintrc

@@ -8,7 +8,7 @@
   },
   "overrides": [
     {
-      "files": ["test/**"],
+      "files": ["**/test/**"],
       "rules": {
         "import/no-extraneous-dependencies": 0
       },

.prettierrc.json

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

.vscode/settings.json

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

jest.config.js

@@ -1,4 +1,8 @@
 module.exports = {
   testEnvironment: 'node',
-  collectCoverageFrom: ['packages/**/*.{js,jsx}', '!**/node_modules/**'],
+  collectCoverageFrom: [
+    'packages/(!test)/**/*.{js,jsx}',
+    '!**/node_modules/**',
+    '!**/test/**',
+  ],
 };

package.json

@@ -16,7 +16,9 @@
     "publish-canary": "lerna version prerelease --preid canary",
     "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",
@@ -25,6 +27,10 @@
       "prettier --write",
       "eslint --fix",
       "git add"
+    ],
+    "*.ts": [
+      "prettier --write",
+      "git add"
     ]
   },
   "devDependencies": {
@@ -34,6 +40,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",

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@now/bash",
-  "version": "0.1.5-canary.0",
+  "version": "0.2.0",
   "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
+		local error_message="Initialization failed for '$SCRIPT_FILENAME' (exit code $exit_code)"
-		error='{"exitCode":'"$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,9 +48,6 @@ _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 :/
@@ -56,6 +56,7 @@ _lambda_runtime_next() {
 	mkfifo "$stdin"
 	_lambda_runtime_body < "$event" > "$stdin" &
 
+	local exit_code=0
 	handler "$event" < "$stdin" > "$body" || exit_code="$?"
 
 	rm -f "$event" "$stdin"
@@ -69,8 +70,9 @@ _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"
+		local error_message="Invocation failed for 'handler' function in '$SCRIPT_FILENAME' (exit code $exit_code)"
-		_lambda_runtime_api "invocation/$request_id/error" -X POST -d @- > /dev/null <<< '{"exitCode":'"$exit_code"'}'
+		echo "$error_message" >&2
+		_lambda_runtime_api "invocation/$request_id/error" -X POST -d '{"errorMessage":"'"$error_message"'"}' > /dev/null
 	fi
 }
 
@@ -100,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

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

packages/now-build-utils/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@now/build-utils",
-  "version": "0.4.38-canary.0",
+  "version": "0.5.0",
   "license": "MIT",
   "main": "./dist/index.js",
   "types": "./dist/index.d.js",
@@ -12,7 +12,7 @@
   "dependencies": {
     "async-retry": "1.2.3",
     "async-sema": "2.1.4",
-    "end-of-stream": "^1.4.1",
+    "end-of-stream": "1.4.1",
     "fs-extra": "7.0.0",
     "glob": "7.1.3",
     "into-stream": "5.0.0",
@@ -30,8 +30,10 @@
     "@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/download.ts

@@ -1,27 +0,0 @@
-import path from 'path';
-import FileFsRef from './file-fs-ref';
-import { File, Files } from './types';
-
-export interface DownloadedFiles {
-  [filePath: string]: FileFsRef
-}
-
-async function downloadFile(file: File, fsPath: string): Promise<FileFsRef> {
-  const { mode } = file;
-  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/file-blob.ts

@@ -13,7 +13,7 @@ interface FromStreamOptions {
 }
 
 export default class FileBlob implements File {
-  public type: string;
+  public type: 'FileBlob';
   public mode: number;
   public data: string | Buffer;
 

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

@@ -5,17 +5,13 @@ import path from 'path';
 import Sema from 'async-sema';
 import { File } from './types';
 
-const semaToPreventEMFILE = new Sema(30);
+const semaToPreventEMFILE = new Sema(20);
 
 interface FileFsRefOptions {
   mode?: number;
   fsPath: string;
 }
 
-interface FromOptions {
-  fsPath: string;
-}
-
 interface FromStreamOptions {
   mode: number;
   stream: NodeJS.ReadableStream;
@@ -23,7 +19,7 @@ interface FromStreamOptions {
 }
 
 class FileFsRef implements File {
-  public type: string;
+  public type: 'FileFsRef';
   public mode: number;
   public fsPath: string;
 
@@ -35,9 +31,13 @@ class FileFsRef implements File {
     this.fsPath = fsPath;
   }
 
-  static async fromFsPath({ fsPath }: FromOptions): Promise<FileFsRef> {
+  static async fromFsPath({ mode, fsPath }: FileFsRefOptions): Promise<FileFsRef> {
-    const { mode } = await fs.lstat(fsPath);
+    let m = mode;
-    return new FileFsRef({ mode, fsPath });
+    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> {
@@ -47,14 +47,15 @@ class FileFsRef implements File {
     await fs.mkdirp(path.dirname(fsPath));
 
     await new Promise<void>((resolve, reject) => {
-      const dest = fs.createWriteStream(fsPath);
+      const dest = fs.createWriteStream(fsPath, {
+        mode: mode & 0o777
+      });
       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 });
   }
 

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

@@ -8,9 +8,10 @@ import { File } from './types';
 interface FileRefOptions {
   mode?: number;
   digest: string;
+  mutable?: boolean;
 }
 
-const semaToDownloadFromS3 = new Sema(10);
+const semaToDownloadFromS3 = new Sema(5);
 
 class BailableError extends Error {
   public bail: boolean;
@@ -22,16 +23,19 @@ class BailableError extends Error {
 }
 
 export default class FileRef implements File {
-  public type: string;
+  public type: 'FileRef';
   public mode: number;
   public digest: string;
+  public mutable: boolean;
 
-  constructor({ mode = 0o100644, digest }: FileRefOptions) {
+  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> {
@@ -39,8 +43,9 @@ export default class FileRef implements File {
     // sha:24be087eef9fac01d61b30a725c1a10d7b45a256
     const digestParts = this.digest.split(':');
     if (digestParts[0] === 'sha') {
-      // url = `https://s3.amazonaws.com/now-files/${digestParts[1]}`;
+      url = this.mutable
-      url = `https://dmmcy0pwk6bqi.cloudfront.net/${digestParts[1]}`;
+        ? `https://s3.amazonaws.com/now-files/${digestParts[1]}`
+        : `https://dmmcy0pwk6bqi.cloudfront.net/${digestParts[1]}`;
     } else {
       throw new Error('Expected digest to be sha');
     }

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

@@ -1,27 +1,62 @@
 import path from 'path';
 import FileFsRef from '../file-fs-ref';
-import { File, Files } from '../types';
+import { File, Files, Meta } from '../types';
+import { remove, 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> {
+async function removeFile(basePath: string, fileMatched: string) {
+  const file = path.join(basePath, fileMatched);
+  await remove(file);
+}
+
+export default async function download(files: Files, basePath: string, meta?: Meta): Promise<DownloadedFiles> {
   const files2: DownloadedFiles = {};
+  const { filesChanged = null, filesRemoved = null } = meta || {};
 
   await Promise.all(
     Object.keys(files).map(async (name) => {
+      // If the file does not exist anymore, remove it.
+      if (Array.isArray(filesRemoved) && filesRemoved.includes(name)) {
+        await removeFile(basePath, name);
+        return;
+      }
+
+      // If a file didn't change, do not re-download it.
+      if (Array.isArray(filesChanged) && !filesChanged.includes(name)) {
+        return;
+      }
+
       const file = files[name];
       const fsPath = path.join(basePath, name);
+
       files2[name] = await downloadFile(file, fsPath);
     }),
   );
 
   return files2;
-};
+}

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

@@ -1,16 +1,19 @@
-import assert from 'assert';
 import path from 'path';
-import vanillaGlob from 'glob';
+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 = import('glob').IOptions;
+type GlobOptions = vanillaGlob_.IOptions;
 
 interface FsFiles {
   [filePath: string]: FileFsRef
 }
 
-export default function glob(pattern: string, opts: GlobOptions | string, mountpoint?: string): Promise<FsFiles> {
+const vanillaGlob = promisify(vanillaGlob_);
-  return new Promise<FsFiles>((resolve, reject) => {
+
+export default async function glob(pattern: string, opts: GlobOptions | string, mountpoint?: string): Promise<FsFiles> {
   let options: GlobOptions;
   if (typeof opts === 'string') {
     options = { cwd: opts };
@@ -28,34 +31,36 @@ export default function glob(pattern: string, opts: GlobOptions | string, mountp
     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;
 
-    // eslint-disable-next-line consistent-return
+  const files = await vanillaGlob(pattern, options);
-    vanillaGlob(pattern, options, (error, files) => {
-      if (error) return reject(error);
 
-      resolve(
+  for (const relativePath of files) {
-        files.reduce<FsFiles>((files2, relativePath) => {
     const fsPath = path.join(options.cwd!, relativePath);
-          const stat = options.statCache![fsPath] as import('fs').Stats;
+    let stat: Stats = options.statCache![fsPath] as Stats;
     assert(
       stat,
       `statCache does not contain value for ${relativePath} (resolved to ${fsPath})`,
     );
-          if (stat && stat.isFile()) {
+    if (stat.isFile()) {
-            let finalPath = relativePath;
+      const isSymlink = options.symlinks![fsPath];
-            if (mountpoint) finalPath = path.join(mountpoint, finalPath);
+      if (isSymlink) {
-            return {
+        stat = await lstat(fsPath);
-              ...files2,
-              [finalPath]: new FileFsRef({ mode: stat.mode, fsPath }),
-            };
       }
 
-          return files2;
+      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/run-user-scripts.ts

@@ -5,11 +5,27 @@ import { spawn, SpawnOptions } from 'child_process';
 
 function spawnAsync(command: string, args: string[], cwd: string, opts: SpawnOptions = {}) {
   return new Promise<void>((resolve, reject) => {
-    const child = spawn(command, args, { stdio: 'inherit', cwd, ...opts });
+    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) => (code !== 0
+    child.on('close', (code, signal) => {
-      ? reject(new Error(`Exited with ${code || signal}`))
+      if (code === 0) {
-      : resolve()));
+        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}`));
+      }
+    });
   });
 }
 
@@ -75,24 +91,32 @@ export async function installDependencies(destPath: string, args: string[] = [])
       // 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);
+    await spawnAsync(
-    await spawnAsync('npm', ['cache', 'clean', '--force'], destPath, opts);
+      'npm',
+      ['install'].concat(commandArgs),
+      destPath,
+      opts as SpawnOptions
+    );
   } else {
     await spawnAsync(
       'yarn',
       ['--cwd', destPath].concat(commandArgs),
       destPath,
-      opts,
+      opts as SpawnOptions,
     );
-    await spawnAsync('yarn', ['cache', 'clean'], destPath, opts);
   }
 }
 
-export async function runPackageJsonScript(destPath: string, scriptName: string) {
+export async function runPackageJsonScript(
+  destPath: string,
+  scriptName: string,
+  opts?: SpawnOptions
+) {
   assert(path.isAbsolute(destPath));
   const { hasScript, hasPackageLockJson } = await scanParentDirs(
     destPath,
@@ -102,10 +126,10 @@ export async function runPackageJsonScript(destPath: string, scriptName: string)
 
   if (hasPackageLockJson) {
     console.log(`running "npm run ${scriptName}"`);
-    await spawnAsync('npm', ['run', scriptName], destPath);
+    await spawnAsync('npm', ['run', scriptName], destPath, opts);
   } else {
     console.log(`running "yarn run ${scriptName}"`);
-    await spawnAsync('yarn', ['--cwd', destPath, 'run', scriptName], destPath);
+    await spawnAsync('yarn', ['--cwd', destPath, 'run', scriptName], destPath, opts);
   }
 
   return true;

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

@@ -1,7 +1,7 @@
 import FileBlob from './file-blob';
 import FileFsRef from './file-fs-ref';
 import FileRef from './file-ref';
-import { File, Files, AnalyzeOptions, BuildOptions, PrepareCacheOptions } from './types';
+import { File, Files, AnalyzeOptions, BuildOptions, PrepareCacheOptions, ShouldServeOptions, Meta } from './types';
 import { Lambda, createLambda } from './lambda';
 import download from './fs/download';
 import getWriteableDirectory from './fs/get-writable-directory'
@@ -9,6 +9,7 @@ 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,
@@ -16,6 +17,7 @@ export {
     FileRef,
     Files,
     File,
+    Meta,
     Lambda,
     createLambda,
     download,
@@ -27,5 +29,6 @@ export {
     AnalyzeOptions,
     BuildOptions,
     PrepareCacheOptions,
+    ShouldServeOptions,
+    shouldServe,
 };
-

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

@@ -1,8 +1,11 @@
 import assert from 'assert';
 import Sema from 'async-sema';
 import { ZipFile } from 'yazl';
-import streamToBuffer from './fs/stream-to-buffer';
+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;
@@ -23,7 +26,7 @@ interface CreateLambdaOptions {
 }
 
 export class Lambda {
-  public type: string;
+  public type: 'Lambda';
   public zipBuffer: Buffer;
   public handler: string;
   public runtime: string;
@@ -52,22 +55,9 @@ export async function createLambda({
   assert(typeof environment === 'object', '"environment" is not an object');
 
   await sema.acquire();
+
   try {
-    const zipFile = new ZipFile();
+    const zipBuffer = await createZip(files);
-    const zipBuffer = await new Promise<Buffer>((resolve, reject) => {
-      Object.keys(files)
-        .sort()
-        .forEach((name) => {
-          const file = files[name];
-          const stream = file.toStream() as import('stream').Readable;
-          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,
@@ -78,3 +68,37 @@ export async function createLambda({
     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

@@ -1,22 +1,35 @@
+import FileRef from './file-ref';
+import FileFsRef from './file-fs-ref';
+
 export interface File {
   type: string;
   mode: number;
   toStream: () => NodeJS.ReadableStream;
+  fsPath?: string;
 }
 
 export interface Files {
-  [filePath: string]: File
+  [filePath: string]: File;
 }
 
 export interface Config {
-  [key: string]: string
+  [key: string]: string;
+}
+
+export interface Meta {
+  isDev?: boolean;
+  requestPath?: string;
+  filesChanged?: string[];
+  filesRemoved?: string[];
 }
 
 export interface AnalyzeOptions {
   /**
    * All source files of the project
    */
-  files: Files;
+  files: {
+    [filePath: string]: FileRef;
+  };
 
   /**
    * Name of entrypoint file for this particular build job. Value
@@ -39,7 +52,6 @@ export interface AnalyzeOptions {
   config: Config;
 }
 
-
 export interface BuildOptions {
   /**
    * All source files of the project
@@ -65,6 +77,13 @@ export interface BuildOptions {
    * in `now.json`.
    */
   config: Config;
+
+  /**
+   * Metadata related to the invoker of the builder, used by `now dev`.
+   * Builders may use the properties on this object to change behavior based
+   * on the build environment.
+   */
+  meta?: Meta;
 }
 
 export interface PrepareCacheOptions {
@@ -99,3 +118,37 @@ export interface PrepareCacheOptions {
    */
   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;
+  };
+
+  /**
+   * 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;
+}

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-cgi/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@now/cgi",
-  "version": "0.0.16-canary.0",
+  "version": "0.1.0",
   "license": "MIT",
   "repository": {
     "type": "git",

packages/now-go/index.js

@@ -1,4 +1,4 @@
-const { join, dirname } = require('path');
+const { join, sep, dirname } = require('path');
 const {
   readFile, writeFile, pathExists, move,
 } = require('fs-extra');
@@ -55,7 +55,7 @@ async function build({ files, entrypoint }) {
 
   // check if package name other than main
   const packageName = parseFunctionName.split(',')[1];
-  const isGoModExist = await pathExists(`${entrypointDirname}/go.mod`);
+  const isGoModExist = await pathExists(join(entrypointDirname, 'go.mod'));
   if (packageName !== 'main') {
     const go = await createGo(
       goPath,
@@ -88,7 +88,7 @@ async function build({ files, entrypoint }) {
 
     if (isGoModExist) {
       const goModContents = await readFile(
-        `${entrypointDirname}/go.mod`,
+        join(entrypointDirname, 'go.mod'),
         'utf8',
       );
       goPackageName = `${
@@ -108,10 +108,20 @@ async function build({ files, entrypoint }) {
 
     // move user go file to folder
     try {
-      await move(
+      // default path
-        downloadedFiles[entrypoint].fsPath,
+      let finalDestination = join(entrypointDirname, packageName, entrypoint);
-        `${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;

packages/now-go/package.json

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

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-html-minifier/package.json

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

packages/now-lambda/package.json

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

packages/now-md/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@now/md",
-  "version": "0.4.10-canary.2",
+  "version": "0.5.0",
   "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 }) => {
+exports.prepareCache = async ({ workPath }) => ({
-  console.log('writing package.json...');
+  ...(await glob('node_modules/**', workPath)),
-  const packageJson = { dependencies: { 'mdx-deck': '1.7.15' } };
+  ...(await glob('package-lock.json', workPath)),
-  const packageJsonPath = path.join(cachePath, 'package.json');
+  ...(await glob('yarn.lock', workPath)),
-  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)),
-  };
-};

packages/now-mdx-deck/package.json

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

packages/now-next/.gitignore

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

packages/now-next/getBridgeTypes.sh

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

packages/now-next/legacy-launcher.js

@@ -1,18 +0,0 @@
-const { Server } = require('http');
-const next = require('next-server');
-const url = require('url');
-const { Bridge } = require('./now__bridge');
-
-process.env.NODE_ENV = 'production';
-
-const app = next({});
-
-const server = new Server((req, res) => {
-  const parsedUrl = url.parse(req.url, true);
-  app.render(req, res, 'PATHNAME_PLACEHOLDER', parsedUrl.query, parsedUrl);
-});
-
-const bridge = new Bridge(server);
-bridge.listen();
-
-exports.launcher = bridge.launcher;

packages/now-next/package.json

@@ -1,9 +1,12 @@
 {
   "name": "@now/next",
-  "version": "0.1.3-canary.2",
+  "version": "0.2.0",
   "license": "MIT",
+  "main": "./dist/index",
   "scripts": {
-    "build": "tsc"
+    "build": "./getBridgeTypes.sh && tsc",
+    "test": "npm run build && jest",
+    "prepublish": "yarn run build"
   },
   "repository": {
     "type": "git",
@@ -11,9 +14,20 @@
     "directory": "packages/now-next"
   },
   "dependencies": {
-    "@now/node-bridge": "^1.0.0",
+    "@now/node-bridge": "^1.1.0",
-    "execa": "^1.0.0",
     "fs-extra": "^7.0.0",
+    "get-port": "^5.0.0",
+    "resolve-from": "^5.0.0",
     "semver": "^5.6.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@types/next-server": "^8.0.0",
+    "@types/resolve-from": "^5.0.1",
+    "@types/semver": "^6.0.0",
+    "jest": "^24.7.1",
+    "typescript": "^3.4.3"
   }
 }

packages/now-next/src/dev-server.ts

@@ -0,0 +1,41 @@
+import resolveFrom from 'resolve-from';
+import { parse } from 'url';
+import getPort from 'get-port';
+import { createServer } from 'http';
+
+export interface ProcessEnv {
+  [key: string]: string;
+}
+
+async function main(env: ProcessEnv, cwd: string) {
+  const next = require(resolveFrom(cwd, 'next'));
+  const app = next({ dev: true, dir: cwd });
+  const handler = app.getRequestHandler();
+
+  const openPort = await getPort({
+    port: [ 5000, 4000 ]
+  });
+
+  const url = `http://localhost:${openPort}`;
+
+  // Prepare for incoming requests
+  await app.prepare();
+
+  createServer((req, res) => {
+    const parsedUrl = parse(req.url || '', true);
+    handler(req, res, parsedUrl);
+  }).listen(openPort, (error: NodeJS.ErrnoException) => {
+    if (error) {
+      console.error(error);
+      process.exit(1);
+
+      return;
+    }
+
+    if (process.send) {
+      process.send(url);
+    }
+  });
+}
+
+main(process.env as ProcessEnv, process.cwd());

packages/now-next/src/index.ts

@@ -1,48 +1,58 @@
-const { createLambda } = require('@now/build-utils/lambda'); // eslint-disable-line import/no-extraneous-dependencies
+import { ChildProcess, fork, SpawnOptions } from 'child_process';
-const download = require('@now/build-utils/fs/download'); // eslint-disable-line import/no-extraneous-dependencies
+import {
-const FileFsRef = require('@now/build-utils/file-fs-ref'); // eslint-disable-line import/no-extraneous-dependencies
+  pathExists,
-const FileBlob = require('@now/build-utils/file-blob'); // eslint-disable-line import/no-extraneous-dependencies
+  readFile,
-const path = require('path');
+  unlink as unlinkFile,
-const {
+  writeFile,
+} from 'fs-extra';
+import os from 'os';
+import path from 'path';
+import semver from 'semver';
+
+import {
+  BuildOptions,
+  createLambda,
+  download,
+  FileBlob,
+  FileFsRef,
+  Files,
+  glob,
+  Lambda,
+  PrepareCacheOptions,
   runNpmInstall,
   runPackageJsonScript,
-} = require('@now/build-utils/fs/run-user-scripts'); // eslint-disable-line import/no-extraneous-dependencies
+} from '@now/build-utils';
-const glob = require('@now/build-utils/fs/glob'); // eslint-disable-line import/no-extraneous-dependencies
+
-const {
+import nextLegacyVersions from './legacy-versions';
-  readFile,
+import {
-  writeFile,
-  unlink: unlinkFile,
-  remove: removePath,
-  mkdirp,
-  rename: renamePath,
-  pathExists,
-} = require('fs-extra');
-const semver = require('semver');
-const nextLegacyVersions = require('./legacy-versions');
-const {
   excludeFiles,
-  validateEntrypoint,
+  getNextConfig,
+  getPathsInside,
+  getRoutes,
   includeOnlyEntryDirectory,
   normalizePackageJson,
   onlyStaticDirectory,
-  getNextConfig,
+  stringMap,
-} = require('./utils');
+  validateEntrypoint,
+} from './utils';
 
-/** @typedef { import('@now/build-utils/file-ref').Files } Files */
+interface BuildParamsMeta {
-/** @typedef { import('@now/build-utils/fs/download').DownloadedFiles } DownloadedFiles */
+  isDev: boolean | undefined;
+}
 
-/**
+interface BuildParamsType extends BuildOptions {
- * @typedef {Object} BuildParamsType
+  files: Files;
- * @property {Files} files - Files object
+  entrypoint: string;
- * @property {string} entrypoint - Entrypoint specified for the builder
+  workPath: string;
- * @property {string} workPath - Working directory for this build
+  meta: BuildParamsMeta;
- */
+}
+
+export const version = 2;
 
 /**
  * Read package.json from files
- * @param {string} entryPath
  */
-async function readPackageJson(entryPath) {
+async function readPackageJson(entryPath: string) {
   const packagePath = path.join(entryPath, 'package.json');
 
   try {
@@ -55,29 +65,28 @@ async function readPackageJson(entryPath) {
 
 /**
  * Write package.json
- * @param {string} workPath
- * @param {Object} packageJson
  */
-async function writePackageJson(workPath, packageJson) {
+async function writePackageJson(workPath: string, packageJson: Object) {
   await writeFile(
     path.join(workPath, 'package.json'),
-    JSON.stringify(packageJson, null, 2),
+    JSON.stringify(packageJson, null, 2)
   );
 }
 
 /**
  * Write .npmrc with npm auth token
- * @param {string} workPath
- * @param {string} token
  */
-async function writeNpmRc(workPath, token) {
+async function writeNpmRc(workPath: string, token: string) {
   await writeFile(
     path.join(workPath, '.npmrc'),
-    `//registry.npmjs.org/:_authToken=${token}`,
+    `//registry.npmjs.org/:_authToken=${token}`
   );
 }
 
-function getNextVersion(packageJson) {
+function getNextVersion(packageJson: {
+  dependencies?: { [key: string]: string };
+  devDependencies?: { [key: string]: string };
+}) {
   let nextVersion;
   if (packageJson.dependencies && packageJson.dependencies.next) {
     nextVersion = packageJson.dependencies.next;
@@ -87,7 +96,7 @@ function getNextVersion(packageJson) {
   return nextVersion;
 }
 
-function isLegacyNext(nextVersion) {
+function isLegacyNext(nextVersion: string) {
   // If version is using the dist-tag instead of a version range
   if (nextVersion === 'canary' || nextVersion === 'latest') {
     return false;
@@ -107,34 +116,95 @@ function isLegacyNext(nextVersion) {
   return true;
 }
 
-exports.config = {
+const name = '[@now/next]';
+const urls: stringMap = {};
+
+function startDevServer(entryPath: string) {
+  const forked = fork(path.join(__dirname, 'dev-server.js'), [], {
+    cwd: entryPath,
+    execArgv: [],
+    env: {
+      NOW_REGION: 'dev1',
+    },
+  });
+
+  const getUrl = () =>
+    new Promise<string>((resolve, reject) => {
+      forked.on('message', resolve);
+      forked.on('error', reject);
+    });
+
+  return { forked, getUrl };
+}
+
+export const config = {
   maxLambdaSize: '5mb',
 };
 
-/**
+export const build = async ({
- * @param {BuildParamsType} buildParams
+  files,
- * @returns {Promise<Files>}
+  workPath,
- */
+  entrypoint,
-exports.build = async ({ files, workPath, entrypoint }) => {
+  meta = {} as BuildParamsMeta,
+}: BuildParamsType): Promise<{
+  routes?: any[];
+  output: Files;
+  watch?: string[];
+  childProcesses: ChildProcess[];
+}> => {
   validateEntrypoint(entrypoint);
 
-  console.log('downloading user files...');
+  const routes: any[] = [];
   const entryDirectory = path.dirname(entrypoint);
-  await download(files, workPath);
   const entryPath = path.join(workPath, entryDirectory);
+  const dotNext = path.join(entryPath, '.next');
 
-  if (await pathExists(path.join(entryPath, '.next'))) {
+  console.log(`${name} Downloading user files...`);
-    console.warn(
+  await download(files, workPath, meta);
-      'WARNING: You should probably not upload the `.next` directory. See https://zeit.co/docs/v2/deployments/official-builders/next-js-now-next/ for more information.',
+
+  const pkg = await readPackageJson(entryPath);
+  const nextVersion = getNextVersion(pkg);
+
+  if (!nextVersion) {
+    throw new Error(
+      'No Next.js version could be detected in "package.json". Make sure `"next"` is installed in "dependencies" or "devDependencies"'
     );
   }
 
-  const pkg = await readPackageJson(entryPath);
+  process.env.__NEXT_BUILDER_EXPERIMENTAL_TARGET = 'serverless';
 
-  const nextVersion = getNextVersion(pkg);
+  if (meta.isDev) {
-  if (!nextVersion) {
+    // eslint-disable-next-line no-underscore-dangle
-    throw new Error(
+    process.env.__NEXT_BUILDER_EXPERIMENTAL_DEBUG = 'true';
-      'No Next.js version could be detected in "package.json". Make sure `"next"` is installed in "dependencies" or "devDependencies"',
+    let childProcess: ChildProcess | undefined;
+
+    // If this is the initial build, we want to start the server
+    if (!urls[entrypoint]) {
+      console.log(`${name} Installing dependencies...`);
+      await runNpmInstall(entryPath, ['--prefer-offline']);
+      const { forked, getUrl } = startDevServer(entryPath);
+      urls[entrypoint] = await getUrl();
+      childProcess = forked;
+      console.log(
+        `${name} Development server for ${entrypoint} running at ${
+          urls[entrypoint]
+        }`
+      );
+    }
+
+    const pathsInside = getPathsInside(entryDirectory, files);
+
+    return {
+      output: {},
+      routes: getRoutes(entryDirectory, pathsInside, files, urls[entrypoint]),
+      watch: pathsInside,
+      childProcesses: childProcess ? [childProcess] : [],
+    };
+  }
+
+  if (await pathExists(dotNext)) {
+    console.warn(
+      'WARNING: You should not upload the `.next` directory. See https://zeit.co/docs/v2/deployments/official-builders/next-js-now-next/ for more details.'
     );
   }
 
@@ -156,7 +226,7 @@ exports.build = async ({ files, workPath, entrypoint }) => {
     }
 
     console.warn(
-      "WARNING: your application is being deployed in @now/next's legacy mode. http://err.sh/zeit/now-builders/now-next-legacy-mode",
+      "WARNING: your application is being deployed in @now/next's legacy mode. http://err.sh/zeit/now-builders/now-next-legacy-mode"
     );
 
     console.log('normalizing package.json');
@@ -165,7 +235,7 @@ exports.build = async ({ files, workPath, entrypoint }) => {
     await writePackageJson(entryPath, packageJson);
   } else if (!pkg.scripts || !pkg.scripts['now-build']) {
     console.warn(
-      'WARNING: "now-build" script not found. Adding \'"now-build": "next build"\' to "package.json" automatically',
+      'WARNING: "now-build" script not found. Adding \'"now-build": "next build"\' to "package.json" automatically'
     );
     pkg.scripts = {
       'now-build': 'next build',
@@ -182,8 +252,15 @@ exports.build = async ({ files, workPath, entrypoint }) => {
 
   console.log('installing dependencies...');
   await runNpmInstall(entryPath, ['--prefer-offline']);
+
   console.log('running user script...');
-  await runPackageJsonScript(entryPath, 'now-build');
+  const memoryToConsume = Math.floor(os.totalmem() / 1024 ** 2) - 128;
+  await runPackageJsonScript(entryPath, 'now-build', {
+    env: {
+      ...process.env,
+      NODE_OPTIONS: `--max_old_space_size=${memoryToConsume}`,
+    },
+  } as SpawnOptions);
 
   if (isLegacy) {
     console.log('running npm install --production...');
@@ -194,21 +271,21 @@ exports.build = async ({ files, workPath, entrypoint }) => {
     await unlinkFile(path.join(entryPath, '.npmrc'));
   }
 
-  const lambdas = {};
+  const lambdas: { [key: string]: Lambda } = {};
 
   if (isLegacy) {
     const filesAfterBuild = await glob('**', entryPath);
 
     console.log('preparing lambda files...');
-    let buildId;
+    let buildId: string;
     try {
       buildId = await readFile(
         path.join(entryPath, '.next', 'BUILD_ID'),
-        'utf8',
+        'utf8'
       );
     } catch (err) {
       console.error(
-        'BUILD_ID not found in ".next". The "package.json" "build" script did not run "next build"',
+        'BUILD_ID not found in ".next". The "package.json" "build" script did not run "next build"'
       );
       throw new Error('Missing BUILD_ID');
     }
@@ -216,12 +293,12 @@ exports.build = async ({ files, workPath, entrypoint }) => {
     const dotNextServerRootFiles = await glob('.next/server/*', entryPath);
     const nodeModules = excludeFiles(
       await glob('node_modules/**', entryPath),
-      file => file.startsWith('node_modules/.cache'),
+      file => file.startsWith('node_modules/.cache')
     );
     const launcherFiles = {
       'now__bridge.js': new FileFsRef({ fsPath: require('@now/node-bridge') }),
     };
-    const nextFiles = {
+    const nextFiles: { [key: string]: FileFsRef } = {
       ...nodeModules,
       ...dotNextRootFiles,
       ...dotNextServerRootFiles,
@@ -232,13 +309,13 @@ exports.build = async ({ files, workPath, entrypoint }) => {
     }
     const pages = await glob(
       '**/*.js',
-      path.join(entryPath, '.next', 'server', 'static', buildId, 'pages'),
+      path.join(entryPath, '.next', 'server', 'static', buildId, 'pages')
     );
     const launcherPath = path.join(__dirname, 'legacy-launcher.js');
     const launcherData = await readFile(launcherPath, 'utf8');
 
     await Promise.all(
-      Object.keys(pages).map(async (page) => {
+      Object.keys(pages).map(async page => {
         // These default pages don't have to be handled as they'd always 404
         if (['_app.js', '_error.js', '_document.js'].includes(page)) {
           return;
@@ -247,7 +324,7 @@ exports.build = async ({ files, workPath, entrypoint }) => {
         const pathname = page.replace(/\.js$/, '');
         const launcher = launcherData.replace(
           'PATHNAME_PLACEHOLDER',
-          `/${pathname.replace(/(^|\/)index$/, '')}`,
+          `/${pathname.replace(/(^|\/)index$/, '')}`
         );
 
         const pageFiles = {
@@ -276,7 +353,7 @@ exports.build = async ({ files, workPath, entrypoint }) => {
           runtime: 'nodejs8.10',
         });
         console.log(`Created lambda for page: "${page}"`);
-      }),
+      })
     );
   } else {
     console.log('preparing lambda files...');
@@ -288,7 +365,7 @@ exports.build = async ({ files, workPath, entrypoint }) => {
     };
     const pages = await glob(
       '**/*.js',
-      path.join(entryPath, '.next', 'serverless', 'pages'),
+      path.join(entryPath, '.next', 'serverless', 'pages')
     );
 
     const pageKeys = Object.keys(pages);
@@ -303,14 +380,14 @@ exports.build = async ({ files, workPath, entrypoint }) => {
       }
 
       throw new Error(
-        'No serverless pages were built. https://err.sh/zeit/now-builders/now-next-no-serverless-pages-built',
+        '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'),
+      path.join(entryPath, '.next', 'serverless')
     );
 
     const assetKeys = Object.keys(assets);
@@ -320,7 +397,7 @@ exports.build = async ({ files, workPath, entrypoint }) => {
     }
 
     await Promise.all(
-      pageKeys.map(async (page) => {
+      pageKeys.map(async page => {
         // These default pages don't have to be handled as they'd always 404
         if (['_app.js', '_error.js', '_document.js'].includes(page)) {
           return;
@@ -339,39 +416,48 @@ exports.build = async ({ files, workPath, entrypoint }) => {
           runtime: 'nodejs8.10',
         });
         console.log(`Created lambda for page: "${page}"`);
-      }),
+      })
     );
   }
 
   const nextStaticFiles = await glob(
     '**',
-    path.join(entryPath, '.next', 'static'),
+    path.join(entryPath, '.next', 'static')
   );
   const staticFiles = Object.keys(nextStaticFiles).reduce(
     (mappedFiles, file) => ({
       ...mappedFiles,
-      [path.join(entryDirectory, `_next/static/${file}`)]: nextStaticFiles[file],
+      [path.join(entryDirectory, `_next/static/${file}`)]: nextStaticFiles[
+        file
+      ],
     }),
-    {},
+    {}
   );
 
   const staticDirectoryFiles = onlyStaticDirectory(
     includeOnlyEntryDirectory(files, entryDirectory),
-    entryDirectory,
+    entryDirectory
   );
 
-  return { ...lambdas, ...staticFiles, ...staticDirectoryFiles };
+  return {
+    output: { ...lambdas, ...staticFiles, ...staticDirectoryFiles },
+    routes: [],
+    watch: [],
+    childProcesses: [],
+  };
 };
 
-exports.prepareCache = async ({ cachePath, workPath, entrypoint }) => {
+export const prepareCache = async ({
+  workPath,
+  entrypoint,
+}: PrepareCacheOptions) => {
   console.log('preparing cache ...');
-
   const entryDirectory = path.dirname(entrypoint);
   const entryPath = path.join(workPath, entryDirectory);
-  const cacheEntryPath = path.join(cachePath, entryDirectory);
 
   const pkg = await readPackageJson(entryPath);
   const nextVersion = getNextVersion(pkg);
+  if (!nextVersion) throw new Error('Could not parse Next.js version');
   const isLegacy = isLegacyNext(nextVersion);
 
   if (isLegacy) {
@@ -379,25 +465,14 @@ exports.prepareCache = async ({ cachePath, workPath, entrypoint }) => {
     return {};
   }
 
-  console.log('clearing old cache ...');
-  await removePath(cacheEntryPath);
-  await mkdirp(cacheEntryPath);
-
-  console.log('copying build files for cache ...');
-  await renamePath(entryPath, cacheEntryPath);
-
   console.log('producing cache file manifest ...');
-
+  const cacheEntrypoint = path.relative(workPath, entryPath);
-  const cacheEntrypoint = path.relative(cachePath, cacheEntryPath);
+  const cache = {
-  return {
+    ...(await glob(path.join(cacheEntrypoint, 'node_modules/**'), workPath)),
-    ...(await glob(
+    ...(await glob(path.join(cacheEntrypoint, '.next/cache/**'), workPath)),
-      path.join(
+    ...(await glob(path.join(cacheEntrypoint, 'package-lock.json'), workPath)),
-        cacheEntrypoint,
+    ...(await glob(path.join(cacheEntrypoint, 'yarn.lock'), workPath)),
-        'node_modules/{**,!.*,.yarn*,.cache/next-minifier/**}',
-      ),
-      cachePath,
-    )),
-    ...(await glob(path.join(cacheEntrypoint, 'package-lock.json'), cachePath)),
-    ...(await glob(path.join(cacheEntrypoint, 'yarn.lock'), cachePath)),
   };
+  console.log('cache file manifest produced');
+  return cache;
 };

packages/now-next/src/launcher.ts

@@ -1,4 +1,6 @@
-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');

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

@@ -0,0 +1,20 @@
+import { Server } from 'http';
+import next from 'next-server';
+import url from 'url';
+import { Bridge } from './now__bridge';
+
+if (!process.env.NODE_ENV) {
+  process.env.NODE_ENV = process.env.NOW_REGION === 'dev1' ? 'development' : 'production';
+}
+
+const app = next({});
+
+const server = new Server((req, res) => {
+  const parsedUrl = url.parse(req.url || '', true);
+  app.render(req, res, 'PATHNAME_PLACEHOLDER', parsedUrl.query, parsedUrl);
+});
+
+const bridge = new Bridge(server);
+bridge.listen();
+
+exports.launcher = bridge.launcher;

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

@@ -1,4 +1,4 @@
-module.exports = [
+export default [
   '0.1.0',
   '0.1.1',
   '0.2.0',

packages/now-next/src/utils.ts

@@ -1,16 +1,13 @@
-const fs = require('fs-extra');
+import fs from 'fs-extra';
-const path = require('path');
+import path from 'path';
+import { Files } from '@now/build-utils';
 
-/** @typedef { import('@now/build-utils/file-ref') } FileRef */
+type stringMap = {[key: string]: string};
-/** @typedef { import('@now/build-utils/file-fs-ref') } FileFsRef */
-/** @typedef {{[filePath: string]: FileRef|FileFsRef}} Files */
 
 /**
  * Validate if the entrypoint is allowed to be used
- * @param {string} entrypoint
- * @throws {Error}
  */
-function validateEntrypoint(entrypoint) {
+function validateEntrypoint(entrypoint: string) {
   if (
     !/package\.json$/.exec(entrypoint)
     && !/next\.config\.js$/.exec(entrypoint)
@@ -21,21 +18,10 @@ function validateEntrypoint(entrypoint) {
   }
 }
 
-/**
- * This callback type is called `requestCallback` and is displayed as a global symbol.
- *
- * @callback matcher
- * @param {string} filePath
- * @returns {boolean}
- */
-
 /**
  * Exclude certain files from the files object
- * @param {Files} files
- * @param {matcher} matcher
- * @returns {Files}
  */
-function excludeFiles(files, matcher) {
+function excludeFiles(files: Files, matcher: (filePath: string) => boolean): Files {
   return Object.keys(files).reduce((newFiles, filePath) => {
     if (matcher(filePath)) {
       return newFiles;
@@ -49,16 +35,13 @@ function excludeFiles(files, matcher) {
 
 /**
  * Creates a new Files object holding only the entrypoint files
- * @param {Files} files
- * @param {string} entryDirectory
- * @returns {Files}
  */
-function includeOnlyEntryDirectory(files, entryDirectory) {
+function includeOnlyEntryDirectory(files: Files, entryDirectory: string): Files {
   if (entryDirectory === '.') {
     return files;
   }
 
-  function matcher(filePath) {
+  function matcher(filePath: string) {
     return !filePath.startsWith(entryDirectory);
   }
 
@@ -67,10 +50,8 @@ function includeOnlyEntryDirectory(files, entryDirectory) {
 
 /**
  * Exclude package manager lockfiles from files
- * @param {Files} files
- * @returns {Files}
  */
-function excludeLockFiles(files) {
+function excludeLockFiles(files: Files): Files {
   const newFiles = files;
   if (newFiles['package-lock.json']) {
     delete newFiles['package-lock.json'];
@@ -83,11 +64,9 @@ function excludeLockFiles(files) {
 
 /**
  * Include the static directory from files
- * @param {Files} files
- * @returns {Files}
  */
-function onlyStaticDirectory(files, entryDir) {
+function onlyStaticDirectory(files: Files, entryDir: string): Files {
-  function matcher(filePath) {
+  function matcher(filePath: string) {
     return !filePath.startsWith(path.join(entryDir, 'static'));
   }
 
@@ -96,11 +75,10 @@ function onlyStaticDirectory(files, entryDir) {
 
 /**
  * Enforce specific package.json configuration for smallest possible lambda
- * @param {{dependencies?: any, devDependencies?: any, scripts?: any}} defaultPackageJson
  */
-function normalizePackageJson(defaultPackageJson = {}) {
+function normalizePackageJson(defaultPackageJson: {dependencies?: stringMap, devDependencies?: stringMap, scripts?: stringMap} = {}) {
-  const dependencies = {};
+  const dependencies: stringMap = {};
-  const devDependencies = {
+  const devDependencies: stringMap = {
     ...defaultPackageJson.dependencies,
     ...defaultPackageJson.devDependencies,
   };
@@ -139,7 +117,7 @@ function normalizePackageJson(defaultPackageJson = {}) {
   };
 }
 
-async function getNextConfig(workPath, entryPath) {
+async function getNextConfig(workPath: string, entryPath: string) {
   const entryConfig = path.join(entryPath, './next.config.js');
   if (await fs.pathExists(entryConfig)) {
     return fs.readFile(entryConfig, 'utf8');
@@ -153,7 +131,84 @@ async function getNextConfig(workPath, entryPath) {
   return null;
 }
 
-module.exports = {
+function pathIsInside(firstPath: string, secondPath: string) {
+  return !path.relative(firstPath, secondPath).startsWith('..');
+}
+
+function getPathsInside(entryDirectory: string, files: Files) {
+  const watch: string[] = [];
+
+  for (const file of Object.keys(files)) {
+    // If the file is outside of the entrypoint directory, we do
+    // not want to monitor it for changes.
+    if (!pathIsInside(entryDirectory, file)) {
+      continue;
+    }
+
+    watch.push(file);
+  }
+
+  return watch;
+}
+
+function getRoutes(entryDirectory: string, pathsInside: string[], files: Files, url: string): any[] {
+  const filesInside: Files = {};
+  const prefix = entryDirectory === `.` ? `/` : `/${entryDirectory}/`;
+
+  for (const file of Object.keys(files)) {
+    if (!pathsInside.includes(file)) {
+      continue;
+    }
+
+    filesInside[file] = files[file];
+  }
+
+  const routes: any[] = [
+    {
+      src: `${prefix}_next/(.*)`,
+      dest: `${url}/_next/$1`
+    },
+    {
+      src: `${prefix}static/(.*)`,
+      dest: `${url}/static/$1`
+    }
+  ];
+
+  for (const file of Object.keys(filesInside)) {
+    const relativePath = path.relative(entryDirectory, file);
+    const isPage = pathIsInside('pages', relativePath);
+
+    if (!isPage) {
+      continue;
+    }
+
+    const relativeToPages = path.relative('pages', relativePath);
+    const extension = path.extname(relativeToPages);
+    const pageName = relativeToPages.replace(extension, '');
+
+    if (pageName.startsWith('_')) {
+      continue;
+    }
+
+    routes.push({
+      src: `${prefix}${pageName}`,
+      dest: `${url}/${pageName}`
+    });
+
+    if (pageName.endsWith('index')) {
+      const resolvedIndex = pageName.replace('/index', '').replace('index', '');
+
+      routes.push({
+        src: `${prefix}${resolvedIndex}`,
+        dest: `${url}/${resolvedIndex}`
+      });
+    }
+  }
+
+  return routes;
+}
+
+export {
   excludeFiles,
   validateEntrypoint,
   includeOnlyEntryDirectory,
@@ -161,4 +216,7 @@ module.exports = {
   normalizePackageJson,
   onlyStaticDirectory,
   getNextConfig,
+  getPathsInside,
+  getRoutes,
+  stringMap,
 };

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

@@ -1,17 +1,17 @@
 /* global it, expect */
 const path = require('path');
-const runBuildLambda = require('../../lib/run-build-lambda');
+const runBuildLambda = require('../../../../test/lib/run-build-lambda');
 
 const FOUR_MINUTES = 240000;
 
 it(
   'Should build the standard example',
   async () => {
-    const { buildResult } = await runBuildLambda(
+    const {
-      path.join(__dirname, 'standard'),
+      buildResult: { output },
-    );
+    } = await runBuildLambda(path.join(__dirname, 'standard'));
-    expect(buildResult.index).toBeDefined();
+    expect(output.index).toBeDefined();
-    const filePaths = Object.keys(buildResult);
+    const filePaths = Object.keys(output);
     const hasUnderScoreAppStaticFile = filePaths.some(filePath => filePath.match(/static.*\/pages\/_app\.js$/));
     const hasUnderScoreErrorStaticFile = filePaths.some(filePath => filePath.match(/static.*\/pages\/_error\.js$/));
     expect(hasUnderScoreAppStaticFile).toBeTruthy();
@@ -23,12 +23,12 @@ it(
 it(
   'Should build the monorepo example',
   async () => {
-    const { buildResult } = await runBuildLambda(
+    const {
-      path.join(__dirname, 'monorepo'),
+      buildResult: { output },
-    );
+    } = await runBuildLambda(path.join(__dirname, 'monorepo'));
-    expect(buildResult['www/index']).toBeDefined();
+    expect(output['www/index']).toBeDefined();
-    expect(buildResult['www/static/test.txt']).toBeDefined();
+    expect(output['www/static/test.txt']).toBeDefined();
-    const filePaths = Object.keys(buildResult);
+    const filePaths = Object.keys(output);
     const hasUnderScoreAppStaticFile = filePaths.some(filePath => filePath.match(/static.*\/pages\/_app\.js$/));
     const hasUnderScoreErrorStaticFile = filePaths.some(filePath => filePath.match(/static.*\/pages\/_error\.js$/));
     expect(hasUnderScoreAppStaticFile).toBeTruthy();
@@ -40,11 +40,11 @@ it(
 it(
   'Should build the legacy standard example',
   async () => {
-    const { buildResult } = await runBuildLambda(
+    const {
-      path.join(__dirname, 'legacy-standard'),
+      buildResult: { output },
-    );
+    } = await runBuildLambda(path.join(__dirname, 'legacy-standard'));
-    expect(buildResult.index).toBeDefined();
+    expect(output.index).toBeDefined();
-    const filePaths = Object.keys(buildResult);
+    const filePaths = Object.keys(output);
     const hasUnderScoreAppStaticFile = filePaths.some(filePath => filePath.match(/static.*\/pages\/_app\.js$/));
     const hasUnderScoreErrorStaticFile = filePaths.some(filePath => filePath.match(/static.*\/pages\/_error\.js$/));
     expect(hasUnderScoreAppStaticFile).toBeTruthy();
@@ -56,10 +56,10 @@ it(
 it(
   'Should build the legacy custom dependency test',
   async () => {
-    const { buildResult } = await runBuildLambda(
+    const {
-      path.join(__dirname, 'legacy-custom-dependency'),
+      buildResult: { output },
-    );
+    } = await runBuildLambda(path.join(__dirname, 'legacy-custom-dependency'));
-    expect(buildResult.index).toBeDefined();
+    expect(output.index).toBeDefined();
   },
   FOUR_MINUTES,
 );
@@ -78,10 +78,10 @@ it('Should throw when package.json or next.config.js is not the "src"', async ()
 it(
   'Should build the static-files test on legacy',
   async () => {
-    const { buildResult } = await runBuildLambda(
+    const {
-      path.join(__dirname, 'legacy-static-files'),
+      buildResult: { output },
-    );
+    } = await runBuildLambda(path.join(__dirname, 'legacy-static-files'));
-    expect(buildResult['static/test.txt']).toBeDefined();
+    expect(output['static/test.txt']).toBeDefined();
   },
   FOUR_MINUTES,
 );
@@ -89,10 +89,10 @@ it(
 it(
   'Should build the static-files test',
   async () => {
-    const { buildResult } = await runBuildLambda(
+    const {
-      path.join(__dirname, 'static-files'),
+      buildResult: { output },
-    );
+    } = await runBuildLambda(path.join(__dirname, 'static-files'));
-    expect(buildResult['static/test.txt']).toBeDefined();
+    expect(output['static/test.txt']).toBeDefined();
   },
   FOUR_MINUTES,
 );

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

@@ -0,0 +1,90 @@
+/* global expect, it, jest */
+const path = require('path');
+const os = require('os');
+const { build } = require('@now/next');
+const { FileBlob } = require('@now/build-utils');
+
+jest.setTimeout(45000);
+
+describe('build meta dev', () => {
+  const files = {
+    'next.config.js': new FileBlob({
+      mode: 0o777,
+      data: `
+      module.exports = {
+        target: 'serverless'
+      }
+    `,
+    }),
+    'pages/index.js': new FileBlob({
+      mode: 0o777,
+      data: `
+      export default () => 'Index page'
+    `,
+    }),
+    'package.json': new FileBlob({
+      mode: 0o777,
+      data: `
+      {
+        "scripts": {
+          "now-build": "next build"
+        },
+        "dependencies": {
+          "next": "8",
+          "react": "16",
+          "react-dom": "16"
+        }
+      }
+    `,
+    }),
+  };
+  const entrypoint = 'next.config.js';
+  const workPath = path.join(
+    os.tmpdir(),
+    Math.random()
+      .toString()
+      .slice(3),
+  );
+  console.log('workPath directory: ', workPath);
+  /*
+  it('should have builder v2 response isDev=false', async () => {
+    const meta = { isDev: false, requestPath: null };
+    const { output, routes, watch } = await build({
+      files,
+      workPath,
+      entrypoint,
+      meta,
+    });
+    //console.log('output: ', Object.keys(output));
+    expect(Object.keys(output).length).toBe(7);
+    expect(output.index.type).toBe('Lambda');
+    expect(routes.length).toBe(0);
+    expect(watch.length).toBe(0);
+  });
+  */
+
+  it('should have builder v2 response isDev=true', async () => {
+    const meta = { isDev: true, requestPath: null };
+    const {
+      output, routes, watch, childProcesses,
+    } = await build({
+      files,
+      workPath,
+      entrypoint,
+      meta,
+    });
+    routes.forEach((route) => {
+      // eslint-disable-next-line no-param-reassign
+      route.dest = route.dest.replace(':4000', ':5000');
+    });
+    expect(output).toEqual({});
+    expect(routes).toEqual([
+      { src: '/_next/(.*)', dest: 'http://localhost:5000/_next/$1' },
+      { src: '/static/(.*)', dest: 'http://localhost:5000/static/$1' },
+      { src: '/index', dest: 'http://localhost:5000/index' },
+      { src: '/', dest: 'http://localhost:5000/' },
+    ]);
+    expect(watch).toEqual(['next.config.js', 'pages/index.js', 'package.json']);
+    childProcesses.forEach(cp => cp.kill());
+  });
+});

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

@@ -5,7 +5,7 @@ const {
   includeOnlyEntryDirectory,
   normalizePackageJson,
   getNextConfig,
-} = require('@now/next/utils');
+} = require('@now/next/dist/utils');
 const FileRef = require('@now/build-utils/file-ref'); // eslint-disable-line import/no-extraneous-dependencies
 
 describe('getNextConfig', () => {

packages/now-next/tsconfig.json

@@ -1,20 +1,18 @@
 {
   "compilerOptions": {
-    "target": "ES2017",
+    "strict": true,
+    "esModuleInterop": true,
+    "lib": ["esnext"],
+    "target": "esnext",
     "module": "commonjs",
-    "lib": ["es2017"],
+    "outDir": "dist",
-    "allowJs": true,
+    "sourceMap": false,
-    "checkJs": true,
+    "declaration": false
-    "noEmit": true,
-    "strict": false,
-    "types": ["node"],
-    "esModuleInterop": true
   },
   "include": [
-    "./"
+    "src/**/*"
   ],
   "exclude": [
-    "./launcher.js",
+    "node_modules"
-    "./legacy-launcher.js"
   ]
 }

packages/now-node-bridge/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@now/node-bridge",
-  "version": "1.0.1-canary.1",
+  "version": "1.1.0",
   "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-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,41 +30,23 @@ 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);
-
+  return [downloadedFiles, entrypointFsDirname];
-  console.log('writing ncc package.json...');
-  await download(
-    {
-      'package.json': new FileBlob({
-        data: JSON.stringify({
-          license: 'UNLICENSED',
-          dependencies: {
-            '@zeit/ncc': '0.16.1',
-          },
-        }),
-      }),
-    },
-    nccPath,
-  );
-
-  console.log('installing dependencies for ncc...');
-  await runNpmInstall(nccPath, npmArguments);
-  return [downloadedFiles, userPath, nccPath, entrypointFsDirname];
 }
 
-async function compile(workNccPath, downloadedFiles, entrypoint, config) {
+async function compile(workPath, downloadedFiles, entrypoint, config) {
   const input = downloadedFiles[entrypoint].fsPath;
   const inputDir = path.dirname(input);
-  const ncc = require(path.join(workNccPath, 'node_modules/@zeit/ncc'));
+  const ncc = require('@zeit/ncc');
-  const { code, assets } = await ncc(input, { sourceMap: true });
+  const { code, map, assets } = await ncc(input, {
+    sourceMap: true,
+    sourceMapRegister: true,
+  });
 
   if (config && config.includeFiles) {
     // eslint-disable-next-line no-restricted-syntax
@@ -89,16 +70,16 @@ async function compile(workNccPath, downloadedFiles, entrypoint, config) {
   }
 
   const preparedFiles = {};
-  const blob = new FileBlob({ data: code });
   // move all user code to 'user' subdirectory
-  preparedFiles[path.join('user', entrypoint)] = blob;
+  preparedFiles[entrypoint] = new FileBlob({ data: code });
+  preparedFiles[`${entrypoint.replace('.ts', '.js')}.map`] = new FileBlob({
+    data: map,
+  });
   // 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[
+    preparedFiles[path.join(path.dirname(entrypoint), assetName)] = blob2;
-      path.join('user', path.dirname(entrypoint), assetName)
-    ] = blob2;
   }
 
   return preparedFiles;
@@ -115,12 +96,7 @@ exports.config = {
 exports.build = async ({
   files, entrypoint, config, workPath,
 }) => {
-  const [
+  const [downloadedFiles, entrypointFsDirname] = await downloadInstallAndBundle(
-    downloadedFiles,
-    workUserPath,
-    workNccPath,
-    entrypointFsDirname,
-  ] = await downloadInstallAndBundle(
     { files, entrypoint, workPath },
     { npmArguments: ['--prefer-offline'] },
   );
@@ -132,13 +108,11 @@ exports.build = async ({
   let preparedFiles;
 
   if (config && config.bundle === false) {
-    // move all user code to 'user' subdirectory
+    preparedFiles = await glob('**', workPath);
-    preparedFiles = await glob('**', workUserPath);
-    preparedFiles = rename(preparedFiles, name => path.join('user', name));
   } else {
     console.log('compiling entrypoint with ncc...');
     preparedFiles = await compile(
-      workNccPath,
+      workPath,
       downloadedFiles,
       entrypoint,
       config,
@@ -149,10 +123,7 @@ exports.build = async ({
   let launcherData = await fs.readFile(launcherPath, 'utf8');
   launcherData = launcherData.replace(
     '// PLACEHOLDER',
-    [
+    [`require("./${entrypoint}");`].join(' '),
-      'process.chdir("./user");',
-      `require("./${path.join('user', entrypoint)}");`,
-    ].join(' '),
   );
 
   const launcherFiles = {
@@ -169,18 +140,8 @@ exports.build = async ({
   return { [entrypoint]: lambda };
 };
 
-exports.prepareCache = async ({
+exports.prepareCache = async ({ workPath }) => ({
-  files, entrypoint, workPath, cachePath,
+  ...(await glob('node_modules/**', workPath)),
-}) => {
+  ...(await glob('package-lock.json', workPath)),
-  await fs.remove(workPath);
+  ...(await glob('yarn.lock', 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)),
-  };
-};

packages/now-node-server/launcher.js

@@ -11,7 +11,7 @@ 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';
 }
 
 try {
@@ -24,7 +24,8 @@ try {
     );
     process.exit(1);
   } else {
-    throw err;
+    console.error(err);
+    process.exit(1);
   }
 }
 

packages/now-node-server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@now/node-server",
-  "version": "0.5.2-canary.3",
+  "version": "0.6.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -8,7 +8,8 @@
     "directory": "packages/now-node-server"
   },
   "dependencies": {
-    "@now/node-bridge": "^1.0.1-canary.1",
+    "@now/node-bridge": "^1.1.0",
+    "@zeit/ncc": "0.18.1",
     "fs-extra": "7.0.1"
   },
   "scripts": {

packages/now-node/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@now/node",
-  "version": "0.5.2-canary.5",
+  "version": "0.6.0",
   "license": "MIT",
   "main": "./dist/index",
   "repository": {
@@ -9,7 +9,8 @@
     "directory": "packages/now-node"
   },
   "dependencies": {
-    "@now/node-bridge": "^1.0.1-canary.1",
+    "@now/node-bridge": "^1.1.0",
+    "@zeit/ncc": "0.18.1",
     "fs-extra": "7.0.1"
   },
   "scripts": {

packages/now-node/src/index.ts

@@ -1,5 +1,5 @@
-import { join, dirname } from 'path';
+import { join, dirname, sep } from 'path';
-import { remove, readFile } from 'fs-extra';
+import { readFile } from 'fs-extra';
 import {
   glob,
   download,
@@ -30,42 +30,23 @@ async function downloadInstallAndBundle({
   workPath,
   npmArguments = []
 }: DownloadOptions) {
-  const userPath = join(workPath, 'user');
-  const nccPath = 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 = join(userPath, dirname(entrypoint));
+  const entrypointFsDirname = join(workPath, 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.16.1',
-          }
-        })
-      })
-    },
-    nccPath
-  );
-
-  console.log('installing dependencies for ncc...');
-  await runNpmInstall(nccPath, npmArguments);
   const entrypointPath = downloadedFiles[entrypoint].fsPath;
-  return { entrypointPath, workNccPath: nccPath, entrypointFsDirname };
+  return { entrypointPath, entrypointFsDirname };
 }
 
-async function compile(workNccPath: string, entrypointPath: string, entrypoint: string, config: CompilerConfig) {
+async function compile(entrypointPath: string, entrypoint: string, config: CompilerConfig): Promise<Files> {
   const input = entrypointPath;
   const inputDir = dirname(input);
-  const ncc = require(join(workNccPath, 'node_modules/@zeit/ncc'));
+  const rootIncludeFiles = inputDir.split(sep).pop() || '';
-  const { code, assets } = await ncc(input);
+  const ncc = require('@zeit/ncc');
+  const { code, map, assets } = await ncc(input, { sourceMap: true, sourceMapRegister: true });
 
   if (config && config.includeFiles) {
     for (const pattern of config.includeFiles) {
@@ -75,8 +56,15 @@ async function compile(workNccPath: string, entrypointPath: string, entrypoint:
         const stream = files[assetName].toStream();
         const { mode } = files[assetName];
         const { data } = await FileBlob.fromStream({ stream });
+        let fullPath = join(rootIncludeFiles, assetName);
 
-        assets[assetName] = {
+        // if asset contain directory
+        // no need to use `rootIncludeFiles`
+        if (assetName.includes(sep)) {
+          fullPath = assetName
+        }
+
+        assets[fullPath] = {
           'source': data,
           'permissions': mode
         };
@@ -84,15 +72,15 @@ async function compile(workNccPath: string, entrypointPath: string, entrypoint:
     }
   }
 
-  const preparedFiles = {};
+  const preparedFiles: Files = {};
-  const blob = new FileBlob({ data: code });
   // move all user code to 'user' subdirectory
-  preparedFiles[join('user', entrypoint)] = blob;
+  preparedFiles[entrypoint] = new FileBlob({ data: code });
+  preparedFiles[`${entrypoint.replace('.ts', '.js')}.map`] = new FileBlob({ data: map });
   // 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;
@@ -105,7 +93,6 @@ export const config = {
 export async function build({ files, entrypoint, workPath, config }: BuildOptions) {
   const {
     entrypointPath,
-    workNccPath,
     entrypointFsDirname
   } = await downloadInstallAndBundle(
     { files, entrypoint, workPath, npmArguments: ['--prefer-offline'] }
@@ -115,15 +102,14 @@ export async function build({ files, entrypoint, workPath, config }: BuildOption
   await runPackageJsonScript(entrypointFsDirname, 'now-build');
 
   console.log('compiling entrypoint with ncc...');
-  const preparedFiles = await compile(workNccPath, entrypointPath, entrypoint, config);
+  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("./${entrypoint}");`,
-      `listener = require("./${join('user', entrypoint)}");`,
       'if (listener.default) listener = listener.default;'
     ].join(' ')
   );
@@ -142,16 +128,10 @@ export async function build({ files, entrypoint, workPath, config }: BuildOption
   return { [entrypoint]: lambda };
 }
 
-export async function prepareCache({ files, entrypoint, workPath, cachePath }: PrepareCacheOptions) {
+export async function prepareCache({ workPath }: PrepareCacheOptions) {
-  await remove(workPath);
-  await downloadInstallAndBundle({ files, entrypoint, workPath: cachePath });
-
   return {
-    ...(await glob('user/node_modules/**', cachePath)),
+    ...(await glob('node_modules/**', workPath)),
-    ...(await glob('user/package-lock.json', cachePath)),
+    ...(await glob('package-lock.json', workPath)),
-    ...(await glob('user/yarn.lock', cachePath)),
+    ...(await glob('yarn.lock', workPath))
-    ...(await glob('ncc/node_modules/**', cachePath)),
-    ...(await glob('ncc/package-lock.json', cachePath)),
-    ...(await glob('ncc/yarn.lock', cachePath))
   };
 }

packages/now-node/src/launcher.ts

@@ -4,7 +4,7 @@ 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 {
@@ -15,7 +15,8 @@ try {
     console.error('Did you forget to add it to "dependencies" in `package.json`?');
     process.exit(1);
   } else {
-    throw err;
+    console.error(err);
+    process.exit(1);
   }
 }
 

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/now.json

@@ -9,12 +9,25 @@
           "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/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/13-stack-trace/index.js

@@ -0,0 +1,10 @@
+module.exports = (req, res) => {
+  try {
+    if (req) {
+      throw new Error(`Should throw ${process.env.RANDOMNESS_ENV_VAR}`);
+    }
+    res.end(`Should not print ${process.env.RANDOMNESS_ENV_VAR}`);
+  } catch (error) {
+    res.end(error.stack);
+  }
+};

packages/now-node/test/fixtures/13-stack-trace/now.json

@@ -0,0 +1,12 @@
+{
+  "version": 2,
+  "builds": [
+    { "src": "index.js", "use": "@now/node" }
+  ],
+  "probes": [
+    {
+      "path": "/",
+      "mustContain": "index.js:4"
+    }
+  ]
+}

packages/now-node/test/fixtures/14-stack-trace-ts/index.ts

@@ -0,0 +1,10 @@
+export default function handler (req: any, res: any) {
+  try {
+    if (req) {
+      throw new Error(`Should throw`);
+    }
+    res.end(`Should not print`);
+  } catch (error) {
+    res.end(error.stack);
+  }
+}

packages/now-node/test/fixtures/14-stack-trace-ts/now.json

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