Publish Stable

- @now/build-utils@1.2.0
 - @now/cgi@1.0.1
 - now@16.7.0
 - @now/go@1.0.1
 - @now/next@2.2.0
 - @now/node@1.3.0
 - @now/python@1.0.1
 - @now/ruby@1.0.1
 - @now/static-build@0.14.0

.circleci/config.yml

@@ -340,6 +340,10 @@ jobs:
       - run:
           name: Running Unit Tests
           command: yarn test-unit --clean false
+      - persist_to_workspace:
+          root: .
+          paths:
+            - packages/now-cli/.nyc_output
 
   coverage:
     docker:
@@ -349,12 +353,6 @@ jobs:
       - checkout
       - attach_workspace:
           at: .
-      - run:
-          name: Compiling `now dev` HTML error templates
-          command: node packages/now-cli/scripts/compile-templates.js
-      - run:
-          name: Run unit tests
-          command: yarn workspace now run test-unit
       - run:
           name: Run coverage report
           command: yarn workspace now run coverage

DEVELOPING_A_RUNTIME.md

@@ -6,7 +6,7 @@ A Runtime is an npm module that exposes a `build` function and optionally an `an
 Official Runtimes are published to [npmjs.com](https://npmjs.com) as a package and referenced in the `use` property of the `now.json` configuration file.
 However, the `use` property will work with any [npm install argument](https://docs.npmjs.com/cli/install) such as a git repo url which is useful for testing your Runtime.
 
-See the [Runtimes Documentation](https://zeit.co/docs/v2/advanced/runtimes) to view example usage.
+See the [Runtimes Documentation](https://zeit.co/docs/runtimes) to view example usage.
 
 ## Runtime Exports
 

packages/now-build-utils/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@now/build-utils",
-  "version": "1.1.2-canary.0",
+  "version": "1.2.0",
   "license": "MIT",
   "main": "./dist/index.js",
   "types": "./dist/index.d.js",
@@ -35,7 +35,6 @@
     "boxen": "4.2.0",
     "cross-spawn": "6.0.5",
     "end-of-stream": "1.4.1",
-    "execa": "^1.0.0",
     "fs-extra": "7.0.0",
     "glob": "7.1.3",
     "into-stream": "5.0.0",

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

@@ -1,6 +1,12 @@
 import minimatch from 'minimatch';
 import { valid as validSemver } from 'semver';
-import { PackageJson, Builder, Config, BuilderFunctions } from './types';
+import {
+  Builder,
+  Config,
+  BuilderFunctions,
+  DetectorResult,
+  DetectorOutput,
+} from './types';
 
 interface ErrorResponse {
   code: string;
@@ -12,26 +18,6 @@ interface Options {
   functions?: BuilderFunctions;
 }
 
-const src = 'package.json';
-const config: Config = { zeroConfig: true };
-
-const MISSING_BUILD_SCRIPT_ERROR: ErrorResponse = {
-  code: 'missing_build_script',
-  message:
-    'Your `package.json` file is missing a `build` property inside the `scripts` property.' +
-    '\nMore details: https://zeit.co/docs/v2/platform/frequently-asked-questions#missing-build-script',
-};
-
-// Static builders are special cased in `@now/static-build`
-function getBuilders({ tag }: Options = {}): Map<string, Builder> {
-  const withTag = tag ? `@${tag}` : '';
-  const config = { zeroConfig: true };
-
-  return new Map<string, Builder>([
-    ['next', { src, use: `@now/next${withTag}`, config }],
-  ]);
-}
-
 // Must be a function to ensure that the returned
 // object won't be a reference
 function getApiBuilders({ tag }: Pick<Options, 'tag'> = {}): Builder[] {
@@ -47,13 +33,8 @@ function getApiBuilders({ tag }: Pick<Options, 'tag'> = {}): Builder[] {
   ];
 }
 
-function hasPublicDirectory(files: string[]) {
-  return files.some(name => name.startsWith('public/'));
-}
-
-function hasBuildScript(pkg: PackageJson | undefined) {
-  const { scripts = {} } = pkg || {};
-  return Boolean(scripts && scripts['build']);
+function hasDirectory(fileName: string, files: string[]) {
+  return files.some(name => name.startsWith(`${fileName}/`));
 }
 
 function getApiFunctionBuilder(
@@ -91,39 +72,49 @@ function getApiFunctionBuilder(
   return use ? { use, src, config } : prevBuilder;
 }
 
-async function detectFrontBuilder(
-  pkg: PackageJson,
+function detectFrontBuilder(
+  detectorResult: Partial<DetectorOutput>,
   builders: Builder[],
   options: Options
-): Promise<Builder> {
+): Builder {
   const { tag } = options;
   const withTag = tag ? `@${tag}` : '';
-  for (const [dependency, builder] of getBuilders(options)) {
-    const deps = Object.assign({}, pkg.dependencies, pkg.devDependencies);
 
-    // Return the builder when a dependency matches
-    if (deps[dependency]) {
-      if (options.functions) {
-        Object.entries(options.functions).forEach(([key, func]) => {
-          // When the builder is not used yet we'll use it for the frontend
-          if (
-            builders.every(
-              b => !(b.config && b.config.functions && b.config.functions[key])
-            )
-          ) {
-            if (!builder.config) builder.config = {};
-            if (!builder.config.functions) builder.config.functions = {};
-            builder.config.functions[key] = { ...func };
-          }
-        });
-      }
+  const { framework, buildCommand, outputDirectory } = detectorResult;
 
-      return builder;
-    }
+  const frameworkSlug = framework ? framework.slug : null;
+
+  const config: Config = {
+    zeroConfig: true,
+  };
+
+  if (buildCommand) {
+    config.buildCommand = buildCommand;
   }
 
-  // By default we'll choose the `static-build` builder
-  return { src, use: `@now/static-build${withTag}`, config };
+  if (outputDirectory) {
+    config.outputDirectory = outputDirectory;
+  }
+
+  // All unused functions will be used for the frontend
+  if (options.functions) {
+    Object.entries(options.functions).forEach(([key, func]) => {
+      if (
+        builders.every(
+          b => !(b.config && b.config.functions && b.config.functions[key])
+        )
+      ) {
+        config.functions = config.functions || {};
+        config.functions[key] = { ...func };
+      }
+    });
+  }
+
+  if (frameworkSlug === 'next') {
+    return { src: 'package.json', use: `@now/next${withTag}`, config };
+  }
+
+  return { src: 'package.json', use: `@now/static-build${withTag}`, config };
 }
 
 // Files that match a specific pattern will get ignored
@@ -139,10 +130,6 @@ export function getIgnoreApiFilter(optionsOrBuilders: Options | Builder[]) {
   }
 
   return (file: string) => {
-    if (!file.startsWith('api/')) {
-      return false;
-    }
-
     if (file.includes('/.')) {
       return false;
     }
@@ -169,10 +156,7 @@ export function sortFiles(fileA: string, fileB: string) {
   return fileA.localeCompare(fileB);
 }
 
-async function detectApiBuilders(
-  files: string[],
-  options: Options
-): Promise<Builder[]> {
+function detectApiBuilders(files: string[], options: Options): Builder[] {
   const builds = files
     .sort(sortFiles)
     .filter(getIgnoreApiFilter(options))
@@ -188,10 +172,10 @@ async function detectApiBuilders(
 
 // When a package has files that conflict with `/api` routes
 // e.g. Next.js pages/api we'll check it here and return an error.
-async function checkConflictingFiles(
+function checkConflictingFiles(
   files: string[],
   builders: Builder[]
-): Promise<ErrorResponse | null> {
+): ErrorResponse | null {
   // For Next.js
   if (builders.some(b => b.use.startsWith('@now/next'))) {
     const hasApiPages = files.some(file => file.startsWith('pages/api/'));
@@ -211,10 +195,10 @@ async function checkConflictingFiles(
 
 // When e.g. Next.js receives a `functions` property it has to make sure,
 // that it can handle those files, otherwise there are unused functions.
-async function checkUnusedFunctionsOnFrontendBuilder(
+function checkUnusedFunctionsOnFrontendBuilder(
   files: string[],
   builder: Builder
-): Promise<ErrorResponse | null> {
+): ErrorResponse | null {
   const { config: { functions = undefined } = {} } = builder;
 
   if (!functions) return null;
@@ -231,7 +215,9 @@ async function checkUnusedFunctionsOnFrontendBuilder(
       ) {
         return {
           code: 'unused_function',
-          message: `The function for ${matchedFile} can't be handled by any builder`,
+          message:
+            `The function for "${matchedFile}" can't be handled by any runtime. ` +
+            `Please provide one with the "runtime" option.`,
         };
       }
     }
@@ -241,8 +227,6 @@ async function checkUnusedFunctionsOnFrontendBuilder(
 }
 
 function validateFunctions(files: string[], { functions = {} }: Options) {
-  const apiBuilders = getApiBuilders();
-
   for (const [path, func] of Object.entries(functions)) {
     if (path.length > 256) {
       return {
@@ -312,15 +296,6 @@ function validateFunctions(files: string[], { functions = {} }: Options) {
             'Function Runtimes must have a valid version, for example `now-php@1.0.0`.',
         };
       }
-
-      if (
-        apiBuilders.some(b => func.runtime && func.runtime.startsWith(b.use))
-      ) {
-        return {
-          code: 'invalid_function_runtime',
-          message: `The function Runtime ${func.runtime} is not a Community Runtime and must not be specified.`,
-        };
-      }
     }
 
     if (func.includeFiles !== undefined) {
@@ -349,7 +324,7 @@ function validateFunctions(files: string[], { functions = {} }: Options) {
 // to determine what builders to use
 export async function detectBuilders(
   files: string[],
-  pkg?: PackageJson | undefined | null,
+  detectorResult: Partial<DetectorResult> | null = null,
   options: Options = {}
 ): Promise<{
   builders: Builder[] | null;
@@ -370,19 +345,23 @@ export async function detectBuilders(
   }
 
   // Detect all builders for the `api` directory before anything else
-  const builders = await detectApiBuilders(files, options);
+  const builders = detectApiBuilders(files, options);
 
-  if (pkg && hasBuildScript(pkg)) {
-    const frontendBuilder = await detectFrontBuilder(pkg, builders, options);
+  if (detectorResult && detectorResult.buildCommand) {
+    const frontendBuilder = detectFrontBuilder(
+      detectorResult,
+      builders,
+      options
+    );
     builders.push(frontendBuilder);
 
-    const conflictError = await checkConflictingFiles(files, builders);
+    const conflictError = checkConflictingFiles(files, builders);
 
     if (conflictError) {
       warnings.push(conflictError);
     }
 
-    const unusedFunctionError = await checkUnusedFunctionsOnFrontendBuilder(
+    const unusedFunctionError = checkUnusedFunctionsOnFrontendBuilder(
       files,
       frontendBuilder
     );
@@ -394,34 +373,35 @@ export async function detectBuilders(
         warnings,
       };
     }
-  } else {
-    if (pkg && builders.length === 0) {
-      // We only show this error when there are no api builders
-      // since the dependencies of the pkg could be used for those
-      errors.push(MISSING_BUILD_SCRIPT_ERROR);
-      return { errors, warnings, builders: null };
-    }
-
-    // We allow a `public` directory
-    // when there are no build steps
-    if (hasPublicDirectory(files)) {
-      builders.push({
-        use: '@now/static',
-        src: 'public/**/*',
-        config,
-      });
-    } else if (
-      builders.length > 0 &&
-      files.some(f => !f.startsWith('api/') && f !== 'package.json')
-    ) {
-      // Everything besides the api directory
-      // and package.json can be served as static files
-      builders.push({
-        use: '@now/static',
-        src: '!{api/**,package.json}',
-        config,
-      });
-    }
+  } else if (
+    detectorResult &&
+    detectorResult.outputDirectory &&
+    hasDirectory(detectorResult.outputDirectory, files)
+  ) {
+    builders.push({
+      use: '@now/static',
+      src: [...detectorResult.outputDirectory.split('/'), '**', '*']
+        .filter(Boolean)
+        .join('/'),
+      config: { zeroConfig: true },
+    });
+  } else if (hasDirectory('public', files)) {
+    builders.push({
+      use: '@now/static',
+      src: 'public/**/*',
+      config: { zeroConfig: true },
+    });
+  } else if (
+    builders.length > 0 &&
+    files.some(f => !f.startsWith('api/') && f !== 'package.json')
+  ) {
+    // Everything besides the api directory
+    // and package.json can be served as static files
+    builders.push({
+      use: '@now/static',
+      src: '!{api/**,package.json}',
+      config: { zeroConfig: true },
+    });
   }
 
   return {

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

@@ -217,7 +217,10 @@ async function detectApiRoutes(
   for (const file of sortedFiles) {
     // We only consider every file in the api directory
     // as we will strip extensions as well as resolving "[segments]"
-    if (!file.startsWith('api/')) {
+    if (
+      !file.startsWith('api/') &&
+      !builders.some(b => b.src === file && b.config!.functions)
+    ) {
       continue;
     }
 
@@ -271,14 +274,16 @@ async function detectApiRoutes(
   return { defaultRoutes, error: null };
 }
 
-function hasPublicBuilder(builders: Builder[]): boolean {
-  return builders.some(
+function getPublicBuilder(builders: Builder[]): Builder | null {
+  const builder = builders.find(
     builder =>
       builder.use === '@now/static' &&
-      builder.src === 'public/**/*' &&
+      /^.*\/\*\*\/\*$/.test(builder.src) &&
       builder.config &&
       builder.config.zeroConfig === true
   );
+
+  return builder || null;
 }
 
 export async function detectRoutes(
@@ -286,11 +291,14 @@ export async function detectRoutes(
   builders: Builder[]
 ): Promise<RoutesResult> {
   const routesResult = await detectApiRoutes(files, builders);
+  const publicBuilder = getPublicBuilder(builders);
+
+  if (routesResult.defaultRoutes && publicBuilder) {
+    const directory = publicBuilder.src.replace('/**/*', '');
 
-  if (routesResult.defaultRoutes && hasPublicBuilder(builders)) {
     routesResult.defaultRoutes.push({
       src: '/(.*)',
-      dest: '/public/$1',
+      dest: `/${directory}/$1`,
     });
   }
 

packages/now-build-utils/src/detectors/angular.ts

@@ -1,14 +1,18 @@
 import { DetectorParameters, DetectorResult } from '../types';
 
 export default async function detectAngular({
-  fs: { hasDependency },
+  fs: { getPackageJsonBuildCommand, getDependencyVersion },
 }: DetectorParameters): Promise<DetectorResult> {
-  const hasAngular = await hasDependency('@angular/cli');
-  if (!hasAngular) return false;
+  const version = await getDependencyVersion('@angular/cli');
+  if (!version) return false;
   return {
-    buildCommand: 'ng build',
-    buildDirectory: 'dist',
+    buildCommand: (await getPackageJsonBuildCommand()) || 'ng build',
+    outputDirectory: 'dist',
     devCommand: 'ng serve --port $PORT',
+    framework: {
+      slug: '@angular/cli',
+      version,
+    },
     minNodeRange: '10.x',
     routes: [
       {

packages/now-build-utils/src/detectors/brunch.ts

@@ -1,17 +1,22 @@
 import { DetectorParameters, DetectorResult } from '../types';
 
 export default async function detectBrunch({
-  fs: { hasDependency, exists },
+  fs: { exists, getPackageJsonBuildCommand, getDependencyVersion },
 }: DetectorParameters): Promise<DetectorResult> {
-  const hasBrunch = await hasDependency('brunch');
-  if (!hasBrunch) return false;
+  const version = await getDependencyVersion('brunch');
+  if (!version) return false;
 
   const hasConfig = await exists('brunch-config.js');
   if (!hasConfig) return false;
 
   return {
-    buildCommand: 'brunch build --production',
-    buildDirectory: 'public',
+    buildCommand:
+      (await getPackageJsonBuildCommand()) || 'brunch build --production',
+    outputDirectory: 'public',
     devCommand: 'brunch watch --server --port $PORT',
+    framework: {
+      slug: 'brunch',
+      version,
+    },
   };
 }

packages/now-build-utils/src/detectors/create-react-app-ejected.ts

@@ -1,16 +1,20 @@
 import { DetectorParameters, DetectorResult } from '../types';
 
 export default async function detectCreateReactAppEjected({
-  fs: { hasDependency },
+  fs: { getDependencyVersion },
 }: DetectorParameters): Promise<DetectorResult> {
-  const hasReactDevUtils = await hasDependency('react-dev-utils');
-  if (!hasReactDevUtils) {
+  const version = await getDependencyVersion('react-dev-utils');
+  if (!version) {
     return false;
   }
   return {
     buildCommand: 'node scripts/build.js',
-    buildDirectory: 'build',
+    outputDirectory: 'build',
     devCommand: 'node scripts/start.js',
+    framework: {
+      slug: 'react-dev-utils',
+      version,
+    },
     devVariables: { BROWSER: 'none' },
     routes: [
       {

packages/now-build-utils/src/detectors/create-react-app.ts

@@ -1,17 +1,21 @@
 import { DetectorParameters, DetectorResult } from '../types';
 
 export default async function detectCreateReactApp({
-  fs: { hasDependency },
+  fs: { getPackageJsonBuildCommand, getDependencyVersion },
 }: DetectorParameters): Promise<DetectorResult> {
-  const hasReactScripts = await hasDependency('react-scripts');
-  if (!hasReactScripts) {
+  const version = await getDependencyVersion('react-scripts');
+  if (!version) {
     return false;
   }
   return {
-    buildCommand: 'react-scripts build',
-    buildDirectory: 'build',
+    buildCommand: (await getPackageJsonBuildCommand()) || 'react-scripts build',
+    outputDirectory: 'build',
     devCommand: 'react-scripts start',
     devVariables: { BROWSER: 'none' },
+    framework: {
+      slug: 'react-scripts',
+      version,
+    },
     routes: [
       {
         src: '/static/(.*)',

packages/now-build-utils/src/detectors/docusaurus.ts

@@ -1,13 +1,17 @@
 import { DetectorParameters, DetectorResult } from '../types';
 
 export default async function detectDocusaurus({
-  fs: { hasDependency },
+  fs: { getPackageJsonBuildCommand, getDependencyVersion },
 }: DetectorParameters): Promise<DetectorResult> {
-  const hasDocusaurus = await hasDependency('docusaurus');
-  if (!hasDocusaurus) return false;
+  const version = await getDependencyVersion('docusaurus');
+  if (!version) return false;
   return {
-    buildCommand: 'docusaurus-build',
-    buildDirectory: 'build',
+    buildCommand: (await getPackageJsonBuildCommand()) || 'docusaurus-build',
+    outputDirectory: 'build',
     devCommand: 'docusaurus-start --port $PORT',
+    framework: {
+      slug: 'docusaurus',
+      version,
+    },
   };
 }

packages/now-build-utils/src/detectors/eleventy.ts

@@ -1,13 +1,17 @@
 import { DetectorParameters, DetectorResult } from '../types';
 
 export default async function detectEleventy({
-  fs: { hasDependency },
+  fs: { getDependencyVersion },
 }: DetectorParameters): Promise<DetectorResult> {
-  const hasEleventy = await hasDependency('@11ty/eleventy');
-  if (!hasEleventy) return false;
+  const version = await getDependencyVersion('@11ty/eleventy');
+  if (!version) return false;
   return {
     buildCommand: 'npx @11ty/eleventy',
-    buildDirectory: '_site',
+    outputDirectory: '_site',
     devCommand: 'npx @11ty/eleventy --serve --watch --port $PORT',
+    framework: {
+      slug: '@11ty/eleventy',
+      version,
+    },
   };
 }

packages/now-build-utils/src/detectors/ember.ts

@@ -1,14 +1,18 @@
 import { DetectorParameters, DetectorResult } from '../types';
 
 export default async function detectEmber({
-  fs: { hasDependency },
+  fs: { getPackageJsonBuildCommand, getDependencyVersion },
 }: DetectorParameters): Promise<DetectorResult> {
-  const hasEmber = await hasDependency('ember-cli');
-  if (!hasEmber) return false;
+  const version = await getDependencyVersion('ember-cli');
+  if (!version) return false;
   return {
-    buildCommand: 'ember build',
-    buildDirectory: 'dist',
+    buildCommand: (await getPackageJsonBuildCommand()) || 'ember build',
+    outputDirectory: 'dist',
     devCommand: 'ember serve --port $PORT',
+    framework: {
+      slug: 'ember-cli',
+      version,
+    },
     routes: [
       {
         handle: 'filesystem',

packages/now-build-utils/src/detectors/filesystem.ts

@@ -102,6 +102,31 @@ export default abstract class DetectorFilesystem {
     const { dependencies = {}, devDependencies = {} } = pkg || {};
     return name in dependencies || name in devDependencies;
   };
+
+  public isNpm = async (): Promise<boolean> => {
+    return this.exists('package-lock.json');
+  };
+
+  public getPackageJsonCommand = async (
+    name: string
+  ): Promise<string | null> => {
+    const pkg = await this.readPackageJson();
+    const { scripts = {} } = pkg || {};
+    return scripts[name] || null;
+  };
+
+  public getPackageJsonBuildCommand = async (): Promise<string | null> => {
+    const buildCommand = (await this.isNpm())
+      ? 'npm run build'
+      : 'yarn run build';
+    return (await this.getPackageJsonCommand('build')) ? buildCommand : null;
+  };
+
+  public getDependencyVersion = async (name: string): Promise<string> => {
+    const pkg = await this.readPackageJson();
+    const { dependencies = {}, devDependencies = {} } = pkg || {};
+    return dependencies[name] || devDependencies[name];
+  };
 }
 
 async function nullEnoent<T>(p: Promise<T>): Promise<T | null> {

packages/now-build-utils/src/detectors/gatsby.ts

@@ -1,16 +1,20 @@
 import { DetectorParameters, DetectorResult } from '../types';
 
 export default async function detectGatsby({
-  fs: { hasDependency },
+  fs: { getPackageJsonBuildCommand, getDependencyVersion },
 }: DetectorParameters): Promise<DetectorResult> {
-  const hasGatsby = await hasDependency('gatsby');
-  if (!hasGatsby) {
+  const version = await getDependencyVersion('gatsby');
+  if (!version) {
     return false;
   }
   return {
-    buildCommand: 'gatsby build',
-    buildDirectory: 'public',
+    buildCommand: (await getPackageJsonBuildCommand()) || 'gatsby build',
+    outputDirectory: 'public',
     devCommand: 'gatsby develop -p $PORT',
+    framework: {
+      slug: 'gatsby',
+      version,
+    },
     cachePattern: '.cache/**',
   };
 }

packages/now-build-utils/src/detectors/generic-node-project.ts

@@ -0,0 +1,21 @@
+import { DetectorParameters, DetectorResult } from '../types';
+
+export default async function detectGenericNodeProject({
+  fs: { isNpm, getPackageJsonCommand },
+}: DetectorParameters): Promise<DetectorResult> {
+  const useNpm = await isNpm();
+  const devCommand = await getPackageJsonCommand('dev');
+  const buildCommand = await getPackageJsonCommand('build');
+
+  if (!buildCommand) {
+    return false;
+  }
+
+  return {
+    buildCommand: `${useNpm ? 'npm' : 'yarn'} run build`,
+    devCommand: `${useNpm ? 'npm' : 'yarn'} run ${
+      devCommand ? 'dev' : 'build'
+    }`,
+    outputDirectory: 'public',
+  };
+}

packages/now-build-utils/src/detectors/gridsome.ts

@@ -1,15 +1,19 @@
 import { DetectorParameters, DetectorResult } from '../types';
 
 export default async function detectGridsome({
-  fs: { hasDependency },
+  fs: { getPackageJsonBuildCommand, getDependencyVersion },
 }: DetectorParameters): Promise<DetectorResult> {
-  const hasGridsome = await hasDependency('gridsome');
-  if (!hasGridsome) {
+  const version = await getDependencyVersion('gridsome');
+  if (!version) {
     return false;
   }
   return {
-    buildCommand: 'gridsome build',
-    buildDirectory: 'dist',
+    buildCommand: (await getPackageJsonBuildCommand()) || 'gridsome build',
+    outputDirectory: 'dist',
     devCommand: 'gridsome develop -p $PORT',
+    framework: {
+      slug: 'gridsom',
+      version,
+    },
   };
 }

packages/now-build-utils/src/detectors/hexo.ts

@@ -1,13 +1,17 @@
 import { DetectorParameters, DetectorResult } from '../types';
 
 export default async function detectHexo({
-  fs: { hasDependency },
+  fs: { getPackageJsonBuildCommand, getDependencyVersion },
 }: DetectorParameters): Promise<DetectorResult> {
-  const hasHexo = await hasDependency('hexo');
-  if (!hasHexo) return false;
+  const version = await getDependencyVersion('hexo');
+  if (!version) return false;
   return {
-    buildCommand: 'hexo generate',
-    buildDirectory: 'public',
+    buildCommand: (await getPackageJsonBuildCommand()) || 'hexo generate',
+    outputDirectory: 'public',
     devCommand: 'hexo server --port $PORT',
+    framework: {
+      slug: 'hexo',
+      version,
+    },
   };
 }

packages/now-build-utils/src/detectors/hugo.ts

@@ -20,7 +20,11 @@ export default async function detectHugo({
   }
   return {
     buildCommand: 'hugo',
-    buildDirectory: config.publishDir || 'public',
+    outputDirectory: config.publishDir || 'public',
     devCommand: 'hugo server -D -w -p $PORT',
+    framework: {
+      slug: 'hugo',
+      version: 'latest',
+    },
   };
 }

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

@@ -9,6 +9,7 @@ import docusaurus from './docusaurus';
 import eleventy from './eleventy';
 import ember from './ember';
 import gatsby from './gatsby';
+import genericNodeProject from './generic-node-project';
 import gridsome from './gridsome';
 import hexo from './hexo';
 import hugo from './hugo';
@@ -81,5 +82,8 @@ export async function detectDefaults(
     d = params.detectors || detectors;
     result = await firstTruthy(d.map(detector => detector(params)));
   }
+  if (!result) {
+    result = await genericNodeProject(params);
+  }
   return result;
 }

packages/now-build-utils/src/detectors/jekyll.ts

@@ -16,7 +16,11 @@ export default async function detectJekyll({
   }
   return {
     buildCommand: 'jekyll build',
-    buildDirectory: config.destination || '_site',
+    outputDirectory: config.destination || '_site',
     devCommand: 'bundle exec jekyll serve --watch --port $PORT',
+    framework: {
+      slug: 'jekyll',
+      version: 'latest',
+    },
   };
 }

packages/now-build-utils/src/detectors/middleman.ts

@@ -8,7 +8,11 @@ export default async function detectMiddleman({
 
   return {
     buildCommand: 'bundle exec middleman build',
-    buildDirectory: 'build',
+    outputDirectory: 'build',
     devCommand: 'bundle exec middleman server -p $PORT',
+    framework: {
+      slug: 'middleman',
+      version: 'latest',
+    },
   };
 }

packages/now-build-utils/src/detectors/next.ts

@@ -1,13 +1,17 @@
 import { DetectorParameters, DetectorResult } from '../types';
 
 export default async function detectNext({
-  fs: { hasDependency },
+  fs: { getPackageJsonBuildCommand, getDependencyVersion },
 }: DetectorParameters): Promise<DetectorResult> {
-  const hasNext = await hasDependency('next');
-  if (!hasNext) return false;
+  const version = await getDependencyVersion('next');
+  if (!version) return false;
   return {
-    buildCommand: 'next build',
-    buildDirectory: 'build',
+    buildCommand: (await getPackageJsonBuildCommand()) || 'next build',
+    outputDirectory: '.next/static',
     devCommand: 'next -p $PORT',
+    framework: {
+      slug: 'next',
+      version,
+    },
   };
 }

packages/now-build-utils/src/detectors/polymer.ts

@@ -1,14 +1,18 @@
 import { DetectorParameters, DetectorResult } from '../types';
 
 export default async function detectPolymer({
-  fs: { hasDependency },
+  fs: { getPackageJsonBuildCommand, getDependencyVersion },
 }: DetectorParameters): Promise<DetectorResult> {
-  const hasPolymer = await hasDependency('polymer-cli');
-  if (!hasPolymer) return false;
+  const version = await getDependencyVersion('polymer-cli');
+  if (!version) return false;
   return {
-    buildCommand: 'polymer build',
-    buildDirectory: 'build',
+    buildCommand: (await getPackageJsonBuildCommand()) || 'polymer build',
+    outputDirectory: 'build',
     devCommand: 'polymer serve --port $PORT',
+    framework: {
+      slug: 'polymer-cli',
+      version,
+    },
     routes: [
       {
         handle: 'filesystem',

packages/now-build-utils/src/detectors/preact.ts

@@ -1,14 +1,18 @@
 import { DetectorParameters, DetectorResult } from '../types';
 
 export default async function detectPreact({
-  fs: { hasDependency },
+  fs: { getPackageJsonBuildCommand, getDependencyVersion },
 }: DetectorParameters): Promise<DetectorResult> {
-  const hasPreact = await hasDependency('preact-cli');
-  if (!hasPreact) return false;
+  const version = await getDependencyVersion('preact-cli');
+  if (!version) return false;
   return {
-    buildCommand: 'preact build',
-    buildDirectory: 'build',
+    buildCommand: (await getPackageJsonBuildCommand()) || 'preact build',
+    outputDirectory: 'build',
     devCommand: 'preact watch --port $PORT',
+    framework: {
+      slug: 'preact-cli',
+      version,
+    },
     routes: [
       {
         handle: 'filesystem',

packages/now-build-utils/src/detectors/saber.ts

@@ -1,13 +1,13 @@
 import { DetectorParameters, DetectorResult } from '../types';
 
 export default async function detectSaber({
-  fs: { hasDependency },
+  fs: { getPackageJsonBuildCommand, getDependencyVersion },
 }: DetectorParameters): Promise<DetectorResult> {
-  const hasSaber = await hasDependency('saber');
-  if (!hasSaber) return false;
+  const version = await getDependencyVersion('saber');
+  if (!version) return false;
   return {
-    buildCommand: 'saber build',
-    buildDirectory: 'public',
+    buildCommand: (await getPackageJsonBuildCommand()) || 'saber build',
+    outputDirectory: 'public',
     devCommand: 'saber --port $PORT',
     routes: [
       {
@@ -23,5 +23,9 @@ export default async function detectSaber({
         dest: '404.html',
       },
     ],
+    framework: {
+      slug: 'saber',
+      version,
+    },
   };
 }

packages/now-build-utils/src/detectors/sapper.ts

@@ -1,13 +1,17 @@
 import { DetectorParameters, DetectorResult } from '../types';
 
 export default async function detectSapper({
-  fs: { hasDependency },
+  fs: { getPackageJsonBuildCommand, getDependencyVersion },
 }: DetectorParameters): Promise<DetectorResult> {
-  const hasSapper = await hasDependency('sapper');
-  if (!hasSapper) return false;
+  const version = await getDependencyVersion('sapper');
+  if (!version) return false;
   return {
-    buildCommand: 'sapper export',
-    buildDirectory: '__sapper__/export',
+    buildCommand: (await getPackageJsonBuildCommand()) || 'sapper export',
+    outputDirectory: '__sapper__/export',
     devCommand: 'sapper dev --port $PORT',
+    framework: {
+      slug: 'sapper',
+      version,
+    },
   };
 }

packages/now-build-utils/src/detectors/stencil.ts

@@ -1,14 +1,18 @@
 import { DetectorParameters, DetectorResult } from '../types';
 
 export default async function detectStencil({
-  fs: { hasDependency },
+  fs: { getPackageJsonBuildCommand, getDependencyVersion },
 }: DetectorParameters): Promise<DetectorResult> {
-  const hasStencil = await hasDependency('@stencil/core');
-  if (!hasStencil) return false;
+  const version = await getDependencyVersion('@stencil/core');
+  if (!version) return false;
   return {
-    buildCommand: 'stencil build',
-    buildDirectory: 'www',
+    buildCommand: (await getPackageJsonBuildCommand()) || 'stencil build',
+    outputDirectory: 'www',
     devCommand: 'stencil build --dev --watch --serve --port $PORT',
+    framework: {
+      slug: '@stencil/core',
+      version,
+    },
     routes: [
       {
         handle: 'filesystem',

packages/now-build-utils/src/detectors/svelte.ts

@@ -1,14 +1,18 @@
 import { DetectorParameters, DetectorResult } from '../types';
 
 export default async function detectSvelte({
-  fs: { hasDependency },
+  fs: { getPackageJsonBuildCommand, getDependencyVersion },
 }: DetectorParameters): Promise<DetectorResult> {
-  const hasSvelte = await hasDependency('sirv-cli');
-  if (!hasSvelte) return false;
+  const version = await getDependencyVersion('sirv-cli');
+  if (!version) return false;
   return {
-    buildCommand: 'rollup -c',
-    buildDirectory: 'public',
+    buildCommand: (await getPackageJsonBuildCommand()) || 'rollup -c',
+    outputDirectory: 'public',
     devCommand: 'sirv public --single --dev --port $PORT',
+    framework: {
+      slug: 'sirv-cli',
+      version,
+    },
     routes: [
       {
         handle: 'filesystem',

packages/now-build-utils/src/detectors/umi.ts

@@ -1,14 +1,18 @@
 import { DetectorParameters, DetectorResult } from '../types';
 
 export default async function detectUmiJS({
-  fs: { hasDependency },
+  fs: { getPackageJsonBuildCommand, getDependencyVersion },
 }: DetectorParameters): Promise<DetectorResult> {
-  const hasUmi = await hasDependency('umi');
-  if (!hasUmi) return false;
+  const version = await getDependencyVersion('umi');
+  if (!version) return false;
   return {
-    buildCommand: 'umi build',
-    buildDirectory: 'dist',
+    buildCommand: (await getPackageJsonBuildCommand()) || 'umi build',
+    outputDirectory: 'dist',
     devCommand: 'umi dev --port $PORT',
+    framework: {
+      slug: 'umi',
+      version,
+    },
     routes: [
       {
         handle: 'filesystem',

packages/now-build-utils/src/detectors/vue.ts

@@ -1,14 +1,19 @@
 import { DetectorParameters, DetectorResult } from '../types';
 
 export default async function detectVue({
-  fs: { hasDependency },
+  fs: { getPackageJsonBuildCommand, getDependencyVersion },
 }: DetectorParameters): Promise<DetectorResult> {
-  const hasVue = await hasDependency('@vue/cli-service');
-  if (!hasVue) return false;
+  const version = await getDependencyVersion('@vue/cli-service');
+  if (!version) return false;
   return {
-    buildCommand: 'vue-cli-service build',
-    buildDirectory: 'dist',
+    buildCommand:
+      (await getPackageJsonBuildCommand()) || 'vue-cli-service build',
+    outputDirectory: 'dist',
     devCommand: 'vue-cli-service serve --port $PORT',
+    framework: {
+      slug: '@vue/cli-service',
+      version,
+    },
     routes: [
       {
         src: '^/[^/]*\\.(js|txt|ico|json)',

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

@@ -70,12 +70,17 @@ export async function getSupportedNodeVersion(
     const validRanges = supportedOptions
       .filter(o => !o.discontinueDate)
       .map(o => o.range);
+    const prevTerm = process.env.TERM;
+    if (!prevTerm) {
+      // workaround for https://github.com/sindresorhus/term-size/issues/13
+      process.env.TERM = 'xterm';
+    }
     console.warn(
       boxen(
-        'WARNING' +
+        'NOTICE' +
           '\n' +
-          `\nNode.js ${range} will be discontinued on ${d}.` +
-          `\nDeployments created on or after ${d} will fail to build.` +
+          `\nNode.js version ${range} has reached end-of-life.` +
+          `\nAs a result, deployments created on or after ${d} will fail to build.` +
           '\nPlease use one of the following supported `engines` in `package.json`: ' +
           JSON.stringify(validRanges) +
           '\nThis change is the result of a decision made by an upstream infrastructure provider (AWS).' +
@@ -83,6 +88,7 @@ export async function getSupportedNodeVersion(
         { padding: 1 }
       )
     );
+    process.env.TERM = prevTerm;
   }
 
   return selection;

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

@@ -57,4 +57,5 @@ export {
 };
 
 export { detectDefaults } from './detectors';
+export * from './schemas';
 export * from './types';

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

@@ -0,0 +1,61 @@
+export const functionsSchema = {
+  type: 'object',
+  minProperties: 1,
+  maxProperties: 50,
+  additionalProperties: false,
+  patternProperties: {
+    '^.{1,256}$': {
+      type: 'object',
+      additionalProperties: false,
+      properties: {
+        runtime: {
+          type: 'string',
+          maxLength: 256,
+        },
+        memory: {
+          // Number between 128 and 3008 in steps of 64
+          enum: Object.keys(Array.from({ length: 50 }))
+            .slice(2, 48)
+            .map(x => Number(x) * 64),
+        },
+        maxDuration: {
+          type: 'number',
+          minimum: 1,
+          maximum: 900,
+        },
+        includeFiles: {
+          type: 'string',
+          maxLength: 256,
+        },
+        excludeFiles: {
+          type: 'string',
+          maxLength: 256,
+        },
+      },
+    },
+  },
+};
+
+export const buildsSchema = {
+  type: 'array',
+  minItems: 0,
+  maxItems: 128,
+  items: {
+    type: 'object',
+    additionalProperties: false,
+    required: ['use'],
+    properties: {
+      src: {
+        type: 'string',
+        minLength: 1,
+        maxLength: 4096,
+      },
+      use: {
+        type: 'string',
+        minLength: 3,
+        maxLength: 256,
+      },
+      config: { type: 'object' },
+    },
+  },
+};

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

@@ -354,7 +354,7 @@ export interface DetectorParameters {
 
 export interface DetectorOutput {
   buildCommand: string;
-  buildDirectory: string;
+  outputDirectory: string;
   buildVariables?: Env;
   devCommand?: string;
   devVariables?: Env;
@@ -366,6 +366,10 @@ export interface DetectorOutput {
   redirects?: NowRedirect[];
   headers?: NowHeader[];
   trailingSlash?: boolean;
+  framework?: {
+    slug: string;
+    version: string;
+  };
 }
 
 export type DetectorResult = DetectorOutput | false;

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

@@ -4,13 +4,34 @@ const {
   packAndDeploy,
   testDeployment,
 } = require('../../../test/lib/deployment/test-deployment');
-const { glob, detectBuilders, detectRoutes } = require('../');
+const {
+  glob,
+  detectBuilders,
+  detectRoutes,
+  DetectorFilesystem,
+  detectDefaults,
+} = require('../');
 
 jest.setTimeout(4 * 60 * 1000);
 
 const builderUrl = '@canary';
 let buildUtilsUrl;
 
+class LocalFilesystem extends DetectorFilesystem {
+  constructor(dir) {
+    super();
+    this.dir = dir;
+  }
+
+  _exists(name) {
+    return fs.pathExists(path.join(this.dir, name));
+  }
+
+  _readFile(name) {
+    return fs.readFile(path.join(this.dir, name));
+  }
+}
+
 beforeAll(async () => {
   const buildUtilsPath = path.resolve(__dirname, '..');
   buildUtilsUrl = await packAndDeploy(buildUtilsPath);
@@ -67,7 +88,9 @@ for (const builder of buildersToTestWith) {
 
 it('Test `detectBuilders` and `detectRoutes`', async () => {
   const fixture = path.join(__dirname, 'fixtures', '01-zero-config-api');
-  const pkg = await fs.readJSON(path.join(fixture, 'package.json'));
+  const detectorResult = await detectDefaults({
+    fs: new LocalFilesystem(fixture),
+  });
   const fileList = await glob('**', fixture);
   const files = Object.keys(fileList);
 
@@ -110,7 +133,7 @@ it('Test `detectBuilders` and `detectRoutes`', async () => {
     },
   ];
 
-  const { builders } = await detectBuilders(files, pkg);
+  const { builders } = await detectBuilders(files, detectorResult);
   const { defaultRoutes } = await detectRoutes(files, builders);
 
   const nowConfig = { builds: builders, routes: defaultRoutes, probes };
@@ -128,7 +151,9 @@ it('Test `detectBuilders` and `detectRoutes`', async () => {
 
 it('Test `detectBuilders` and `detectRoutes` with `index` files', async () => {
   const fixture = path.join(__dirname, 'fixtures', '02-zero-config-api');
-  const pkg = await fs.readJSON(path.join(fixture, 'package.json'));
+  const detectorResult = await detectDefaults({
+    fs: new LocalFilesystem(fixture),
+  });
   const fileList = await glob('**', fixture);
   const files = Object.keys(fileList);
 
@@ -192,7 +217,7 @@ it('Test `detectBuilders` and `detectRoutes` with `index` files', async () => {
     },
   ];
 
-  const { builders } = await detectBuilders(files, pkg);
+  const { builders } = await detectBuilders(files, detectorResult);
   const { defaultRoutes } = await detectRoutes(files, builders);
 
   const nowConfig = { builds: builders, routes: defaultRoutes, probes };

packages/now-build-utils/test/unit.detectors.test.ts

@@ -67,8 +67,8 @@ test('detectDefaults() - angular', async () => {
   const fs = new LocalFilesystem(dir);
   const result = await detectDefaults({ fs });
   if (!result) throw new Error('Expected result');
-  assert.equal(result.buildDirectory, 'dist');
-  assert.deepEqual(result.buildCommand, 'ng build');
+  assert.equal(result.outputDirectory, 'dist');
+  assert.deepEqual(result.buildCommand, 'yarn run build');
 });
 
 test('detectDefaults() - brunch', async () => {
@@ -76,8 +76,8 @@ test('detectDefaults() - brunch', async () => {
   const fs = new LocalFilesystem(dir);
   const result = await detectDefaults({ fs });
   if (!result) throw new Error('Expected result');
-  assert.equal(result.buildDirectory, 'public');
-  assert.deepEqual(result.buildCommand, 'brunch build --production');
+  assert.equal(result.outputDirectory, 'public');
+  assert.deepEqual(result.buildCommand, 'yarn run build');
 });
 
 test('detectDefaults() - hugo', async () => {
@@ -85,7 +85,7 @@ test('detectDefaults() - hugo', async () => {
   const fs = new LocalFilesystem(dir);
   const result = await detectDefaults({ fs });
   if (!result) throw new Error('Expected result');
-  assert.equal(result.buildDirectory, 'public');
+  assert.equal(result.outputDirectory, 'public');
   assert.deepEqual(result.buildCommand, 'hugo');
 });
 
@@ -94,7 +94,7 @@ test('detectDefaults() - jekyll', async () => {
   const fs = new LocalFilesystem(dir);
   const result = await detectDefaults({ fs });
   if (!result) throw new Error('Expected result');
-  assert.equal(result.buildDirectory, '_site');
+  assert.equal(result.outputDirectory, '_site');
   assert.deepEqual(result.buildCommand, 'jekyll build');
 });
 
@@ -103,6 +103,6 @@ test('detectDefaults() - middleman', async () => {
   const fs = new LocalFilesystem(dir);
   const result = await detectDefaults({ fs });
   if (!result) throw new Error('Expected result');
-  assert.equal(result.buildDirectory, 'build');
+  assert.equal(result.outputDirectory, 'build');
   assert.deepEqual(result.buildCommand, 'bundle exec middleman build');
 });

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

@@ -1,9 +1,14 @@
 const path = require('path');
 const fs = require('fs-extra');
-const execa = require('execa');
 const assert = require('assert');
 const { createZip } = require('../dist/lambda');
-const { glob, download, detectBuilders, detectRoutes } = require('../');
+const {
+  glob,
+  download,
+  detectBuilders,
+  detectRoutes,
+  spawnAsync,
+} = require('../');
 const {
   getSupportedNodeVersion,
   defaultSelection,
@@ -39,7 +44,7 @@ it('should create zip files with symlinks properly', async () => {
   await fs.mkdirp(outDir);
 
   await fs.writeFile(outFile, await createZip(files));
-  await execa('unzip', [outFile], { cwd: outDir });
+  await spawnAsync('unzip', [outFile], { cwd: outDir });
 
   const [linkStat, aStat] = await Promise.all([
     fs.lstat(path.join(outDir, 'link.txt')),
@@ -110,42 +115,34 @@ it('should support require by path for legacy builders', () => {
 });
 
 describe('Test `detectBuilders`', () => {
-  it('package.json + no build', async () => {
-    const pkg = { dependencies: { next: '9.0.0' } };
+  it('package.json + no build command', async () => {
+    const detected = { framework: { slug: 'next', version: '9.0.0' } };
     const files = ['package.json', 'pages/index.js', 'public/index.html'];
-    const { builders, errors } = await detectBuilders(files, pkg);
-    expect(builders).toBe(null);
-    expect(errors.length).toBe(1);
+    const { builders } = await detectBuilders(files, detected);
+    expect(builders.length).toBe(1);
+    expect(builders[0].src).toBe('public/**/*');
+    expect(builders[0].use).toBe('@now/static');
   });
 
-  it('package.json + no build + next', async () => {
-    const pkg = {
-      scripts: { build: 'next build' },
-      dependencies: { next: '9.0.0' },
+  it('package.json + build command + next', async () => {
+    const detected = {
+      buildCommand: 'yarn build',
+      framework: {
+        slug: 'next',
+        version: '9.0.0',
+      },
     };
     const files = ['package.json', 'pages/index.js'];
-    const { builders, errors } = await detectBuilders(files, pkg);
+    const { builders, errors } = await detectBuilders(files, detected);
     expect(builders[0].use).toBe('@now/next');
     expect(errors).toBe(null);
   });
 
-  it('package.json + no build + next', async () => {
-    const pkg = {
-      scripts: { build: 'next build' },
-      devDependencies: { next: '9.0.0' },
-    };
-    const files = ['package.json', 'pages/index.js'];
-    const { builders, errors } = await detectBuilders(files, pkg);
-    expect(builders[0].use).toBe('@now/next');
-    expect(errors).toBe(null);
-  });
-
-  it('package.json + no build', async () => {
-    const pkg = {};
+  it('no detectors + no build command', async () => {
     const files = ['package.json'];
-    const { builders, errors } = await detectBuilders(files, pkg);
+    const { builders, errors } = await detectBuilders(files, {});
     expect(builders).toBe(null);
-    expect(errors.length).toBe(1);
+    expect(errors).toBe(null);
   });
 
   it('static file', async () => {
@@ -155,7 +152,7 @@ describe('Test `detectBuilders`', () => {
     expect(errors).toBe(null);
   });
 
-  it('no package.json + public', async () => {
+  it('no package.json + public + api', async () => {
     const files = ['api/users.js', 'public/index.html'];
     const { builders, errors } = await detectBuilders(files);
     expect(builders[1].use).toBe('@now/static');
@@ -173,7 +170,7 @@ describe('Test `detectBuilders`', () => {
     expect(errors).toBe(null);
   });
 
-  it('package.json + no build + root + api', async () => {
+  it('no package.json + no build command + root + api', async () => {
     const files = ['index.html', 'api/[endpoint].js', 'static/image.png'];
     const { builders, errors } = await detectBuilders(files);
     expect(builders[0].use).toBe('@now/node');
@@ -198,13 +195,17 @@ describe('Test `detectBuilders`', () => {
   });
 
   it('api + next + public', async () => {
-    const pkg = {
-      scripts: { build: 'next build' },
-      devDependencies: { next: '9.0.0' },
+    const detected = {
+      buildCommand: 'yarn build',
+      framework: {
+        slug: 'next',
+        version: '9.0.0',
+      },
     };
+
     const files = ['package.json', 'api/endpoint.js', 'public/index.html'];
 
-    const { builders } = await detectBuilders(files, pkg);
+    const { builders } = await detectBuilders(files, detected);
     expect(builders[0].use).toBe('@now/node');
     expect(builders[0].src).toBe('api/endpoint.js');
     expect(builders[1].use).toBe('@now/next');
@@ -213,13 +214,17 @@ describe('Test `detectBuilders`', () => {
   });
 
   it('api + next + raw static', async () => {
-    const pkg = {
-      scripts: { build: 'next build' },
-      devDependencies: { next: '9.0.0' },
+    const detected = {
+      buildCommand: 'yarn build',
+      framework: {
+        slug: 'next',
+        version: '9.0.0',
+      },
     };
+
     const files = ['package.json', 'api/endpoint.js', 'index.html'];
 
-    const { builders } = await detectBuilders(files, pkg);
+    const { builders } = await detectBuilders(files, detected);
     expect(builders[0].use).toBe('@now/node');
     expect(builders[0].src).toBe('api/endpoint.js');
     expect(builders[1].use).toBe('@now/next');
@@ -263,61 +268,85 @@ describe('Test `detectBuilders`', () => {
   });
 
   it('next + public', async () => {
-    const pkg = {
-      scripts: { build: 'next build' },
-      devDependencies: { next: '9.0.0' },
+    const detected = {
+      buildCommand: 'yarn build',
+      framework: {
+        slug: 'next',
+        version: '9.0.0',
+      },
     };
+
     const files = ['package.json', 'public/index.html', 'README.md'];
 
-    const { builders } = await detectBuilders(files, pkg);
+    const { builders } = await detectBuilders(files, detected);
     expect(builders[0].use).toBe('@now/next');
     expect(builders[0].src).toBe('package.json');
     expect(builders.length).toBe(1);
   });
 
   it('nuxt', async () => {
-    const pkg = {
-      scripts: { build: 'nuxt build' },
-      dependencies: { nuxt: '2.8.1' },
+    const detected = {
+      buildCommand: 'yarn build',
+      framework: {
+        slug: '@vue/cli-service',
+        version: '2.8.1',
+      },
     };
+
     const files = ['package.json', 'pages/index.js'];
 
-    const { builders } = await detectBuilders(files, pkg);
+    const { builders } = await detectBuilders(files, detected);
     expect(builders[0].use).toBe('@now/static-build');
     expect(builders[0].src).toBe('package.json');
     expect(builders.length).toBe(1);
   });
 
   it('nuxt + tag canary', async () => {
-    const pkg = {
-      scripts: { build: 'nuxt build' },
-      dependencies: { nuxt: '2.8.1' },
+    const detected = {
+      buildCommand: 'yarn build',
+      framework: {
+        slug: '@vue/cli-service',
+        version: '2.8.1',
+      },
     };
+
     const files = ['package.json', 'pages/index.js'];
 
-    const { builders } = await detectBuilders(files, pkg, { tag: 'canary' });
+    const { builders } = await detectBuilders(files, detected, {
+      tag: 'canary',
+    });
     expect(builders[0].use).toBe('@now/static-build@canary');
     expect(builders[0].src).toBe('package.json');
     expect(builders.length).toBe(1);
   });
 
-  it('package.json with no build + api', async () => {
-    const pkg = { dependencies: { next: '9.0.0' } };
+  it('no build command + api', async () => {
+    const detected = {
+      framework: {
+        slug: 'next',
+        version: '9.0.0',
+      },
+    };
     const files = ['package.json', 'api/[endpoint].js'];
 
-    const { builders } = await detectBuilders(files, pkg);
+    const { builders } = await detectBuilders(files, detected);
     expect(builders[0].use).toBe('@now/node');
     expect(builders[0].src).toBe('api/[endpoint].js');
     expect(builders.length).toBe(1);
   });
 
-  it('package.json with no build + public directory', async () => {
-    const pkg = { dependencies: { next: '9.0.0' } };
+  it('no build command + public directory', async () => {
+    const detected = {
+      framework: {
+        slug: 'next',
+        version: '9.0.0',
+      },
+    };
     const files = ['package.json', 'public/index.html'];
 
-    const { builders, errors } = await detectBuilders(files, pkg);
-    expect(builders).toBe(null);
-    expect(errors.length).toBe(1);
+    const { builders, errors } = await detectBuilders(files, detected);
+    expect(builders.length).toBe(1);
+    expect(errors).toBe(null);
   });
 
   it('no package.json + api', async () => {
@@ -336,17 +365,23 @@ describe('Test `detectBuilders`', () => {
   });
 
   it('package.json + api + canary', async () => {
-    const pkg = {
-      scripts: { build: 'next build' },
-      dependencies: { next: '9.0.0' },
+    const detected = {
+      buildCommand: 'yarn build',
+      framework: {
+        slug: 'next',
+        version: '9.0.0',
+      },
     };
+
     const files = [
       'pages/index.js',
       'api/[endpoint].js',
       'api/[endpoint]/[id].js',
     ];
 
-    const { builders } = await detectBuilders(files, pkg, { tag: 'canary' });
+    const { builders } = await detectBuilders(files, detected, {
+      tag: 'canary',
+    });
     expect(builders[0].use).toBe('@now/node@canary');
     expect(builders[1].use).toBe('@now/node@canary');
     expect(builders[2].use).toBe('@now/next@canary');
@@ -354,17 +389,23 @@ describe('Test `detectBuilders`', () => {
   });
 
   it('package.json + api + latest', async () => {
-    const pkg = {
-      scripts: { build: 'next build' },
-      dependencies: { next: '9.0.0' },
+    const detected = {
+      buildCommand: 'yarn build',
+      framework: {
+        slug: 'next',
+        version: '9.0.0',
+      },
     };
+
     const files = [
       'pages/index.js',
       'api/[endpoint].js',
       'api/[endpoint]/[id].js',
     ];
 
-    const { builders } = await detectBuilders(files, pkg, { tag: 'latest' });
+    const { builders } = await detectBuilders(files, detected, {
+      tag: 'latest',
+    });
     expect(builders[0].use).toBe('@now/node@latest');
     expect(builders[1].use).toBe('@now/node@latest');
     expect(builders[2].use).toBe('@now/next@latest');
@@ -372,17 +413,21 @@ describe('Test `detectBuilders`', () => {
   });
 
   it('package.json + api + random tag', async () => {
-    const pkg = {
-      scripts: { build: 'next build' },
-      dependencies: { next: '9.0.0' },
+    const detected = {
+      buildCommand: 'yarn build',
+      framework: {
+        slug: 'next',
+        version: '9.0.0',
+      },
     };
+
     const files = [
       'pages/index.js',
       'api/[endpoint].js',
       'api/[endpoint]/[id].js',
     ];
 
-    const { builders } = await detectBuilders(files, pkg, { tag: 'haha' });
+    const { builders } = await detectBuilders(files, detected, { tag: 'haha' });
     expect(builders[0].use).toBe('@now/node@haha');
     expect(builders[1].use).toBe('@now/node@haha');
     expect(builders[2].use).toBe('@now/next@haha');
@@ -390,13 +435,20 @@ describe('Test `detectBuilders`', () => {
   });
 
   it('next.js pages/api + api', async () => {
-    const pkg = {
-      scripts: { build: 'next build' },
-      dependencies: { next: '9.0.0' },
+    const detected = {
+      buildCommand: 'yarn build',
+      framework: {
+        slug: 'next',
+        version: '9.0.0',
+      },
     };
+
     const files = ['api/user.js', 'pages/api/user.js'];
 
-    const { warnings, errors, builders } = await detectBuilders(files, pkg);
+    const { warnings, errors, builders } = await detectBuilders(
+      files,
+      detected
+    );
 
     expect(errors).toBe(null);
     expect(warnings[0]).toBeDefined();
@@ -420,9 +472,12 @@ describe('Test `detectBuilders`', () => {
   });
 
   it('functions with nextjs', async () => {
-    const pkg = {
-      scripts: { build: 'next build' },
-      dependencies: { next: '9.0.0' },
+    const detected = {
+      buildCommand: 'yarn build',
+      framework: {
+        slug: 'next',
+        version: '9.0.0',
+      },
     };
     const functions = {
       'pages/api/teams/**': {
@@ -435,7 +490,7 @@ describe('Test `detectBuilders`', () => {
       'pages/index.js',
       'pages/api/teams/members.ts',
     ];
-    const { builders, errors } = await detectBuilders(files, pkg, {
+    const { builders, errors } = await detectBuilders(files, detected, {
       functions,
     });
 
@@ -446,6 +501,7 @@ describe('Test `detectBuilders`', () => {
       use: '@now/next',
       config: {
         zeroConfig: true,
+        buildCommand: 'yarn build',
         functions: {
           'pages/api/teams/**': {
             memory: 128,
@@ -457,9 +513,12 @@ describe('Test `detectBuilders`', () => {
   });
 
   it('extend with functions', async () => {
-    const pkg = {
-      scripts: { build: 'next build' },
-      dependencies: { next: '9.0.0' },
+    const detected = {
+      buildCommand: 'yarn build',
+      framework: {
+        slug: 'next',
+        version: '9.0.0',
+      },
     };
     const functions = {
       'api/users/*.ts': {
@@ -476,7 +535,7 @@ describe('Test `detectBuilders`', () => {
       'api/users/[id].ts',
       'api/teams/members.ts',
     ];
-    const { builders } = await detectBuilders(files, pkg, { functions });
+    const { builders } = await detectBuilders(files, detected, { functions });
 
     expect(builders.length).toBe(3);
     expect(builders[0]).toEqual({
@@ -509,6 +568,7 @@ describe('Test `detectBuilders`', () => {
       use: '@now/next',
       config: {
         zeroConfig: true,
+        buildCommand: 'yarn build',
       },
     });
   });
@@ -607,31 +667,23 @@ describe('Test `detectBuilders`', () => {
   });
 
   it('Do not allow functions that are not used by @now/next', async () => {
-    const pkg = {
-      scripts: { build: 'next build' },
-      dependencies: { next: '9.0.0' },
+    const detected = {
+      buildCommand: 'yarn build',
+      framework: {
+        slug: 'next',
+        version: '9.0.0',
+      },
     };
+
     const functions = { 'test.js': { memory: 1024 } };
     const files = ['pages/index.js', 'test.js'];
 
-    const { errors } = await detectBuilders(files, pkg, { functions });
+    const { errors } = await detectBuilders(files, detected, { functions });
 
     expect(errors).toBeDefined();
     expect(errors[0].code).toBe('unused_function');
   });
 
-  it('Do not allow function non Community Runtimes', async () => {
-    const functions = {
-      'api/test.js': { memory: 128, runtime: '@now/node@1.0.0' },
-    };
-    const files = ['api/test.js'];
-
-    const { errors } = await detectBuilders(files, null, { functions });
-
-    expect(errors).toBeDefined();
-    expect(errors[0].code).toBe('invalid_function_runtime');
-  });
-
   it('Must include includeFiles config property', async () => {
     const functions = {
       'api/test.js': { includeFiles: 'text/include.txt' },
@@ -731,6 +783,145 @@ describe('Test `detectBuilders`', () => {
     expect(errors).not.toBe(null);
     expect(errors[0].code).toBe('invalid_function_source');
   });
+
+  it('Custom static output directory', async () => {
+    const detected = {
+      outputDirectory: 'dist',
+    };
+
+    const files = ['dist/index.html', 'dist/style.css'];
+
+    const { builders } = await detectBuilders(files, detected);
+
+    expect(builders.length).toBe(1);
+    expect(builders[0].src).toBe('dist/**/*');
+    expect(builders[0].use).toBe('@now/static');
+
+    const { defaultRoutes } = await detectRoutes(files, builders);
+
+    expect(defaultRoutes.length).toBe(1);
+    expect(defaultRoutes[0].src).toBe('/(.*)');
+    expect(defaultRoutes[0].dest).toBe('/dist/$1');
+  });
+
+  it('Custom static output directory with api', async () => {
+    const detected = {
+      outputDirectory: 'output',
+    };
+
+    const files = ['api/user.ts', 'output/index.html', 'output/style.css'];
+
+    const { builders } = await detectBuilders(files, detected);
+
+    expect(builders.length).toBe(2);
+    expect(builders[1].src).toBe('output/**/*');
+    expect(builders[1].use).toBe('@now/static');
+
+    const { defaultRoutes } = await detectRoutes(files, builders);
+
+    expect(defaultRoutes.length).toBe(3);
+    expect(defaultRoutes[1].status).toBe(404);
+    expect(defaultRoutes[2].src).toBe('/(.*)');
+    expect(defaultRoutes[2].dest).toBe('/output/$1');
+  });
+
+  it('Custom directory for Serverless Functions', async () => {
+    const files = ['server/_lib/db.ts', 'server/user.ts', 'server/team.ts'];
+
+    const functions = {
+      'server/**/*.ts': {
+        memory: 128,
+        runtime: '@now/node@1.2.1',
+      },
+    };
+
+    const { builders } = await detectBuilders(files, null, { functions });
+
+    expect(builders.length).toBe(3);
+    expect(builders[0]).toEqual({
+      use: '@now/node@1.2.1',
+      src: 'server/team.ts',
+      config: {
+        zeroConfig: true,
+        functions: {
+          'server/**/*.ts': {
+            memory: 128,
+            runtime: '@now/node@1.2.1',
+          },
+        },
+      },
+    });
+    expect(builders[1]).toEqual({
+      use: '@now/node@1.2.1',
+      src: 'server/user.ts',
+      config: {
+        zeroConfig: true,
+        functions: {
+          'server/**/*.ts': {
+            memory: 128,
+            runtime: '@now/node@1.2.1',
+          },
+        },
+      },
+    });
+    // This is expected, since only "api + full static" is supported
+    // no other directory, so everything else will be deployed
+    expect(builders[2].use).toBe('@now/static');
+
+    const { defaultRoutes } = await detectRoutes(files, builders);
+
+    expect(defaultRoutes.length).toBe(3);
+    expect(defaultRoutes[0].dest).toBe('/server/team.ts');
+    expect(defaultRoutes[0].src).toBe('^/server/(team\\/|team|team\\.ts)$');
+    expect(defaultRoutes[1].dest).toBe('/server/user.ts');
+    expect(defaultRoutes[1].src).toBe('^/server/(user\\/|user|user\\.ts)$');
+    expect(defaultRoutes[2].status).toBe(404);
+  });
+
+  it('Custom directory for Serverless Functions + Next.js', async () => {
+    const detected = {
+      buildCommand: 'yarn build',
+      framework: {
+        slug: 'next',
+        version: '9.0.0',
+      },
+    };
+
+    const functions = {
+      'server/**/*.ts': {
+        runtime: '@now/node@1.2.1',
+      },
+    };
+
+    const files = ['package.json', 'pages/index.ts', 'server/user.ts'];
+
+    const { builders } = await detectBuilders(files, detected, { functions });
+
+    expect(builders.length).toBe(2);
+    expect(builders[0]).toEqual({
+      use: '@now/node@1.2.1',
+      src: 'server/user.ts',
+      config: {
+        zeroConfig: true,
+        functions,
+      },
+    });
+    expect(builders[1]).toEqual({
+      use: '@now/next',
+      src: 'package.json',
+      config: {
+        buildCommand: 'yarn build',
+        zeroConfig: true,
+      },
+    });
+
+    const { defaultRoutes } = await detectRoutes(files, builders);
+
+    expect(defaultRoutes.length).toBe(2);
+    expect(defaultRoutes[0].dest).toBe('/server/user.ts');
+    expect(defaultRoutes[0].src).toBe('^/server/(user\\/|user|user\\.ts)$');
+    expect(defaultRoutes[1].status).toBe(404);
+  });
 });
 
 it('Test `detectRoutes`', async () => {
@@ -804,13 +995,17 @@ it('Test `detectRoutes`', async () => {
   }
 
   {
-    const pkg = {
-      scripts: { build: 'next build' },
-      devDependencies: { next: '9.0.0' },
+    const detected = {
+      buildCommand: 'yarn build',
+      framework: {
+        slug: 'next',
+        version: '9.0.0',
+      },
     };
+
     const files = ['public/index.html', 'api/[endpoint].js'];
 
-    const { builders } = await detectBuilders(files, pkg);
+    const { builders } = await detectBuilders(files, detected);
     const { defaultRoutes } = await detectRoutes(files, builders);
     expect(defaultRoutes[1].status).toBe(404);
     expect(defaultRoutes[1].src).toBe('/api(\\/.*)?$');

packages/now-cgi/package.json

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

packages/now-cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "now",
-  "version": "16.6.4-canary.0",
+  "version": "16.7.0",
   "preferGlobal": true,
   "license": "Apache-2.0",
   "description": "The command-line interface for Now",

packages/now-cli/src/commands/deploy/latest.js

@@ -38,7 +38,6 @@ import {
 } from '../../util/errors-ts';
 import { SchemaValidationFailed } from '../../util/errors';
 import purchaseDomainIfAvailable from '../../util/domains/purchase-domain-if-available';
-import handleCertError from '../../util/certs/handle-cert-error';
 import isWildcardAlias from '../../util/alias/is-wildcard-alias';
 import shouldDeployDir from '../../util/deploy/should-deploy-dir';
 
@@ -382,15 +381,13 @@ export default async function main(
       return 1;
     }
 
-    const deploymentResponse = handleCertError(
-      output,
-      await getDeploymentByIdOrHost(now, contextName, deployment.id, 'v10')
+    const deploymentResponse = await getDeploymentByIdOrHost(
+      now,
+      contextName,
+      deployment.id,
+      'v10'
     );
 
-    if (deploymentResponse === 1) {
-      return deploymentResponse;
-    }
-
     if (
       deploymentResponse instanceof DeploymentNotFound ||
       deploymentResponse instanceof DeploymentPermissionDenied ||
@@ -400,10 +397,6 @@ export default async function main(
       return 1;
     }
 
-    if (handleCertError(output, deployment) === 1) {
-      return 1;
-    }
-
     if (deployment === null) {
       error('Uploading failed. Please try again.');
       return 1;

packages/now-cli/src/commands/deploy/legacy.ts

@@ -70,7 +70,6 @@ import {
   InvalidRegionOrDCForScale,
 } from '../../util/errors';
 import { SchemaValidationFailed } from '../../util/errors';
-import handleCertError from '../../util/certs/handle-cert-error';
 import readPackage from '../../util/read-package';
 
 interface Env {
@@ -801,11 +800,6 @@ async function sync({
         createArgs
       );
 
-      const handledResult = handleCertError(output, deployment);
-      if (handledResult === 1) {
-        return handledResult;
-      }
-
       if (
         deployment instanceof DomainNotFound ||
         deployment instanceof NotDomainOwner ||

packages/now-cli/src/commands/domains/inspect.ts

@@ -10,6 +10,7 @@ import formatDate from '../../util/format-date';
 import formatNSTable from '../../util/format-ns-table';
 import getDomainByName from '../../util/domains/get-domain-by-name';
 import getScope from '../../util/get-scope';
+import getDomainPrice from '../../util/domains/get-domain-price';
 
 type Options = {
   '--debug': boolean;
@@ -23,7 +24,7 @@ export default async function inspect(
 ) {
   const {
     authConfig: { token },
-    config
+    config,
   } = ctx;
   const { currentTeam } = config;
   const { apiUrl } = ctx;
@@ -61,7 +62,12 @@ export default async function inspect(
   }
 
   output.debug(`Fetching domain info`);
-  const domain = await getDomainByName(client, contextName, domainName);
+  const [domain, renewalPrice] = await Promise.all([
+    getDomainByName(client, contextName, domainName),
+    getDomainPrice(client, domainName, 'renewal')
+      .then(res => (res instanceof Error ? null : res.price))
+      .catch(() => null),
+  ]);
   if (domain instanceof DomainNotFound) {
     output.error(
       `Domain not found by "${domainName}" under ${chalk.bold(contextName)}`
@@ -104,24 +110,35 @@ export default async function inspect(
     `    ${chalk.cyan('Bought At')}\t\t\t${formatDate(domain.boughtAt)}\n`
   );
   output.print(
-    `    ${chalk.cyan('Transferred At')}\t\t${formatDate(domain.transferredAt)}\n`
+    `    ${chalk.cyan('Transferred At')}\t\t${formatDate(
+      domain.transferredAt
+    )}\n`
   );
   output.print(
     `    ${chalk.cyan('Expires At')}\t\t\t${formatDate(domain.expiresAt)}\n`
   );
   output.print(
-    `    ${chalk.cyan('NS Verified At')}\t\t${formatDate(domain.nsVerifiedAt)}\n`
+    `    ${chalk.cyan('NS Verified At')}\t\t${formatDate(
+      domain.nsVerifiedAt
+    )}\n`
   );
   output.print(
-    `    ${chalk.cyan('TXT Verified At')}\t\t${formatDate(domain.txtVerifiedAt)}\n`
+    `    ${chalk.cyan('TXT Verified At')}\t\t${formatDate(
+      domain.txtVerifiedAt
+    )}\n`
   );
-  output.print(`    ${chalk.cyan('CDN Enabled')}\t\t${true}\n`);
+  if (renewalPrice && domain.boughtAt) {
+    output.print(
+      `    ${chalk.cyan('Renewal Price')}\t\t$${renewalPrice} USD\n`
+    );
+  }
+  output.print(`    ${chalk.cyan('CDN Enabled')}\t\t\t${true}\n`);
   output.print('\n');
 
   output.print(chalk.bold('  Nameservers\n\n'));
   output.print(
     `${formatNSTable(domain.intendedNameservers, domain.nameservers, {
-      extraSpace: '    '
+      extraSpace: '    ',
     })}\n`
   );
   output.print('\n');
@@ -129,7 +146,7 @@ export default async function inspect(
   output.print(chalk.bold('  Verification Record\n\n'));
   output.print(
     `${dnsTable([['_now', 'TXT', domain.verificationRecord]], {
-      extraSpace: '    '
+      extraSpace: '    ',
     })}\n`
   );
   output.print('\n');

packages/now-cli/src/util/dev/server.ts

@@ -22,6 +22,8 @@ import {
   PackageJson,
   detectBuilders,
   detectRoutes,
+  detectDefaults,
+  DetectorFilesystem,
 } from '@now/build-utils';
 
 import { once } from '../once';
@@ -100,6 +102,25 @@ function sortBuilders(buildA: Builder, buildB: Builder) {
   return 0;
 }
 
+class DevDetectorFilesystem extends DetectorFilesystem {
+  private dir: string;
+  private files: string[];
+
+  constructor(dir: string, files: string[]) {
+    super();
+    this.dir = dir;
+    this.files = files;
+  }
+
+  _exists(name: string): Promise<boolean> {
+    return Promise.resolve(this.files.includes(name));
+  }
+
+  _readFile(name: string): Promise<Buffer> {
+    return fs.readFile(join(this.dir, name));
+  }
+}
+
 export default class DevServer {
   public cwd: string;
   public debug: boolean;
@@ -477,8 +498,6 @@ export default class DevServer {
       return this.cachedNowConfig;
     }
 
-    const pkg = await this.getPackageJson();
-
     // The default empty `now.json` is used to serve all files as static
     // when no `now.json` is present
     let config: NowConfig = this.cachedNowConfig || { version: 2 };
@@ -526,11 +545,19 @@ export default class DevServer {
 
     // no builds -> zero config
     if (!config.builds || config.builds.length === 0) {
-      const { builders, warnings, errors } = await detectBuilders(files, pkg, {
-        tag: getDistTag(cliVersion) === 'canary' ? 'canary' : 'latest',
-        functions: config.functions,
+      const detectorResult = await detectDefaults({
+        fs: new DevDetectorFilesystem(this.cwd, files),
       });
 
+      const { builders, warnings, errors } = await detectBuilders(
+        files,
+        detectorResult,
+        {
+          tag: getDistTag(cliVersion) === 'canary' ? 'canary' : 'latest',
+          functions: config.functions,
+        }
+      );
+
       if (errors) {
         this.output.error(errors[0].message);
         await this.exit();
@@ -575,29 +602,6 @@ export default class DevServer {
     return config;
   }
 
-  async getPackageJson(): Promise<PackageJson | null> {
-    const pkgPath = join(this.cwd, 'package.json');
-    let pkg: PackageJson | null = null;
-
-    this.output.debug('Reading `package.json` file');
-
-    try {
-      pkg = JSON.parse(await fs.readFile(pkgPath, 'utf8'));
-    } catch (err) {
-      if (err.code === 'ENOENT') {
-        this.output.debug('No `package.json` file present');
-      } else if (err.name === 'SyntaxError') {
-        this.output.warn(
-          `There is a syntax error in the \`package.json\` file: ${err.message}`
-        );
-      } else {
-        throw err;
-      }
-    }
-
-    return pkg;
-  }
-
   async tryValidateOrExit(
     config: NowConfig,
     validate: (c: NowConfig) => string | null

packages/now-cli/src/util/dev/validate.ts

@@ -8,62 +8,10 @@ import {
   trailingSlashSchema,
 } from '@now/routing-utils';
 import { NowConfig } from './types';
+import { functionsSchema, buildsSchema } from '@now/build-utils';
 
 const ajv = new Ajv();
 
-const buildsSchema = {
-  type: 'array',
-  minItems: 0,
-  maxItems: 128,
-  items: {
-    type: 'object',
-    additionalProperties: false,
-    required: ['use'],
-    properties: {
-      src: {
-        type: 'string',
-        minLength: 1,
-        maxLength: 4096,
-      },
-      use: {
-        type: 'string',
-        minLength: 3,
-        maxLength: 256,
-      },
-      config: { type: 'object' },
-    },
-  },
-};
-
-const functionsSchema = {
-  type: 'object',
-  minProperties: 1,
-  maxProperties: 50,
-  additionalProperties: false,
-  patternProperties: {
-    '^.{1,256}$': {
-      type: 'object',
-      additionalProperties: false,
-      properties: {
-        runtime: {
-          type: 'string',
-          maxLength: 256,
-        },
-        memory: {
-          enum: Object.keys(Array.from({ length: 50 }))
-            .slice(2, 48)
-            .map(x => Number(x) * 64),
-        },
-        maxDuration: {
-          type: 'number',
-          minimum: 1,
-          maximum: 900,
-        },
-      },
-    },
-  },
-};
-
 const validateBuilds = ajv.compile(buildsSchema);
 const validateRoutes = ajv.compile(routesSchema);
 const validateCleanUrls = ajv.compile(cleanUrlsSchema);

packages/now-cli/src/util/errors-ts.ts

@@ -1097,7 +1097,7 @@ export class LambdaSizeExceededError extends NowError<
         size
       ).toLowerCase()}) exceeds the maximum size limit (${bytes(
         maxLambdaSize
-      ).toLowerCase()}). Learn more: https://zeit.co/docs/v2/deployments/concepts/lambdas/#maximum-bundle-size`,
+      ).toLowerCase()}).`,
       meta: { size, maxLambdaSize },
     });
   }

packages/now-cli/test/dev/fixtures/public-and-server-as-api/.gitignore

@@ -0,0 +1 @@
+!public

packages/now-cli/test/dev/fixtures/public-and-server-as-api/now.json

@@ -0,0 +1,7 @@
+{
+  "functions": {
+    "server/**/*.js": {
+      "runtime": "@now/node@1.2.1"
+    }
+  }
+}

packages/now-cli/test/dev/fixtures/public-and-server-as-api/public/index.txt

@@ -0,0 +1 @@
+This is content.

packages/now-cli/test/dev/fixtures/public-and-server-as-api/server/date.js

@@ -0,0 +1,3 @@
+export default (req, res) => {
+  res.end(`current hour: ${Math.floor(Date.now() / 10000)}`);
+};

packages/now-cli/test/dev/integration.js

@@ -1114,8 +1114,7 @@ if (satisfies(process.version, '>= 8.9.0')) {
       // start `now dev` detached in child_process
       dev.unref();
 
-      const result = await fetchWithRetry(`http://localhost:${port}`, 80);
-      const response = await result;
+      const response = await fetchWithRetry(`http://localhost:${port}`, 80);
 
       validateResponseHeaders(t, response);
 
@@ -1134,8 +1133,10 @@ if (satisfies(process.version, '>= 8.9.0')) {
 test(
   '[now dev] Use runtime from the functions property',
   testFixtureStdio('custom-runtime', async (t, port) => {
-    const result = await fetchWithRetry(`http://localhost:${port}/api/user`, 3);
-    const response = await result;
+    const response = await fetchWithRetry(
+      `http://localhost:${port}/api/user`,
+      3
+    );
 
     validateResponseHeaders(t, response);
 
@@ -1143,3 +1144,20 @@ test(
     t.regex(body, /Hello, from Bash!/gm);
   })
 );
+
+test(
+  '[now dev] Use public with a custom Serverless Function in `server/date.js',
+  testFixtureStdio('public-and-server-as-api', async (t, port) => {
+    const response = await fetchWithRetry(
+      `http://localhost:${port}/server/date`
+    );
+
+    validateResponseHeaders(t, response);
+
+    t.is(response.status, 200);
+    t.is(
+      await response.text(),
+      `current hour: ${Math.floor(Date.now() / 10000)}`
+    );
+  })
+);

packages/now-cli/test/integration.js

@@ -493,6 +493,35 @@ test('list the payment methods', async t => {
   t.true(stdout.startsWith(`> 0 cards found under ${contextName}`));
 });
 
+test('domains inspect', async t => {
+  const domainName = `inspect-${contextName}.org`;
+
+  const addRes = await execa(
+    binaryPath,
+    [`domains`, `add`, domainName, ...defaultArgs],
+    { reject: false }
+  );
+  t.is(addRes.exitCode, 0);
+
+  const { stderr, exitCode } = await execa(
+    binaryPath,
+    ['domains', 'inspect', domainName, ...defaultArgs],
+    {
+      reject: false,
+    }
+  );
+
+  const rmRes = await execa(
+    binaryPath,
+    [`domains`, `rm`, domainName, ...defaultArgs],
+    { reject: false, input: 'y' }
+  );
+  t.is(rmRes.exitCode, 0);
+
+  t.is(exitCode, 0);
+  t.true(!stderr.includes(`Renewal Price`));
+});
+
 test('try to purchase a domain', async t => {
   const { stderr, stdout, exitCode } = await execa(
     binaryPath,
@@ -767,7 +796,19 @@ test('create wildcard alias for deployment', async t => {
   t.true(stdout.startsWith(goal));
 
   // Send a test request to the alias
-  const response = await fetch(`https://test.${contextName}.now.sh`);
+  // Retries to make sure we consider the time it takes to update
+  const response = await retry(
+    async () => {
+      const response = await fetch(`https://test.${contextName}.now.sh`);
+
+      if (response.ok) {
+        return response;
+      }
+
+      throw new Error(`Error: Returned code ${response.status}`);
+    },
+    { retries: 3 }
+  );
   const content = await response.text();
 
   t.true(response.ok);

packages/now-go/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@now/go",
-  "version": "1.0.1-canary.1",
+  "version": "1.0.1",
   "license": "MIT",
   "main": "./dist/index",
   "homepage": "https://zeit.co/docs/runtimes#official-runtimes/go",

packages/now-next/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@now/next",
-  "version": "2.1.2-canary.0",
+  "version": "2.2.0",
   "license": "MIT",
   "main": "./dist/index",
   "homepage": "https://zeit.co/docs/runtimes#official-runtimes/next-js",

packages/now-next/src/index.ts

@@ -334,6 +334,27 @@ export const build = async ({
   env.NODE_OPTIONS = `--max_old_space_size=${memoryToConsume}`;
   await runPackageJsonScript(entryPath, shouldRunScript, { ...spawnOpts, env });
 
+  const routesManifest = await getRoutesManifest(entryPath, realNextVersion);
+  const rewrites: Route[] = [];
+  const redirects: Route[] = [];
+
+  if (routesManifest) {
+    switch (routesManifest.version) {
+      case 1: {
+        redirects.push(...convertRedirects(routesManifest.redirects));
+        rewrites.push(...convertRewrites(routesManifest.rewrites));
+        break;
+      }
+      default: {
+        // update MIN_ROUTES_MANIFEST_VERSION in ./utils.ts
+        throw new Error(
+          'This version of `@now/next` does not support the version of Next.js you are trying to deploy.\n' +
+            'Please upgrade your `@now/next` builder and try again. Contact support if this continues to happen.'
+        );
+      }
+    }
+  }
+
   if (isLegacy) {
     debug('Running npm install --production...');
     await runNpmInstall(
@@ -819,8 +840,6 @@ export const build = async ({
   let dynamicPrefix = path.join('/', entryDirectory);
   dynamicPrefix = dynamicPrefix === '/' ? '' : dynamicPrefix;
 
-  const routesManifest = await getRoutesManifest(entryPath, realNextVersion);
-
   const dynamicRoutes = await getDynamicRoutes(
     entryPath,
     entryDirectory,
@@ -834,26 +853,6 @@ export const build = async ({
     })
   );
 
-  const rewrites: Route[] = [];
-  const redirects: Route[] = [];
-
-  if (routesManifest) {
-    switch (routesManifest.version) {
-      case 1: {
-        redirects.push(...convertRedirects(routesManifest.redirects));
-        rewrites.push(...convertRewrites(routesManifest.rewrites));
-        break;
-      }
-      default: {
-        // update MIN_ROUTES_MANIFEST_VERSION in ./utils.ts
-        throw new Error(
-          'This version of `@now/next` does not support the version of Next.js you are trying to deploy.\n' +
-            'Please upgrade your `@now/next` builder and try again. Contact support if this continues to happen.'
-        );
-      }
-    }
-  }
-
   return {
     output: {
       ...publicDirectoryFiles,

packages/now-node/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@now/node",
-  "version": "1.2.2-canary.0",
+  "version": "1.3.0",
   "license": "MIT",
   "main": "./dist/index",
   "homepage": "https://zeit.co/docs/runtimes#official-runtimes/node-js",

packages/now-python/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@now/python",
-  "version": "1.0.1-canary.1",
+  "version": "1.0.1",
   "main": "./dist/index.js",
   "license": "MIT",
   "homepage": "https://zeit.co/docs/runtimes#official-runtimes/python",

packages/now-ruby/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@now/ruby",
   "author": "Nathan Cahill <nathan@nathancahill.com>",
-  "version": "1.0.1-canary.1",
+  "version": "1.0.1",
   "license": "MIT",
   "main": "./dist/index",
   "homepage": "https://zeit.co/docs/runtimes#official-runtimes/ruby",

packages/now-static-build/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@now/static-build",
-  "version": "0.13.2-canary.0",
+  "version": "0.14.0",
   "license": "MIT",
   "main": "./dist/index",
   "homepage": "https://zeit.co/docs/runtimes#official-runtimes/static-builds",

yarn.lock

@@ -9721,7 +9721,7 @@ shellwords@^0.1.1:
   resolved "https://registry.yarnpkg.com/shellwords/-/shellwords-0.1.1.tgz#d6b9181c1a48d397324c84871efbcfc73fc0654b"
   integrity sha512-vFwSUfQvqybiICwZY5+DAWIPLKsWO31Q91JSKl3UYv+K5c2QRPzn0qzec6QPu1Qc9eHYItiP3NdJqNVqetYAww==
 
-signal-exit@3.0.2, signal-exit@^3.0.0, signal-exit@^3.0.2:
+signal-exit@3.0.2, signal-exit@TooTallNate/signal-exit#update/sighub-to-sigint-on-windows, signal-exit@^3.0.0, signal-exit@^3.0.2:
   version "3.0.2"
   resolved "https://codeload.github.com/TooTallNate/signal-exit/tar.gz/58088fa7f715149f8411e089a4a6e3fe6ed265ec"