@vercel/static-build 0.18.1-canary.1 → 0.22.2-canary.2

package/dist/utils/gatsby.js

@@ -14,7 +14,7 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 var __importStar = (this && this.__importStar) || function (mod) {
     if (mod && mod.__esModule) return mod;
     var result = {};
-    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
     __setModuleDefault(result, mod);
     return result;
 };
@@ -38,11 +38,13 @@ async function injectVercelAnalyticsPlugin(dir) {
     const gatsbyConfigName = 'gatsby-config.js';
     const gatsbyPluginPackageName = 'gatsby-plugin-vercel';
     const gatsbyConfigPath = path.join(dir, gatsbyConfigName);
+    console.log(`Injecting Gatsby.js analytics plugin "${gatsbyPluginPackageName}" to \`${gatsbyConfigPath}\``);
     const pkgJson = (await _shared_1.readPackageJson(dir));
     if (!pkgJson.dependencies) {
         pkgJson.dependencies = {};
     }
     if (!pkgJson.dependencies[gatsbyPluginPackageName]) {
+        console.log(`Adding "${gatsbyPluginPackageName}" to \`package.json\` "dependencies"`);
         pkgJson.dependencies[gatsbyPluginPackageName] = 'latest';
         await _shared_1.writePackageJson(dir, pkgJson);
     }

package/dist/utils/nuxt.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.injectVercelAnalyticsPlugin = void 0;
+const path_1 = require("path");
+const rc9_1 = require("rc9");
+const _shared_1 = require("./_shared");
+// https://github.com/nuxt-community/web-vitals-module
+const ANALYTICS_PLUGIN_PACKAGE = '@nuxtjs/web-vitals';
+async function injectVercelAnalyticsPlugin(dir) {
+    // First update the `.nuxtrc` file to inject the analytics plugin.
+    // See: https://gist.github.com/pi0/23b5253ac19b4ed5a70add3b971545c9
+    const nuxtrcPath = path_1.join(dir, '.nuxtrc');
+    console.log(`Injecting Nuxt.js analytics plugin "${ANALYTICS_PLUGIN_PACKAGE}" to \`${nuxtrcPath}\``);
+    rc9_1.update({
+        'modules[]': ANALYTICS_PLUGIN_PACKAGE,
+    }, {
+        name: nuxtrcPath,
+    });
+    // The dependency needs to be listed in `package.json` as well so
+    // that `npm i` installs the package.
+    const pkgJson = (await _shared_1.readPackageJson(dir));
+    if (!pkgJson.dependencies) {
+        pkgJson.dependencies = {};
+    }
+    if (!pkgJson.dependencies[ANALYTICS_PLUGIN_PACKAGE]) {
+        pkgJson.dependencies[ANALYTICS_PLUGIN_PACKAGE] = 'latest';
+        console.log(`Adding "${ANALYTICS_PLUGIN_PACKAGE}" to \`package.json\` "dependencies"`);
+        await _shared_1.writePackageJson(dir, pkgJson);
+    }
+}
+exports.injectVercelAnalyticsPlugin = injectVercelAnalyticsPlugin;

package/dist/utils/read-build-output.js

@@ -3,102 +3,192 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.readBuildOutputDirectory = void 0;
+exports.readBuildOutputConfig = exports.readBuildOutputDirectory = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_1 = require("fs");
 const build_utils_1 = require("@vercel/build-utils");
 const _shared_1 = require("./_shared");
-const launcher_1 = require("../launcher");
-const fs_1 = require("fs");
-const build_utils_2 = __importDefault(require("../build-utils"));
-const path_1 = __importDefault(require("path"));
-const { createLambda, debug, getLatestNodeVersion, glob } = build_utils_2.default;
+const VERCEL_BUILD_OUTPUT = '.vercel_build_output';
 /**
  * Reads the .vercel_build_output directory and returns and object
  * that should be merged with the build outputs.
- *
- * At the moment only `functions/node` is supported for functions.
  */
-async function readBuildOutputDirectory({ workPath, }) {
-    const functions = {};
-    const functionsMountPath = path_1.default.join('.vercel', 'functions');
-    Object.assign(functions, await readNodeFunctions({ workPath, functionsMountPath }));
+async function readBuildOutputDirectory({ workPath, nodeVersion, }) {
+    const functions = await readFunctions({
+        workPath,
+        functionsMountPath: path_1.default.join('.vercel', 'functions'),
+        nodeVersion,
+    });
     const staticFiles = await readStaticFiles({ workPath });
-    const routes = await readRoutesConfig({ workPath });
+    const routes = (await readBuildOutputConfig({
+        workPath,
+        configFileName: 'routes.json',
+    })) || [];
+    const images = await readBuildOutputConfig({
+        workPath,
+        configFileName: 'images.json',
+    });
+    const build = await readBuildOutputConfig({
+        workPath,
+        configFileName: 'build.json',
+    });
     const outputs = {
         staticFiles: _shared_1.isObjectEmpty(staticFiles) ? null : staticFiles,
         functions: _shared_1.isObjectEmpty(functions) ? null : functions,
         routes: routes.length ? routes : null,
+        images,
+        build,
     };
     if (outputs.functions) {
-        console.log(`Detected Serverless Functions in ".vercel_build_output/functions"`);
+        console.log(`Detected Serverless Functions in "${VERCEL_BUILD_OUTPUT}"`);
     }
     if (outputs.staticFiles) {
-        console.log(`Detected Static Assets in ".vercel_build_output/static"`);
+        console.log(`Detected Static Assets in "${VERCEL_BUILD_OUTPUT}"`);
     }
     if (outputs.routes) {
-        console.log(`Detected Configuration in ".vercel_build_output/config"`);
+        console.log(`Detected Routes Configuration in "${VERCEL_BUILD_OUTPUT}"`);
+    }
+    if (outputs.images) {
+        console.log(`Detected Images Configuration in "${VERCEL_BUILD_OUTPUT}"`);
+    }
+    if (outputs.build) {
+        console.log(`Detected Build Configuration in "${VERCEL_BUILD_OUTPUT}"`);
     }
     return outputs;
 }
 exports.readBuildOutputDirectory = readBuildOutputDirectory;
 async function readStaticFiles({ workPath, }) {
-    const staticFilePath = path_1.default.join(workPath, '.vercel_build_output', 'static');
-    const staticFiles = await glob('**', {
+    const staticFilePath = path_1.default.join(workPath, VERCEL_BUILD_OUTPUT, 'static');
+    const staticFiles = await build_utils_1.glob('**', {
         cwd: staticFilePath,
     });
     return staticFiles;
 }
-async function readNodeFunctions({ workPath, functionsMountPath, }) {
+async function readFunctions({ workPath, functionsMountPath, nodeVersion, }) {
     const output = {};
-    const nodeFunctionPath = path_1.default.join(workPath, '.vercel_build_output', 'functions', 'node');
-    const nodeFunctionFiles = await glob('*/index.js', {
-        cwd: nodeFunctionPath,
-    });
-    const nodeBridgeData = await fs_1.promises.readFile(path_1.default.join(__dirname, 'bridge.js'));
-    for (const fileName of Object.keys(nodeFunctionFiles)) {
-        const launcherFileName = '___now_launcher';
-        const bridgeFileName = '___now_bridge';
-        const launcherFiles = {
-            [`${launcherFileName}.js`]: new build_utils_1.FileBlob({
-                data: launcher_1.makeNowLauncher({
-                    entrypointPath: `./index.js`,
-                    bridgePath: `./${bridgeFileName}`,
-                    helpersPath: '',
-                    sourcemapSupportPath: '',
-                    shouldAddHelpers: false,
-                    shouldAddSourcemapSupport: false,
-                }),
-            }),
-            [`${bridgeFileName}.js`]: new build_utils_1.FileBlob({
-                data: nodeBridgeData,
-            }),
-        };
-        const requiredFiles = await glob('**', {
-            cwd: path_1.default.join(nodeFunctionPath, path_1.default.dirname(fileName)),
+    const functionsConfig = await readFunctionsConfig({ workPath });
+    // Find all entrypoints and create a Lambda for each of them.
+    let functionsPath = path_1.default.join(workPath, VERCEL_BUILD_OUTPUT, 'functions');
+    let functionEntrypoints = await build_utils_1.glob('*/index{,.*}', { cwd: functionsPath });
+    let isLegacyFunctions = false;
+    // To not break existing projects, we have to keep supporting the `functions/node` folder.
+    if (!Object.keys(functionEntrypoints).length) {
+        functionsPath = path_1.default.join(functionsPath, 'node');
+        functionEntrypoints = await build_utils_1.glob('*/index.{js,mjs}', {
+            cwd: functionsPath,
         });
-        const lambda = await createLambda({
-            files: {
-                ...requiredFiles,
-                ...launcherFiles,
-            },
-            handler: `${launcherFileName}.launcher`,
-            runtime: getLatestNodeVersion().runtime,
+        isLegacyFunctions = true;
+    }
+    for (const entrypointFile of Object.keys(functionEntrypoints)) {
+        let lambda;
+        const functionName = path_1.default.dirname(entrypointFile);
+        const lambdaConfig = functionsConfig.get(functionName) || {};
+        const { runtime, handler, ...config } = lambdaConfig;
+        const lambdaFiles = await build_utils_1.glob('**', {
+            cwd: path_1.default.join(functionsPath, functionName),
         });
-        const parsed = path_1.default.parse(fileName);
-        const newPath = path_1.default.join(functionsMountPath, parsed.dir, parsed.name);
+        if (!lambdaConfig.runtime && isLegacyFunctions) {
+            // The bridge and launcher is only added for legacy functions.
+            lambda = new build_utils_1.NodejsLambda({
+                files: lambdaFiles,
+                handler: path_1.default.basename(entrypointFile),
+                runtime: nodeVersion.runtime,
+                ...config,
+                shouldAddHelpers: false,
+                shouldAddSourcemapSupport: false,
+            });
+        }
+        else {
+            if (!runtime) {
+                throw new Error(`Missing the \`runtime\` property for the function \`${functionName}\`.`);
+            }
+            if (!handler) {
+                throw new Error(`Missing the \`handler\` property for the function \`${functionName}\`.`);
+            }
+            lambda = new build_utils_1.Lambda({
+                files: lambdaFiles,
+                ...config,
+                handler,
+                runtime,
+            });
+        }
+        /**
+         * For legacy functions we have to keep the `<name>/index` structure,
+         * for new functions we'll just use `<name>`, as there is no need to
+         * further nest it.
+         */
+        const parsed = path_1.default.parse(entrypointFile);
+        const newPath = isLegacyFunctions
+            ? path_1.default.join(functionsMountPath, parsed.dir, parsed.name)
+            : path_1.default.join(functionsMountPath, functionName);
         output[newPath] = lambda;
-        debug(`Created Lambda "${newPath}" from "${path_1.default.join(nodeFunctionPath, fileName)}".`);
+        build_utils_1.debug(`Created Lambda "${newPath}" from "${path_1.default.join(functionsPath, entrypointFile)}".`);
     }
     return output;
 }
-async function readRoutesConfig({ workPath, }) {
-    const routesConfigPath = path_1.default.join(workPath, '.vercel_build_output', 'config', 'routes.json');
+/**
+ * Reads the global configuration file for functions and checks its types.
+ */
+async function readFunctionsConfig({ workPath }) {
+    const data = await fs_1.promises
+        .readFile(path_1.default.join(workPath, VERCEL_BUILD_OUTPUT, 'config', 'functions.json'), 'utf8')
+        .then(raw => {
+        try {
+            return JSON.parse(raw);
+        }
+        catch (_error) {
+            return null;
+        }
+    })
+        .catch(error => {
+        if (error.code === 'ENOENT') {
+            return null;
+        }
+        throw error;
+    });
+    const config = new Map();
+    if (!data) {
+        return config;
+    }
+    Object.keys(data).forEach(key => {
+        const fnConf = parseFunctionConfig(data[key]);
+        if (fnConf)
+            config.set(key, fnConf);
+    });
+    return config;
+}
+function parseFunctionConfig(data) {
+    if (!data) {
+        return null;
+    }
+    const config = {};
+    if (typeof data.memory === 'number') {
+        config.memory = data.memory;
+    }
+    if (typeof data.maxDuration === 'number') {
+        config.maxDuration = data.maxDuration;
+    }
+    // In case of a custom runtime, a custom handler has to be provided.
+    if (typeof data.runtime === 'string' && typeof data.handler === 'string') {
+        config.runtime = data.runtime;
+        config.handler = data.handler;
+    }
+    if (Array.isArray(data.regions) &&
+        data.regions.every(r => typeof r === 'string')) {
+        config.regions = data.regions;
+    }
+    return config;
+}
+async function readBuildOutputConfig({ workPath, configFileName, }) {
+    const configPath = path_1.default.join(workPath, VERCEL_BUILD_OUTPUT, 'config', configFileName);
     try {
-        return JSON.parse(await fs_1.promises.readFile(routesConfigPath, 'utf8')) || [];
+        return JSON.parse(await fs_1.promises.readFile(configPath, 'utf8'));
     }
     catch (error) {
         if (error.code === 'ENOENT') {
-            return [];
+            return undefined;
         }
         throw error;
     }
 }
+exports.readBuildOutputConfig = readBuildOutputConfig;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/static-build",
-  "version": "0.18.1-canary.1",
+  "version": "0.22.2-canary.2",
   "license": "MIT",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/build-step",
@@ -10,13 +10,13 @@
   "repository": {
     "type": "git",
     "url": "https://github.com/vercel/vercel.git",
-    "directory": "packages/now-static-build"
+    "directory": "packages/static-build"
   },
   "scripts": {
-    "build": "./build.sh",
+    "build": "node build",
     "test-unit": "jest --env node --verbose --runInBand --bail test/unit.test.js",
     "test-integration-once": "jest --env node --verbose --runInBand --bail test/integration.test.js",
-    "prepublishOnly": "./build.sh"
+    "prepublishOnly": "node build"
   },
   "devDependencies": {
     "@types/aws-lambda": "8.10.64",
@@ -24,12 +24,15 @@
     "@types/ms": "0.7.31",
     "@types/node-fetch": "2.5.4",
     "@types/promise-timeout": "1.3.0",
+    "@vercel/build-utils": "2.14.1-canary.5",
+    "@vercel/frameworks": "0.6.1-canary.4",
     "@vercel/ncc": "0.24.0",
+    "@vercel/routing-utils": "1.12.1-canary.0",
     "get-port": "5.0.0",
     "is-port-reachable": "2.0.1",
     "ms": "2.1.2",
     "node-fetch": "2.6.1",
-    "typescript": "3.9.3"
+    "rc9": "1.2.0"
   },
-  "gitHead": "a6ec53d9d38edddbbd4dd4753464d08997d6d598"
+  "gitHead": "b3ccb5f3ef354da577eeff6ce63d8ee51cfb3e17"
 }

package/dist/bridge.js

@@ -1,178 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Bridge = void 0;
-const http_1 = require("http");
-/**
- * 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 => {
-    console.error('Unhandled rejection:', err);
-    process.exit(1);
-});
-function normalizeNowProxyEvent(event) {
-    let bodyBuffer;
-    const { method, path, headers, encoding, body } = JSON.parse(event.body);
-    if (body) {
-        if (encoding === 'base64') {
-            bodyBuffer = Buffer.from(body, encoding);
-        }
-        else if (encoding === undefined) {
-            bodyBuffer = Buffer.from(body);
-        }
-        else {
-            throw new Error(`Unsupported encoding: ${encoding}`);
-        }
-    }
-    else {
-        bodyBuffer = Buffer.alloc(0);
-    }
-    return { isApiGateway: false, method, path, headers, body: bodyBuffer };
-}
-function normalizeAPIGatewayProxyEvent(event) {
-    let bodyBuffer;
-    const { httpMethod: method, path, headers, body } = event;
-    if (body) {
-        if (event.isBase64Encoded) {
-            bodyBuffer = Buffer.from(body, 'base64');
-        }
-        else {
-            bodyBuffer = Buffer.from(body);
-        }
-    }
-    else {
-        bodyBuffer = Buffer.alloc(0);
-    }
-    return { isApiGateway: true, method, path, headers, body: bodyBuffer };
-}
-function normalizeEvent(event) {
-    if ('Action' in event) {
-        if (event.Action === 'Invoke') {
-            return normalizeNowProxyEvent(event);
-        }
-        else {
-            throw new Error(`Unexpected event.Action: ${event.Action}`);
-        }
-    }
-    else {
-        return normalizeAPIGatewayProxyEvent(event);
-    }
-}
-class Bridge {
-    constructor(server, shouldStoreEvents = false) {
-        this.events = {};
-        this.reqIdSeed = 1;
-        this.shouldStoreEvents = false;
-        this.server = null;
-        this.shouldStoreEvents = shouldStoreEvents;
-        if (server) {
-            this.setServer(server);
-        }
-        this.launcher = this.launcher.bind(this);
-        // This is just to appease TypeScript strict mode, since it doesn't
-        // understand that the Promise constructor is synchronous
-        this.resolveListening = (_info) => { }; // eslint-disable-line @typescript-eslint/no-unused-vars
-        this.listening = new Promise(resolve => {
-            this.resolveListening = resolve;
-        });
-    }
-    setServer(server) {
-        this.server = server;
-    }
-    listen() {
-        const { server, resolveListening } = this;
-        if (!server) {
-            throw new Error('Server has not been set!');
-        }
-        if (typeof server.timeout === 'number' && server.timeout > 0) {
-            // Disable timeout (usually 2 minutes until Node 13).
-            // Instead, user should assign function `maxDuration`.
-            server.timeout = 0;
-        }
-        return server.listen({
-            host: '127.0.0.1',
-            port: 0,
-        }, function listeningCallback() {
-            if (!this || typeof this.address !== 'function') {
-                throw new Error('Missing server.address() function on `this` in server.listen()');
-            }
-            const addr = this.address();
-            if (!addr) {
-                throw new Error('`server.address()` returned `null`');
-            }
-            if (typeof addr === 'string') {
-                throw new Error(`Unexpected string for \`server.address()\`: ${addr}`);
-            }
-            resolveListening(addr);
-        });
-    }
-    async launcher(event, context) {
-        context.callbackWaitsForEmptyEventLoop = false;
-        const { port } = await this.listening;
-        const normalizedEvent = normalizeEvent(event);
-        const { isApiGateway, method, path, headers, body } = normalizedEvent;
-        if (this.shouldStoreEvents) {
-            const reqId = `${this.reqIdSeed++}`;
-            this.events[reqId] = normalizedEvent;
-            headers['x-now-bridge-request-id'] = reqId;
-        }
-        // eslint-disable-next-line consistent-return
-        return new Promise((resolve, reject) => {
-            const opts = { hostname: '127.0.0.1', port, path, method };
-            const req = http_1.request(opts, res => {
-                const response = res;
-                const respBodyChunks = [];
-                response.on('data', chunk => respBodyChunks.push(Buffer.from(chunk)));
-                response.on('error', reject);
-                response.on('end', () => {
-                    const bodyBuffer = Buffer.concat(respBodyChunks);
-                    delete response.headers.connection;
-                    if (isApiGateway) {
-                        delete response.headers['content-length'];
-                    }
-                    else if (response.headers['content-length']) {
-                        response.headers['content-length'] = String(bodyBuffer.length);
-                    }
-                    resolve({
-                        statusCode: response.statusCode || 200,
-                        headers: response.headers,
-                        body: bodyBuffer.toString('base64'),
-                        encoding: 'base64',
-                    });
-                });
-            });
-            req.on('error', error => {
-                setTimeout(() => {
-                    // this lets express print the true error of why the connection was closed.
-                    // it is probably 'Cannot set headers after they are sent to the client'
-                    reject(error);
-                }, 2);
-            });
-            for (const [name, value] of Object.entries(headers)) {
-                if (value === undefined) {
-                    console.error('Skipping HTTP request header %j because value is undefined', name);
-                    continue;
-                }
-                try {
-                    req.setHeader(name, value);
-                }
-                catch (err) {
-                    console.error('Skipping HTTP request header: %j', `${name}: ${value}`);
-                    console.error(err.message);
-                }
-            }
-            if (body)
-                req.write(body);
-            req.end();
-        });
-    }
-    consumeEvent(reqId) {
-        const event = this.events[reqId];
-        delete this.events[reqId];
-        return event;
-    }
-}
-exports.Bridge = Bridge;

package/dist/build-utils.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-let buildUtils;
-try {
-    buildUtils = require('@vercel/build-utils');
-}
-catch (e) {
-    // Fallback for older CLI versions
-    buildUtils = require('@now/build-utils');
-}
-exports.default = buildUtils;