@vercel/build-utils 2.12.3-canary.13 → 2.12.3-canary.17

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

@@ -0,0 +1,12 @@
+import { Lambda } from './lambda';
+import type { 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): ({ workPath }: {
+    workPath: string;
+}) => Promise<void>;

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

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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) {
+    return async function build({ 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 functionsManifest = {};
+        const functions = await readVercelConfigFunctions(workPath);
+        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,
+                },
+            });
+            functionsManifest[entrypoint] = {
+                handler: output.handler,
+                runtime: output.runtime,
+                memory: config.memory || output.memory,
+                maxDuration: config.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 fs_extra_1.default.writeFile(path_1.join(workPath, '.output', 'functions-manifest.json'), JSON.stringify(functionsManifest));
+    };
+}
+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 readVercelConfigFunctions(workPath) {
+    const vercelJsonPath = path_1.join(workPath, 'vercel.json');
+    try {
+        const str = await fs_extra_1.default.readFile(vercelJsonPath, 'utf8');
+        const obj = JSON.parse(str);
+        return obj.functions || {};
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            return {};
+        }
+        throw err;
+    }
+}

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 } from './convert-runtime-to-plugin';
 export * from './schemas';
 export * from './types';
 export * from './errors';