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

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

@@ -77,6 +77,10 @@ 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 = [];
+        const entryDir = path_1.join('.output', 'server', 'pages');
+        const entryRoot = path_1.join(workPath, entryDir);
         for (const entrypoint of Object.keys(entrypoints)) {
             const { output } = await buildRuntime({
                 files: sourceFilesPreBuild,
@@ -96,22 +100,6 @@ function convertRuntimeToPlugin(buildRuntime, packageName, ext) {
             // so we don't want to pollute this space unnecessarily. That means we have to clean
             // up files that were created by the build, which is done further below.
             const sourceFilesAfterBuild = await getSourceFiles(workPath, ignoreFilter);
-            // Further down, we will need the filename of the Lambda handler
-            // for placing it inside `server/pages/api`, but because Legacy Runtimes
-            // don't expose the filename directly, we have to construct it
-            // from the handler name, and then find the matching file further below,
-            // because we don't yet know its extension here.
-            const handler = output.handler;
-            const handlerMethod = handler.split('.').reverse()[0];
-            const handlerFileName = handler.replace(`.${handlerMethod}`, '');
-            pages[entrypoint] = {
-                handler: handler,
-                runtime: output.runtime,
-                memory: output.memory,
-                maxDuration: output.maxDuration,
-                environment: output.environment,
-                allowQuery: output.allowQuery,
-            };
             // @ts-ignore This symbol is a private API
             const lambdaFiles = output[lambda_1.FILES_SYMBOL];
             // When deploying, the `files` that are passed to the Legacy Runtimes already
@@ -123,56 +111,174 @@ function convertRuntimeToPlugin(buildRuntime, packageName, ext) {
                     delete lambdaFiles[file];
                 }
             }
-            const handlerFilePath = Object.keys(lambdaFiles).find(item => {
-                return path_1.parse(item).name === handlerFileName;
-            });
-            const handlerFileOrigin = lambdaFiles[handlerFilePath || ''].fsPath;
-            if (!handlerFileOrigin) {
-                throw new Error(`Could not find a handler file. Please ensure that the list of \`files\` defined for the returned \`Lambda\` contains a file with the name ${handlerFileName} (+ any extension).`);
+            let handlerFileBase = output.handler;
+            let handlerFile = lambdaFiles[handlerFileBase];
+            const { handler } = output;
+            const handlerMethod = handler.split('.').pop();
+            const handlerFileName = handler.replace(`.${handlerMethod}`, '');
+            // For compiled languages, the launcher file for the Lambda generated
+            // by the Legacy Runtime matches the `handler` defined for it, but for
+            // interpreted languages, the `handler` consists of the launcher file name
+            // without an extension, plus the name of the method inside of that file
+            // that should be invoked, so we have to construct the file path explicitly.
+            if (!handlerFile) {
+                handlerFileBase = handlerFileName + ext;
+                handlerFile = lambdaFiles[handlerFileBase];
             }
-            const entry = path_1.join(workPath, '.output', 'server', 'pages', entrypoint);
+            if (!handlerFile || !handlerFile.fsPath) {
+                throw new Error(`Could not find a handler file. Please ensure that \`files\` for the returned \`Lambda\` contains an \`FileFsRef\` named "${handlerFileBase}" with a valid \`fsPath\`.`);
+            }
+            const handlerExtName = path_1.extname(handlerFile.fsPath);
+            const entryBase = path_1.basename(entrypoint).replace(ext, handlerExtName);
+            const entryPath = path_1.join(path_1.dirname(entrypoint), entryBase);
+            const entry = path_1.join(entryRoot, entryPath);
+            // We never want to link here, only copy, because the launcher
+            // file often has the same name for every entrypoint, which means that
+            // every build for every entrypoint overwrites the launcher of the previous
+            // one, so linking would end with a broken reference.
             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.
+            await fs_extra_1.default.copy(handlerFile.fsPath, entry);
+            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) {
+                if (relPath === handlerFileBase) {
                     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}`);
                 }
             });
-            const nft = path_1.join(workPath, '.output', 'server', 'pages', `${entrypoint}.nft.json`);
+            linkersRuntime = linkersRuntime.concat(linkers);
+            const nft = `${entry}.nft.json`;
             const json = JSON.stringify({
                 version: 1,
                 files: tracedFiles.map(file => ({
                     input: normalize_path_1.normalizePath(path_1.relative(path_1.dirname(nft), file.absolutePath)),
-                    output: normalize_path_1.normalizePath(file.relativePath),
+                    // We'd like to place all the dependency files right next
+                    // to the final launcher file inside of the Lambda.
+                    output: normalize_path_1.normalizePath(path_1.join(entryDir, 'api', file.relativePath)),
                 })),
             });
             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,
+            ]);
+            // Add an entry that will later on be added to the `functions-manifest.json`
+            // file that is placed inside of the `.output` directory.
+            pages[normalize_path_1.normalizePath(entryPath)] = {
+                // Because the underlying file used as a handler was placed
+                // inside `.output/server/pages/api`, it no longer has the name it originally
+                // had and is now named after the API Route that it's responsible for,
+                // so we have to adjust the name of the Lambda handler accordingly.
+                handler: handler.replace(handlerFileName, path_1.parse(entry).name),
+                runtime: output.runtime,
+                memory: output.memory,
+                maxDuration: output.maxDuration,
+                environment: output.environment,
+                allowQuery: output.allowQuery,
+            };
         }
+        // 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,10 @@ 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 = [];
+        const entryDir = path_1.join('.output', 'server', 'pages');
+        const entryRoot = path_1.join(workPath, entryDir);
         for (const entrypoint of Object.keys(entrypoints)) {
             const { output } = await buildRuntime({
                 files: sourceFilesPreBuild,
@@ -32843,22 +32847,6 @@ function convertRuntimeToPlugin(buildRuntime, packageName, ext) {
             // so we don't want to pollute this space unnecessarily. That means we have to clean
             // up files that were created by the build, which is done further below.
             const sourceFilesAfterBuild = await getSourceFiles(workPath, ignoreFilter);
-            // Further down, we will need the filename of the Lambda handler
-            // for placing it inside `server/pages/api`, but because Legacy Runtimes
-            // don't expose the filename directly, we have to construct it
-            // from the handler name, and then find the matching file further below,
-            // because we don't yet know its extension here.
-            const handler = output.handler;
-            const handlerMethod = handler.split('.').reverse()[0];
-            const handlerFileName = handler.replace(`.${handlerMethod}`, '');
-            pages[entrypoint] = {
-                handler: handler,
-                runtime: output.runtime,
-                memory: output.memory,
-                maxDuration: output.maxDuration,
-                environment: output.environment,
-                allowQuery: output.allowQuery,
-            };
             // @ts-ignore This symbol is a private API
             const lambdaFiles = output[lambda_1.FILES_SYMBOL];
             // When deploying, the `files` that are passed to the Legacy Runtimes already
@@ -32870,56 +32858,174 @@ function convertRuntimeToPlugin(buildRuntime, packageName, ext) {
                     delete lambdaFiles[file];
                 }
             }
-            const handlerFilePath = Object.keys(lambdaFiles).find(item => {
-                return path_1.parse(item).name === handlerFileName;
-            });
-            const handlerFileOrigin = lambdaFiles[handlerFilePath || ''].fsPath;
-            if (!handlerFileOrigin) {
-                throw new Error(`Could not find a handler file. Please ensure that the list of \`files\` defined for the returned \`Lambda\` contains a file with the name ${handlerFileName} (+ any extension).`);
+            let handlerFileBase = output.handler;
+            let handlerFile = lambdaFiles[handlerFileBase];
+            const { handler } = output;
+            const handlerMethod = handler.split('.').pop();
+            const handlerFileName = handler.replace(`.${handlerMethod}`, '');
+            // For compiled languages, the launcher file for the Lambda generated
+            // by the Legacy Runtime matches the `handler` defined for it, but for
+            // interpreted languages, the `handler` consists of the launcher file name
+            // without an extension, plus the name of the method inside of that file
+            // that should be invoked, so we have to construct the file path explicitly.
+            if (!handlerFile) {
+                handlerFileBase = handlerFileName + ext;
+                handlerFile = lambdaFiles[handlerFileBase];
             }
-            const entry = path_1.join(workPath, '.output', 'server', 'pages', entrypoint);
+            if (!handlerFile || !handlerFile.fsPath) {
+                throw new Error(`Could not find a handler file. Please ensure that \`files\` for the returned \`Lambda\` contains an \`FileFsRef\` named "${handlerFileBase}" with a valid \`fsPath\`.`);
+            }
+            const handlerExtName = path_1.extname(handlerFile.fsPath);
+            const entryBase = path_1.basename(entrypoint).replace(ext, handlerExtName);
+            const entryPath = path_1.join(path_1.dirname(entrypoint), entryBase);
+            const entry = path_1.join(entryRoot, entryPath);
+            // We never want to link here, only copy, because the launcher
+            // file often has the same name for every entrypoint, which means that
+            // every build for every entrypoint overwrites the launcher of the previous
+            // one, so linking would end with a broken reference.
             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.
+            await fs_extra_1.default.copy(handlerFile.fsPath, entry);
+            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) {
+                if (relPath === handlerFileBase) {
                     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}`);
                 }
             });
-            const nft = path_1.join(workPath, '.output', 'server', 'pages', `${entrypoint}.nft.json`);
+            linkersRuntime = linkersRuntime.concat(linkers);
+            const nft = `${entry}.nft.json`;
             const json = JSON.stringify({
                 version: 1,
                 files: tracedFiles.map(file => ({
                     input: normalize_path_1.normalizePath(path_1.relative(path_1.dirname(nft), file.absolutePath)),
-                    output: normalize_path_1.normalizePath(file.relativePath),
+                    // We'd like to place all the dependency files right next
+                    // to the final launcher file inside of the Lambda.
+                    output: normalize_path_1.normalizePath(path_1.join(entryDir, 'api', file.relativePath)),
                 })),
             });
             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,
+            ]);
+            // Add an entry that will later on be added to the `functions-manifest.json`
+            // file that is placed inside of the `.output` directory.
+            pages[normalize_path_1.normalizePath(entryPath)] = {
+                // Because the underlying file used as a handler was placed
+                // inside `.output/server/pages/api`, it no longer has the name it originally
+                // had and is now named after the API Route that it's responsible for,
+                // so we have to adjust the name of the Lambda handler accordingly.
+                handler: handler.replace(handlerFileName, path_1.parse(entry).name),
+                runtime: output.runtime,
+                memory: output.memory,
+                maxDuration: output.maxDuration,
+                environment: output.environment,
+                allowQuery: output.allowQuery,
+            };
         }
+        // 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.36",
   "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": "1c3701628d88e82f6e0535ecdba2c5e91ce61976"
 }