@vercel/build-utils 2.12.3-canary.32 → 2.12.3-canary.33

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

@@ -77,6 +77,8 @@ function convertRuntimeToPlugin(buildRuntime, packageName, ext) {
         // need to be able to easily inspect the output.
         `api-routes-${pluginName}`);
         await fs_extra_1.default.ensureDir(traceDir);
+        let newPathsRuntime = new Set();
+        let linkersRuntime = [];
         for (const entrypoint of Object.keys(entrypoints)) {
             const { output } = await buildRuntime({
                 files: sourceFilesPreBuild,
@@ -133,35 +135,93 @@ function convertRuntimeToPlugin(buildRuntime, packageName, ext) {
             const entry = path_1.join(workPath, '.output', 'server', 'pages', entrypoint);
             await fs_extra_1.default.ensureDir(path_1.dirname(entry));
             await linkOrCopy(handlerFileOrigin, entry);
-            const toRemove = [];
-            // You can find more details about this at the point where the
-            // `sourceFilesAfterBuild` is created originally.
+            const newFilesEntrypoint = [];
+            const newDirectoriesEntrypoint = [];
+            const preBuildFiles = Object.values(sourceFilesPreBuild).map(file => {
+                return file.fsPath;
+            });
+            // Generate a list of directories and files that weren't present
+            // before the entrypoint was processed by the Legacy Runtime, so
+            // that we can perform a cleanup later. We need to divide into files
+            // and directories because only cleaning up files might leave empty
+            // directories, and listing directories separately also speeds up the
+            // build because we can just delete them, which wipes all of their nested
+            // paths, instead of iterating through all files that should be deleted.
             for (const file in sourceFilesAfterBuild) {
                 if (!sourceFilesPreBuild[file]) {
                     const path = sourceFilesAfterBuild[file].fsPath;
-                    toRemove.push(fs_extra_1.default.remove(path));
+                    const dirPath = path_1.dirname(path);
+                    // If none of the files that were present before the entrypoint
+                    // was processed are contained within the directory we're looking
+                    // at right now, then we know it's a newly added directory
+                    // and it can therefore be removed later on.
+                    const isNewDir = !preBuildFiles.some(filePath => {
+                        return path_1.dirname(filePath).startsWith(dirPath);
+                    });
+                    // Check out the list of tracked directories that were
+                    // newly added and see if one of them contains the path
+                    // we're looking at.
+                    const hasParentDir = newDirectoriesEntrypoint.some(dir => {
+                        return path.startsWith(dir);
+                    });
+                    // If we have already tracked a directory that was newly
+                    // added that sits above the file or directory that we're
+                    // looking at, we don't need to add more entries to the list
+                    // because when the parent will get removed in the future,
+                    // all of its children (and therefore the path we're looking at)
+                    // will automatically get removed anyways.
+                    if (hasParentDir) {
+                        continue;
+                    }
+                    if (isNewDir) {
+                        newDirectoriesEntrypoint.push(dirPath);
+                    }
+                    else {
+                        newFilesEntrypoint.push(path);
+                    }
                 }
             }
-            await Promise.all(toRemove);
             const tracedFiles = [];
-            Object.entries(lambdaFiles).forEach(async ([relPath, file]) => {
+            const linkers = Object.entries(lambdaFiles).map(async ([relPath, file]) => {
                 const newPath = path_1.join(traceDir, relPath);
                 // The handler was already moved into position above.
                 if (relPath === handlerFilePath) {
                     return;
                 }
                 tracedFiles.push({ absolutePath: newPath, relativePath: relPath });
-                if (file.fsPath) {
-                    await linkOrCopy(file.fsPath, newPath);
+                const { fsPath, type } = file;
+                if (fsPath) {
+                    await fs_extra_1.default.ensureDir(path_1.dirname(newPath));
+                    const isNewFile = newFilesEntrypoint.includes(fsPath);
+                    const isInsideNewDirectory = newDirectoriesEntrypoint.some(dirPath => {
+                        return fsPath.startsWith(dirPath);
+                    });
+                    // With this, we're making sure that files in the `workPath` that existed
+                    // before the Legacy Runtime was invoked (source files) are linked from
+                    // `.output` instead of copying there (the latter only happens if linking fails),
+                    // which is the fastest solution. However, files that are created fresh
+                    // by the Legacy Runtimes are always copied, because their link destinations
+                    // are likely to be overwritten every time an entrypoint is processed by
+                    // the Legacy Runtime. This is likely to overwrite the destination on subsequent
+                    // runs, but that's also how `workPath` used to work originally, without
+                    // the File System API (meaning that there was one `workPath` for all entrypoints).
+                    if (isNewFile || isInsideNewDirectory) {
+                        _1.debug(`Copying from ${fsPath} to ${newPath}`);
+                        await fs_extra_1.default.copy(fsPath, newPath);
+                    }
+                    else {
+                        await linkOrCopy(fsPath, newPath);
+                    }
                 }
-                else if (file.type === 'FileBlob') {
+                else if (type === 'FileBlob') {
                     const { data, mode } = file;
                     await fs_extra_1.default.writeFile(newPath, data, { mode });
                 }
                 else {
-                    throw new Error(`Unknown file type: ${file.type}`);
+                    throw new Error(`Unknown file type: ${type}`);
                 }
             });
+            linkersRuntime = linkersRuntime.concat(linkers);
             const nft = path_1.join(workPath, '.output', 'server', 'pages', `${entrypoint}.nft.json`);
             const json = JSON.stringify({
                 version: 1,
@@ -172,7 +232,34 @@ function convertRuntimeToPlugin(buildRuntime, packageName, ext) {
             });
             await fs_extra_1.default.ensureDir(path_1.dirname(nft));
             await fs_extra_1.default.writeFile(nft, json);
+            // Extend the list of directories and files that were created by the
+            // Legacy Runtime with the list of directories and files that were
+            // created for the entrypoint that was just processed above.
+            newPathsRuntime = new Set([
+                ...newPathsRuntime,
+                ...newFilesEntrypoint,
+                ...newDirectoriesEntrypoint,
+            ]);
         }
+        // Instead of of waiting for all of the linking to be done for every
+        // entrypoint before processing the next one, we immediately handle all
+        // of them one after the other, while then waiting for the linking
+        // to finish right here, before we clean up newly created files below.
+        await Promise.all(linkersRuntime);
+        // A list of all the files that were created by the Legacy Runtime,
+        // which we'd like to remove from the File System.
+        const toRemove = Array.from(newPathsRuntime).map(path => {
+            _1.debug(`Removing ${path} as part of cleanup`);
+            return fs_extra_1.default.remove(path);
+        });
+        // Once all the entrypoints have been processed, we'd like to
+        // remove all the files from `workPath` that originally weren't present
+        // before the Legacy Runtime began running, because the `workPath`
+        // is nowadays the directory in which the user keeps their source code, since
+        // we're no longer running separate parallel builds for every Legacy Runtime.
+        await Promise.all(toRemove);
+        // Add any Serverless Functions that were exposed by the Legacy Runtime
+        // to the `functions-manifest.json` file provided in `.output`.
         await updateFunctionsManifest({ workPath, pages });
     };
 }

package/dist/index.js

@@ -32824,6 +32824,8 @@ function convertRuntimeToPlugin(buildRuntime, packageName, ext) {
         // need to be able to easily inspect the output.
         `api-routes-${pluginName}`);
         await fs_extra_1.default.ensureDir(traceDir);
+        let newPathsRuntime = new Set();
+        let linkersRuntime = [];
         for (const entrypoint of Object.keys(entrypoints)) {
             const { output } = await buildRuntime({
                 files: sourceFilesPreBuild,
@@ -32880,35 +32882,93 @@ function convertRuntimeToPlugin(buildRuntime, packageName, ext) {
             const entry = path_1.join(workPath, '.output', 'server', 'pages', entrypoint);
             await fs_extra_1.default.ensureDir(path_1.dirname(entry));
             await linkOrCopy(handlerFileOrigin, entry);
-            const toRemove = [];
-            // You can find more details about this at the point where the
-            // `sourceFilesAfterBuild` is created originally.
+            const newFilesEntrypoint = [];
+            const newDirectoriesEntrypoint = [];
+            const preBuildFiles = Object.values(sourceFilesPreBuild).map(file => {
+                return file.fsPath;
+            });
+            // Generate a list of directories and files that weren't present
+            // before the entrypoint was processed by the Legacy Runtime, so
+            // that we can perform a cleanup later. We need to divide into files
+            // and directories because only cleaning up files might leave empty
+            // directories, and listing directories separately also speeds up the
+            // build because we can just delete them, which wipes all of their nested
+            // paths, instead of iterating through all files that should be deleted.
             for (const file in sourceFilesAfterBuild) {
                 if (!sourceFilesPreBuild[file]) {
                     const path = sourceFilesAfterBuild[file].fsPath;
-                    toRemove.push(fs_extra_1.default.remove(path));
+                    const dirPath = path_1.dirname(path);
+                    // If none of the files that were present before the entrypoint
+                    // was processed are contained within the directory we're looking
+                    // at right now, then we know it's a newly added directory
+                    // and it can therefore be removed later on.
+                    const isNewDir = !preBuildFiles.some(filePath => {
+                        return path_1.dirname(filePath).startsWith(dirPath);
+                    });
+                    // Check out the list of tracked directories that were
+                    // newly added and see if one of them contains the path
+                    // we're looking at.
+                    const hasParentDir = newDirectoriesEntrypoint.some(dir => {
+                        return path.startsWith(dir);
+                    });
+                    // If we have already tracked a directory that was newly
+                    // added that sits above the file or directory that we're
+                    // looking at, we don't need to add more entries to the list
+                    // because when the parent will get removed in the future,
+                    // all of its children (and therefore the path we're looking at)
+                    // will automatically get removed anyways.
+                    if (hasParentDir) {
+                        continue;
+                    }
+                    if (isNewDir) {
+                        newDirectoriesEntrypoint.push(dirPath);
+                    }
+                    else {
+                        newFilesEntrypoint.push(path);
+                    }
                 }
             }
-            await Promise.all(toRemove);
             const tracedFiles = [];
-            Object.entries(lambdaFiles).forEach(async ([relPath, file]) => {
+            const linkers = Object.entries(lambdaFiles).map(async ([relPath, file]) => {
                 const newPath = path_1.join(traceDir, relPath);
                 // The handler was already moved into position above.
                 if (relPath === handlerFilePath) {
                     return;
                 }
                 tracedFiles.push({ absolutePath: newPath, relativePath: relPath });
-                if (file.fsPath) {
-                    await linkOrCopy(file.fsPath, newPath);
+                const { fsPath, type } = file;
+                if (fsPath) {
+                    await fs_extra_1.default.ensureDir(path_1.dirname(newPath));
+                    const isNewFile = newFilesEntrypoint.includes(fsPath);
+                    const isInsideNewDirectory = newDirectoriesEntrypoint.some(dirPath => {
+                        return fsPath.startsWith(dirPath);
+                    });
+                    // With this, we're making sure that files in the `workPath` that existed
+                    // before the Legacy Runtime was invoked (source files) are linked from
+                    // `.output` instead of copying there (the latter only happens if linking fails),
+                    // which is the fastest solution. However, files that are created fresh
+                    // by the Legacy Runtimes are always copied, because their link destinations
+                    // are likely to be overwritten every time an entrypoint is processed by
+                    // the Legacy Runtime. This is likely to overwrite the destination on subsequent
+                    // runs, but that's also how `workPath` used to work originally, without
+                    // the File System API (meaning that there was one `workPath` for all entrypoints).
+                    if (isNewFile || isInsideNewDirectory) {
+                        _1.debug(`Copying from ${fsPath} to ${newPath}`);
+                        await fs_extra_1.default.copy(fsPath, newPath);
+                    }
+                    else {
+                        await linkOrCopy(fsPath, newPath);
+                    }
                 }
-                else if (file.type === 'FileBlob') {
+                else if (type === 'FileBlob') {
                     const { data, mode } = file;
                     await fs_extra_1.default.writeFile(newPath, data, { mode });
                 }
                 else {
-                    throw new Error(`Unknown file type: ${file.type}`);
+                    throw new Error(`Unknown file type: ${type}`);
                 }
             });
+            linkersRuntime = linkersRuntime.concat(linkers);
             const nft = path_1.join(workPath, '.output', 'server', 'pages', `${entrypoint}.nft.json`);
             const json = JSON.stringify({
                 version: 1,
@@ -32919,7 +32979,34 @@ function convertRuntimeToPlugin(buildRuntime, packageName, ext) {
             });
             await fs_extra_1.default.ensureDir(path_1.dirname(nft));
             await fs_extra_1.default.writeFile(nft, json);
+            // Extend the list of directories and files that were created by the
+            // Legacy Runtime with the list of directories and files that were
+            // created for the entrypoint that was just processed above.
+            newPathsRuntime = new Set([
+                ...newPathsRuntime,
+                ...newFilesEntrypoint,
+                ...newDirectoriesEntrypoint,
+            ]);
         }
+        // Instead of of waiting for all of the linking to be done for every
+        // entrypoint before processing the next one, we immediately handle all
+        // of them one after the other, while then waiting for the linking
+        // to finish right here, before we clean up newly created files below.
+        await Promise.all(linkersRuntime);
+        // A list of all the files that were created by the Legacy Runtime,
+        // which we'd like to remove from the File System.
+        const toRemove = Array.from(newPathsRuntime).map(path => {
+            _1.debug(`Removing ${path} as part of cleanup`);
+            return fs_extra_1.default.remove(path);
+        });
+        // Once all the entrypoints have been processed, we'd like to
+        // remove all the files from `workPath` that originally weren't present
+        // before the Legacy Runtime began running, because the `workPath`
+        // is nowadays the directory in which the user keeps their source code, since
+        // we're no longer running separate parallel builds for every Legacy Runtime.
+        await Promise.all(toRemove);
+        // Add any Serverless Functions that were exposed by the Legacy Runtime
+        // to the `functions-manifest.json` file provided in `.output`.
         await updateFunctionsManifest({ workPath, pages });
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/build-utils",
-  "version": "2.12.3-canary.32",
+  "version": "2.12.3-canary.33",
   "license": "MIT",
   "main": "./dist/index.js",
   "types": "./dist/index.d.js",
@@ -49,5 +49,5 @@
     "typescript": "4.3.4",
     "yazl": "2.4.3"
   },
-  "gitHead": "ba7bf2e4a60bc4c9fd35ad33a11d94f1dae2ac81"
+  "gitHead": "5efd3b98deb33029180ac40b0e30df1155c1ea5d"
 }