@vercel/build-utils 2.12.3-canary.2 → 2.12.3-canary.23

package/dist/convert-runtime-to-plugin.d.ts

@@ -0,0 +1,73 @@
+import { Lambda } from './lambda';
+import type { BuilderFunctions, BuildOptions } from './types';
+/**
+ * Convert legacy Runtime to a Plugin.
+ * @param buildRuntime - a legacy build() function from a Runtime
+ * @param ext - the file extension, for example `.py`
+ */
+export declare function convertRuntimeToPlugin(buildRuntime: (options: BuildOptions) => Promise<{
+    output: Lambda;
+}>, ext: string): ({ vercelConfig, workPath, }: {
+    vercelConfig: {
+        functions?: BuilderFunctions;
+        regions?: string[];
+    };
+    workPath: string;
+}) => Promise<void>;
+/**
+ * If `.output/functions-manifest.json` exists, append to the pages
+ * property. Otherwise write a new file. This will also read `vercel.json`
+ * and apply relevant `functions` property config.
+ */
+export declare function updateFunctionsManifest({ vercelConfig, workPath, pages, }: {
+    vercelConfig: {
+        functions?: BuilderFunctions;
+        regions?: string[];
+    };
+    workPath: string;
+    pages: {
+        [key: string]: any;
+    };
+}): Promise<void>;
+/**
+ * Append routes to the `routes-manifest.json` file.
+ * If the file does not exist, it will be created.
+ */
+export declare function updateRoutesManifest({ workPath, redirects, rewrites, headers, dynamicRoutes, staticRoutes, }: {
+    workPath: string;
+    redirects?: {
+        source: string;
+        destination: string;
+        statusCode: number;
+        regex: string;
+    }[];
+    rewrites?: {
+        source: string;
+        destination: string;
+        regex: string;
+    }[];
+    headers?: {
+        source: string;
+        headers: {
+            key: string;
+            value: string;
+        }[];
+        regex: string;
+    }[];
+    dynamicRoutes?: {
+        page: string;
+        regex: string;
+        namedRegex?: string;
+        routeKeys?: {
+            [named: string]: string;
+        };
+    }[];
+    staticRoutes?: {
+        page: string;
+        regex: string;
+        namedRegex?: string;
+        routeKeys?: {
+            [named: string]: string;
+        };
+    }[];
+}): Promise<void>;

package/dist/convert-runtime-to-plugin.js

@@ -0,0 +1,173 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateRoutesManifest = exports.updateFunctionsManifest = exports.convertRuntimeToPlugin = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = require("path");
+const glob_1 = __importDefault(require("./fs/glob"));
+const normalize_path_1 = require("./fs/normalize-path");
+const lambda_1 = require("./lambda");
+const minimatch_1 = __importDefault(require("minimatch"));
+/**
+ * Convert legacy Runtime to a Plugin.
+ * @param buildRuntime - a legacy build() function from a Runtime
+ * @param ext - the file extension, for example `.py`
+ */
+function convertRuntimeToPlugin(buildRuntime, ext) {
+    // This `build()` signature should match `plugin.build()` signature in `vercel build`.
+    return async function build({ vercelConfig, workPath, }) {
+        const opts = { cwd: workPath };
+        const files = await glob_1.default('**', opts);
+        delete files['vercel.json']; // Builders/Runtimes didn't have vercel.json
+        const entrypoints = await glob_1.default(`api/**/*${ext}`, opts);
+        const pages = {};
+        const { functions = {} } = vercelConfig;
+        const traceDir = path_1.join(workPath, '.output', 'runtime-traced-files');
+        await fs_extra_1.default.ensureDir(traceDir);
+        for (const entrypoint of Object.keys(entrypoints)) {
+            const key = Object.keys(functions).find(src => src === entrypoint || minimatch_1.default(entrypoint, src)) || '';
+            const config = functions[key] || {};
+            const { output } = await buildRuntime({
+                files,
+                entrypoint,
+                workPath,
+                config: {
+                    zeroConfig: true,
+                    includeFiles: config.includeFiles,
+                    excludeFiles: config.excludeFiles,
+                },
+            });
+            pages[entrypoint] = {
+                handler: output.handler,
+                runtime: output.runtime,
+                memory: output.memory,
+                maxDuration: output.maxDuration,
+                environment: output.environment,
+                allowQuery: output.allowQuery,
+                //regions: output.regions,
+            };
+            // @ts-ignore This symbol is a private API
+            const lambdaFiles = output[lambda_1.FILES_SYMBOL];
+            const entry = path_1.join(workPath, '.output', 'server', 'pages', entrypoint);
+            await fs_extra_1.default.ensureDir(path_1.dirname(entry));
+            await linkOrCopy(files[entrypoint].fsPath, entry);
+            const tracedFiles = [];
+            Object.entries(lambdaFiles).forEach(async ([relPath, file]) => {
+                const newPath = path_1.join(traceDir, relPath);
+                tracedFiles.push({ absolutePath: newPath, relativePath: relPath });
+                if (file.fsPath) {
+                    await linkOrCopy(file.fsPath, newPath);
+                }
+                else if (file.type === 'FileBlob') {
+                    const { data, mode } = file;
+                    await fs_extra_1.default.writeFile(newPath, data, { mode });
+                }
+                else {
+                    throw new Error(`Unknown file type: ${file.type}`);
+                }
+            });
+            const nft = path_1.join(workPath, '.output', 'server', 'pages', `${entrypoint}.nft.json`);
+            const json = JSON.stringify({
+                version: 1,
+                files: tracedFiles.map(f => ({
+                    input: normalize_path_1.normalizePath(path_1.relative(nft, f.absolutePath)),
+                    output: normalize_path_1.normalizePath(f.relativePath),
+                })),
+            });
+            await fs_extra_1.default.ensureDir(path_1.dirname(nft));
+            await fs_extra_1.default.writeFile(nft, json);
+        }
+        await updateFunctionsManifest({ vercelConfig, workPath, pages });
+    };
+}
+exports.convertRuntimeToPlugin = convertRuntimeToPlugin;
+async function linkOrCopy(existingPath, newPath) {
+    try {
+        await fs_extra_1.default.createLink(existingPath, newPath);
+    }
+    catch (err) {
+        if (err.code !== 'EEXIST') {
+            await fs_extra_1.default.copyFile(existingPath, newPath);
+        }
+    }
+}
+async function readJson(filePath) {
+    try {
+        const str = await fs_extra_1.default.readFile(filePath, 'utf8');
+        return JSON.parse(str);
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            return {};
+        }
+        throw err;
+    }
+}
+/**
+ * If `.output/functions-manifest.json` exists, append to the pages
+ * property. Otherwise write a new file. This will also read `vercel.json`
+ * and apply relevant `functions` property config.
+ */
+async function updateFunctionsManifest({ vercelConfig, workPath, pages, }) {
+    const functionsManifestPath = path_1.join(workPath, '.output', 'functions-manifest.json');
+    const functionsManifest = await readJson(functionsManifestPath);
+    if (!functionsManifest.version)
+        functionsManifest.version = 1;
+    if (!functionsManifest.pages)
+        functionsManifest.pages = {};
+    for (const [pageKey, pageConfig] of Object.entries(pages)) {
+        const fnConfig = await lambda_1.getLambdaOptionsFromFunction({
+            sourceFile: pageKey,
+            config: vercelConfig,
+        });
+        functionsManifest.pages[pageKey] = {
+            ...pageConfig,
+            memory: fnConfig.memory || pageConfig.memory,
+            maxDuration: fnConfig.maxDuration || pageConfig.maxDuration,
+            regions: vercelConfig.regions || pageConfig.regions,
+        };
+    }
+    await fs_extra_1.default.writeFile(functionsManifestPath, JSON.stringify(functionsManifest));
+}
+exports.updateFunctionsManifest = updateFunctionsManifest;
+/**
+ * Append routes to the `routes-manifest.json` file.
+ * If the file does not exist, it will be created.
+ */
+async function updateRoutesManifest({ workPath, redirects, rewrites, headers, dynamicRoutes, staticRoutes, }) {
+    const routesManifestPath = path_1.join(workPath, '.output', 'routes-manifest.json');
+    const routesManifest = await readJson(routesManifestPath);
+    if (!routesManifest.version)
+        routesManifest.version = 3;
+    if (routesManifest.pages404 === undefined)
+        routesManifest.pages404 = true;
+    if (redirects) {
+        if (!routesManifest.redirects)
+            routesManifest.redirects = [];
+        routesManifest.redirects.push(...redirects);
+    }
+    if (rewrites) {
+        if (!routesManifest.rewrites)
+            routesManifest.rewrites = [];
+        routesManifest.rewrites.push(...rewrites);
+    }
+    if (headers) {
+        if (!routesManifest.headers)
+            routesManifest.headers = [];
+        routesManifest.headers.push(...headers);
+    }
+    if (dynamicRoutes) {
+        if (!routesManifest.dynamicRoutes)
+            routesManifest.dynamicRoutes = [];
+        routesManifest.dynamicRoutes.push(...dynamicRoutes);
+    }
+    if (staticRoutes) {
+        if (!routesManifest.staticRoutes)
+            routesManifest.staticRoutes = [];
+        routesManifest.staticRoutes.push(...staticRoutes);
+    }
+    await fs_extra_1.default.writeFile(routesManifestPath, JSON.stringify(routesManifest));
+}
+exports.updateRoutesManifest = updateRoutesManifest;

package/dist/detect-builders.d.ts

@@ -34,5 +34,11 @@ export declare function detectBuilders(files: string[], pkg?: PackageJson | unde
     redirectRoutes: Route[] | null;
     rewriteRoutes: Route[] | null;
     errorRoutes: Route[] | null;
+    limitedRoutes: LimitedRoutes | null;
 }>;
+interface LimitedRoutes {
+    defaultRoutes: Route[];
+    redirectRoutes: Route[];
+    rewriteRoutes: Route[];
+}
 export {};

package/dist/detect-builders.js

@@ -66,6 +66,7 @@ async function detectBuilders(files, pkg, options = {}) {
             redirectRoutes: null,
             rewriteRoutes: null,
             errorRoutes: null,
+            limitedRoutes: null,
         };
     }
     const sortedFiles = files.sort(sortFiles);
@@ -113,6 +114,7 @@ async function detectBuilders(files, pkg, options = {}) {
                     redirectRoutes: null,
                     rewriteRoutes: null,
                     errorRoutes: null,
+                    limitedRoutes: null,
                 };
             }
             if (apiRoute) {
@@ -167,6 +169,7 @@ async function detectBuilders(files, pkg, options = {}) {
                 defaultRoutes: null,
                 rewriteRoutes: null,
                 errorRoutes: null,
+                limitedRoutes: null,
             };
         }
         // If `outputDirectory` is an empty string,
@@ -203,6 +206,7 @@ async function detectBuilders(files, pkg, options = {}) {
             defaultRoutes: null,
             rewriteRoutes: null,
             errorRoutes: null,
+            limitedRoutes: null,
         };
     }
     const builders = [];
@@ -221,7 +225,7 @@ async function detectBuilders(files, pkg, options = {}) {
             });
         }
     }
-    const routesResult = getRouteResult(apiRoutes, dynamicRoutes, usedOutputDirectory, apiBuilders, frontendBuilder, options);
+    const routesResult = getRouteResult(pkg, apiRoutes, dynamicRoutes, usedOutputDirectory, apiBuilders, frontendBuilder, options);
     return {
         warnings,
         builders: builders.length ? builders : null,
@@ -230,6 +234,7 @@ async function detectBuilders(files, pkg, options = {}) {
         defaultRoutes: routesResult.defaultRoutes,
         rewriteRoutes: routesResult.rewriteRoutes,
         errorRoutes: routesResult.errorRoutes,
+        limitedRoutes: routesResult.limitedRoutes,
     };
 }
 exports.detectBuilders = detectBuilders;
@@ -670,23 +675,51 @@ function createRouteFromPath(filePath, featHandleMiss, cleanUrls) {
     }
     return { route, isDynamic };
 }
-function getRouteResult(apiRoutes, dynamicRoutes, outputDirectory, apiBuilders, frontendBuilder, options) {
+function getRouteResult(pkg, apiRoutes, dynamicRoutes, outputDirectory, apiBuilders, frontendBuilder, options) {
     var _a, _b;
+    const deps = Object.assign({}, pkg === null || pkg === void 0 ? void 0 : pkg.dependencies, pkg === null || pkg === void 0 ? void 0 : pkg.devDependencies);
     const defaultRoutes = [];
     const redirectRoutes = [];
     const rewriteRoutes = [];
     const errorRoutes = [];
+    const limitedRoutes = {
+        defaultRoutes: [],
+        redirectRoutes: [],
+        rewriteRoutes: [],
+    };
     const framework = ((_a = frontendBuilder === null || frontendBuilder === void 0 ? void 0 : frontendBuilder.config) === null || _a === void 0 ? void 0 : _a.framework) || '';
     const isNextjs = framework === 'nextjs' || _1.isOfficialRuntime('next', frontendBuilder === null || frontendBuilder === void 0 ? void 0 : frontendBuilder.use);
     const ignoreRuntimes = (_b = slugToFramework.get(framework)) === null || _b === void 0 ? void 0 : _b.ignoreRuntimes;
     if (apiRoutes && apiRoutes.length > 0) {
         if (options.featHandleMiss) {
+            // Exclude extension names if the corresponding plugin is not found in package.json
+            // detectBuilders({ignoreRoutesForBuilders: ['@vercel/python']})
+            // return a copy of routes.
+            // We should exclud errorRoutes and
             const extSet = detectApiExtensions(apiBuilders);
+            const withTag = options.tag ? `@${options.tag}` : '';
+            const extSetLimited = detectApiExtensions(apiBuilders.filter(b => {
+                if (b.use === `@vercel/python${withTag}` &&
+                    !('vercel-plugin-python' in deps)) {
+                    return false;
+                }
+                if (b.use === `@vercel/go${withTag}` &&
+                    !('vercel-plugin-go' in deps)) {
+                    return false;
+                }
+                if (b.use === `@vercel/ruby${withTag}` &&
+                    !('vercel-plugin-ruby' in deps)) {
+                    return false;
+                }
+                return true;
+            }));
             if (extSet.size > 0) {
-                const exts = Array.from(extSet)
+                const extGroup = `(?:\\.(?:${Array.from(extSet)
                     .map(ext => ext.slice(1))
-                    .join('|');
-                const extGroup = `(?:\\.(?:${exts}))`;
+                    .join('|')}))`;
+                const extGroupLimited = `(?:\\.(?:${Array.from(extSetLimited)
+                    .map(ext => ext.slice(1))
+                    .join('|')}))`;
                 if (options.cleanUrls) {
                     redirectRoutes.push({
                         src: `^/(api(?:.+)?)/index${extGroup}?/?$`,
@@ -700,6 +733,18 @@ function getRouteResult(apiRoutes, dynamicRoutes, outputDirectory, apiBuilders,
                         },
                         status: 308,
                     });
+                    limitedRoutes.redirectRoutes.push({
+                        src: `^/(api(?:.+)?)/index${extGroupLimited}?/?$`,
+                        headers: { Location: options.trailingSlash ? '/$1/' : '/$1' },
+                        status: 308,
+                    });
+                    limitedRoutes.redirectRoutes.push({
+                        src: `^/api/(.+)${extGroupLimited}/?$`,
+                        headers: {
+                            Location: options.trailingSlash ? '/api/$1/' : '/api/$1',
+                        },
+                        status: 308,
+                    });
                 }
                 else {
                     defaultRoutes.push({ handle: 'miss' });
@@ -708,9 +753,16 @@ function getRouteResult(apiRoutes, dynamicRoutes, outputDirectory, apiBuilders,
                         dest: '/api/$1',
                         check: true,
                     });
+                    limitedRoutes.defaultRoutes.push({ handle: 'miss' });
+                    limitedRoutes.defaultRoutes.push({
+                        src: `^/api/(.+)${extGroupLimited}$`,
+                        dest: '/api/$1',
+                        check: true,
+                    });
                 }
             }
             rewriteRoutes.push(...dynamicRoutes);
+            limitedRoutes.rewriteRoutes.push(...dynamicRoutes);
             if (typeof ignoreRuntimes === 'undefined') {
                 // This route is only necessary to hide the directory listing
                 // to avoid enumerating serverless function names.
@@ -755,6 +807,7 @@ function getRouteResult(apiRoutes, dynamicRoutes, outputDirectory, apiBuilders,
         redirectRoutes,
         rewriteRoutes,
         errorRoutes,
+        limitedRoutes,
     };
 }
 function sortFilesBySegmentCount(fileA, fileB) {

package/dist/fs/glob.js

@@ -8,6 +8,7 @@ const assert_1 = __importDefault(require("assert"));
 const glob_1 = __importDefault(require("glob"));
 const util_1 = require("util");
 const fs_extra_1 = require("fs-extra");
+const normalize_path_1 = require("./normalize-path");
 const file_fs_ref_1 = __importDefault(require("../file-fs-ref"));
 const vanillaGlob = util_1.promisify(glob_1.default);
 async function glob(pattern, opts, mountpoint) {
@@ -31,7 +32,7 @@ async function glob(pattern, opts, mountpoint) {
     options.dot = true;
     const files = await vanillaGlob(pattern, options);
     for (const relativePath of files) {
-        const fsPath = path_1.default.join(options.cwd, relativePath).replace(/\\/g, '/');
+        const fsPath = normalize_path_1.normalizePath(path_1.default.join(options.cwd, relativePath));
         let stat = options.statCache[fsPath];
         assert_1.default(stat, `statCache does not contain value for ${relativePath} (resolved to ${fsPath})`);
         const isSymlink = options.symlinks[fsPath];

package/dist/fs/normalize-path.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Convert Windows separators to Unix separators.
+ */
+export declare function normalizePath(p: string): string;

package/dist/fs/normalize-path.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizePath = void 0;
+const isWin = process.platform === 'win32';
+/**
+ * Convert Windows separators to Unix separators.
+ */
+function normalizePath(p) {
+    return isWin ? p.replace(/\\/g, '/') : p;
+}
+exports.normalizePath = normalizePath;

package/dist/index.d.ts

@@ -17,6 +17,8 @@ export { detectBuilders, detectOutputDirectory, detectApiDirectory, detectApiExt
 export { detectFramework } from './detect-framework';
 export { DetectorFilesystem } from './detectors/filesystem';
 export { readConfigFile } from './fs/read-config-file';
+export { normalizePath } from './fs/normalize-path';
+export { convertRuntimeToPlugin, updateFunctionsManifest, updateRoutesManifest, } from './convert-runtime-to-plugin';
 export * from './schemas';
 export * from './types';
 export * from './errors';