@vercel/go 2.0.12 → 2.0.15

package/dist/index.js

@@ -17720,289 +17720,383 @@ async function initPrivateGit(credentials) {
  * which works great for this feature. We also need to add a suffix during `vercel dev`
  * since the entrypoint is already stripped of its suffix before build() is called.
  */
-async function getRenamedEntrypoint(entrypoint, files) {
+function getRenamedEntrypoint(entrypoint) {
     const filename = path_1.basename(entrypoint);
     if (filename.startsWith('[')) {
         const newEntrypoint = entrypoint.replace('/[', '/now-bracket[');
-        const file = files[entrypoint];
-        delete files[entrypoint];
-        files[newEntrypoint] = file;
         build_utils_1.debug(`Renamed entrypoint from ${entrypoint} to ${newEntrypoint}`);
-        entrypoint = newEntrypoint;
+        return newEntrypoint;
     }
-    return entrypoint;
+    return undefined;
 }
 exports.version = 3;
 async function build({ files, entrypoint, config, workPath, meta = {}, }) {
-    if (process.env.GIT_CREDENTIALS) {
-        build_utils_1.debug('Initialize Git credentials...');
-        await initPrivateGit(process.env.GIT_CREDENTIALS);
-    }
-    if (process.env.GO111MODULE) {
-        console.log(`\nManually assigning 'GO111MODULE' is not recommended.
-
-By default:
-  - 'GO111MODULE=on' If entrypoint package name is not 'main'
-  - 'GO111MODULE=off' If entrypoint package name is 'main'
-
-We highly recommend you leverage Go Modules in your project.
-Learn more: https://github.com/golang/go/wiki/Modules
-`);
-    }
-    entrypoint = await getRenamedEntrypoint(entrypoint, files);
-    const entrypointArr = entrypoint.split(path_1.sep);
-    // eslint-disable-next-line prefer-const
-    let [goPath, outDir] = await Promise.all([
-        build_utils_1.getWriteableDirectory(),
-        build_utils_1.getWriteableDirectory(),
-    ]);
+    const goPath = await build_utils_1.getWriteableDirectory();
     const srcPath = path_1.join(goPath, 'src', 'lambda');
     const downloadPath = meta.skipDownload ? workPath : srcPath;
-    const downloadedFiles = await build_utils_1.download(files, downloadPath, meta);
-    build_utils_1.debug(`Parsing AST for "${entrypoint}"`);
-    let analyzed;
+    await build_utils_1.download(files, downloadPath, meta);
+    // keep track of file system actions we need to undo
+    // the keys "from" and "to" refer to what needs to be done
+    // in order to undo the action, not what the original action was
+    const undoFileActions = [];
+    const undoDirectoryCreation = [];
     try {
-        let goModAbsPathDir = '';
-        const fileName = 'go.mod';
-        if (fileName in downloadedFiles) {
-            goModAbsPathDir = path_1.dirname(downloadedFiles[fileName].fsPath);
-            build_utils_1.debug(`Found ${fileName} file in "${goModAbsPathDir}"`);
+        if (process.env.GIT_CREDENTIALS) {
+            build_utils_1.debug('Initialize Git credentials...');
+            await initPrivateGit(process.env.GIT_CREDENTIALS);
         }
-        else if ('api/go.mod' in downloadedFiles) {
-            goModAbsPathDir = path_1.dirname(downloadedFiles['api/go.mod'].fsPath);
-            build_utils_1.debug(`Found ${fileName} file in "${goModAbsPathDir}"`);
+        if (process.env.GO111MODULE) {
+            console.log(`\nManually assigning 'GO111MODULE' is not recommended.
+
+  By default:
+    - 'GO111MODULE=on' If entrypoint package name is not 'main'
+    - 'GO111MODULE=off' If entrypoint package name is 'main'
+
+  We highly recommend you leverage Go Modules in your project.
+  Learn more: https://github.com/golang/go/wiki/Modules
+  `);
         }
-        analyzed = await go_helpers_1.getAnalyzedEntrypoint(workPath, downloadedFiles[entrypoint].fsPath, goModAbsPathDir);
-    }
-    catch (err) {
-        console.log(`Failed to parse AST for "${entrypoint}"`);
-        throw err;
-    }
-    if (!analyzed) {
-        const err = new Error(`Could not find an exported function in "${entrypoint}"
-Learn more: https://vercel.com/docs/runtimes#official-runtimes/go
-      `);
-        console.log(err.message);
-        throw err;
-    }
-    const parsedAnalyzed = JSON.parse(analyzed);
-    // find `go.mod` in downloadedFiles
-    const entrypointDirname = path_1.dirname(downloadedFiles[entrypoint].fsPath);
-    let isGoModExist = false;
-    let goModPath = '';
-    let isGoModInRootDir = false;
-    for (const file of Object.keys(downloadedFiles)) {
-        const { fsPath } = downloadedFiles[file];
-        const fileDirname = path_1.dirname(fsPath);
-        if (file === 'go.mod') {
-            isGoModExist = true;
-            isGoModInRootDir = true;
-            goModPath = fileDirname;
+        const renamedEntrypoint = getRenamedEntrypoint(entrypoint);
+        if (renamedEntrypoint) {
+            await fs_extra_1.move(path_1.join(workPath, entrypoint), path_1.join(workPath, renamedEntrypoint));
+            undoFileActions.push({
+                to: path_1.join(workPath, entrypoint),
+                from: path_1.join(workPath, renamedEntrypoint),
+            });
+            entrypoint = renamedEntrypoint;
         }
-        else if (file.endsWith('go.mod')) {
-            if (entrypointDirname === fileDirname) {
-                isGoModExist = true;
-                goModPath = fileDirname;
-                build_utils_1.debug(`Found file dirname equals entrypoint dirname: ${fileDirname}`);
-                break;
+        const entrypointAbsolute = path_1.join(workPath, entrypoint);
+        const entrypointArr = entrypoint.split(path_1.sep);
+        build_utils_1.debug(`Parsing AST for "${entrypoint}"`);
+        let analyzed;
+        try {
+            const goModAbsPath = await findGoModPath(workPath);
+            if (goModAbsPath) {
+                build_utils_1.debug(`Found ${goModAbsPath}"`);
             }
-            if (!isGoModInRootDir && config.zeroConfig && file === 'api/go.mod') {
-                // We didn't find `/go.mod` but we found `/api/go.mod` so move it to the root
+            analyzed = await go_helpers_1.getAnalyzedEntrypoint(workPath, entrypointAbsolute, path_1.dirname(goModAbsPath));
+        }
+        catch (err) {
+            console.log(`Failed to parse AST for "${entrypoint}"`);
+            throw err;
+        }
+        if (!analyzed) {
+            const err = new Error(`Could not find an exported function in "${entrypoint}"
+  Learn more: https://vercel.com/docs/runtimes#official-runtimes/go
+        `);
+            console.log(err.message);
+            throw err;
+        }
+        const parsedAnalyzed = JSON.parse(analyzed);
+        // find `go.mod` in modFiles
+        const entrypointDirname = path_1.dirname(entrypointAbsolute);
+        let isGoModExist = false;
+        let goModPath = '';
+        let isGoModInRootDir = false;
+        const modFileRefs = await build_utils_1.glob('**/*.mod', workPath);
+        const modFiles = Object.keys(modFileRefs);
+        for (const file of modFiles) {
+            const fileDirname = path_1.dirname(file);
+            if (file === 'go.mod') {
                 isGoModExist = true;
                 isGoModInRootDir = true;
-                goModPath = path_1.join(fileDirname, '..');
-                const pathParts = fsPath.split(path_1.sep);
-                pathParts.pop(); // Remove go.mod
-                pathParts.pop(); // Remove api
-                pathParts.push('go.mod');
-                const newFsPath = pathParts.join(path_1.sep);
-                build_utils_1.debug(`Moving api/go.mod to root: ${fsPath} to ${newFsPath}`);
-                await fs_extra_1.move(fsPath, newFsPath);
-                const oldSumPath = path_1.join(path_1.dirname(fsPath), 'go.sum');
-                const newSumPath = path_1.join(path_1.dirname(newFsPath), 'go.sum');
-                if (await fs_extra_1.pathExists(oldSumPath)) {
-                    build_utils_1.debug(`Moving api/go.sum to root: ${oldSumPath} to ${newSumPath}`);
-                    await fs_extra_1.move(oldSumPath, newSumPath);
+                goModPath = path_1.join(workPath, fileDirname);
+            }
+            else if (file.endsWith('go.mod')) {
+                if (entrypointDirname === fileDirname) {
+                    isGoModExist = true;
+                    goModPath = path_1.join(workPath, fileDirname);
+                    build_utils_1.debug(`Found file dirname equals entrypoint dirname: ${fileDirname}`);
+                    break;
+                }
+                if (!isGoModInRootDir && config.zeroConfig && file === 'api/go.mod') {
+                    // We didn't find `/go.mod` but we found `/api/go.mod` so move it to the root
+                    isGoModExist = true;
+                    isGoModInRootDir = true;
+                    goModPath = path_1.join(fileDirname, '..');
+                    const pathParts = file.split(path_1.sep);
+                    pathParts.pop(); // Remove go.mod
+                    pathParts.pop(); // Remove api
+                    pathParts.push('go.mod');
+                    const newRoot = pathParts.join(path_1.sep);
+                    const newFsPath = path_1.join(workPath, newRoot);
+                    build_utils_1.debug(`Moving api/go.mod to root: ${file} to ${newFsPath}`);
+                    await fs_extra_1.move(file, newFsPath);
+                    undoFileActions.push({
+                        to: file,
+                        from: newFsPath,
+                    });
+                    const oldSumPath = path_1.join(path_1.dirname(file), 'go.sum');
+                    const newSumPath = path_1.join(path_1.dirname(newFsPath), 'go.sum');
+                    if (await fs_extra_1.pathExists(oldSumPath)) {
+                        build_utils_1.debug(`Moving api/go.sum to root: ${oldSumPath} to ${newSumPath}`);
+                        await fs_extra_1.move(oldSumPath, newSumPath);
+                        undoFileActions.push({
+                            to: oldSumPath,
+                            from: newSumPath,
+                        });
+                    }
+                    break;
                 }
-                break;
             }
         }
-    }
-    const input = entrypointDirname;
-    const includedFiles = {};
-    if (config && config.includeFiles) {
-        const patterns = Array.isArray(config.includeFiles)
-            ? config.includeFiles
-            : [config.includeFiles];
-        for (const pattern of patterns) {
-            const fsFiles = await build_utils_1.glob(pattern, input);
-            for (const [assetName, asset] of Object.entries(fsFiles)) {
-                includedFiles[assetName] = asset;
+        const input = entrypointDirname;
+        const includedFiles = {};
+        if (config && config.includeFiles) {
+            const patterns = Array.isArray(config.includeFiles)
+                ? config.includeFiles
+                : [config.includeFiles];
+            for (const pattern of patterns) {
+                const fsFiles = await build_utils_1.glob(pattern, input);
+                for (const [assetName, asset] of Object.entries(fsFiles)) {
+                    includedFiles[assetName] = asset;
+                }
             }
         }
-    }
-    const handlerFunctionName = parsedAnalyzed.functionName;
-    build_utils_1.debug(`Found exported function "${handlerFunctionName}" in "${entrypoint}"`);
-    if (!isGoModExist && 'vendor' in downloadedFiles) {
-        throw new Error('`go.mod` is required to use a `vendor` directory.');
-    }
-    // check if package name other than main
-    // using `go.mod` way building the handler
-    const packageName = parsedAnalyzed.packageName;
-    if (isGoModExist && packageName === 'main') {
-        throw new Error('Please change `package main` to `package handler`');
-    }
-    if (packageName !== 'main') {
-        const go = await go_helpers_1.createGo(workPath, goPath, process.platform, process.arch, {
-            cwd: entrypointDirname,
-        }, true);
+        const handlerFunctionName = parsedAnalyzed.functionName;
+        build_utils_1.debug(`Found exported function "${handlerFunctionName}" in "${entrypoint}"`);
         if (!isGoModExist) {
+            if (await fs_extra_1.pathExists(path_1.join(workPath, 'vendor'))) {
+                throw new Error('`go.mod` is required to use a `vendor` directory.');
+            }
+        }
+        // check if package name other than main
+        // using `go.mod` way building the handler
+        const packageName = parsedAnalyzed.packageName;
+        if (isGoModExist && packageName === 'main') {
+            throw new Error('Please change `package main` to `package handler`');
+        }
+        const outDir = await build_utils_1.getWriteableDirectory();
+        if (packageName !== 'main') {
+            const go = await go_helpers_1.createGo(workPath, goPath, process.platform, process.arch, {
+                cwd: entrypointDirname,
+            }, true);
+            if (!isGoModExist) {
+                try {
+                    const defaultGoModContent = `module ${packageName}`;
+                    await fs_extra_1.writeFile(path_1.join(entrypointDirname, 'go.mod'), defaultGoModContent);
+                    undoFileActions.push({
+                        to: undefined,
+                        from: path_1.join(entrypointDirname, 'go.mod'),
+                    });
+                    // remove the `go.sum` file that will be generated as well
+                    undoFileActions.push({
+                        to: undefined,
+                        from: path_1.join(entrypointDirname, 'go.sum'),
+                    });
+                }
+                catch (err) {
+                    console.log(`Failed to create default go.mod for ${packageName}`);
+                    throw err;
+                }
+            }
+            const mainModGoFileName = 'main__mod__.go';
+            const modMainGoContents = await fs_extra_1.readFile(__webpack_require__.ab + "main__mod__.go", 'utf8');
+            let goPackageName = `${packageName}/${packageName}`;
+            const goFuncName = `${packageName}.${handlerFunctionName}`;
+            if (isGoModExist) {
+                const goModContents = await fs_extra_1.readFile(path_1.join(goModPath, 'go.mod'), 'utf8');
+                const usrModName = goModContents.split('\n')[0].split(' ')[1];
+                if (entrypointArr.length > 1 && isGoModInRootDir) {
+                    const cleanPackagePath = [...entrypointArr];
+                    cleanPackagePath.pop();
+                    goPackageName = `${usrModName}/${cleanPackagePath.join('/')}`;
+                }
+                else {
+                    goPackageName = `${usrModName}/${packageName}`;
+                }
+            }
+            const mainModGoContents = modMainGoContents
+                .replace('__VC_HANDLER_PACKAGE_NAME', goPackageName)
+                .replace('__VC_HANDLER_FUNC_NAME', goFuncName);
+            if (isGoModExist && isGoModInRootDir) {
+                build_utils_1.debug('[mod-root] Write main file to ' + downloadPath);
+                await fs_extra_1.writeFile(path_1.join(downloadPath, mainModGoFileName), mainModGoContents);
+                undoFileActions.push({
+                    to: undefined,
+                    from: path_1.join(downloadPath, mainModGoFileName),
+                });
+            }
+            else if (isGoModExist && !isGoModInRootDir) {
+                build_utils_1.debug('[mod-other] Write main file to ' + goModPath);
+                await fs_extra_1.writeFile(path_1.join(goModPath, mainModGoFileName), mainModGoContents);
+                undoFileActions.push({
+                    to: undefined,
+                    from: path_1.join(goModPath, mainModGoFileName),
+                });
+            }
+            else {
+                build_utils_1.debug('[entrypoint] Write main file to ' + entrypointDirname);
+                await fs_extra_1.writeFile(path_1.join(entrypointDirname, mainModGoFileName), mainModGoContents);
+                undoFileActions.push({
+                    to: undefined,
+                    from: path_1.join(entrypointDirname, mainModGoFileName),
+                });
+            }
+            // move user go file to folder
             try {
-                const defaultGoModContent = `module ${packageName}`;
-                await fs_extra_1.writeFile(path_1.join(entrypointDirname, 'go.mod'), defaultGoModContent);
+                // default path
+                let finalDestination = path_1.join(entrypointDirname, packageName, entrypoint);
+                // if `entrypoint` include folder, only use filename
+                if (entrypointArr.length > 1) {
+                    finalDestination = path_1.join(entrypointDirname, packageName, entrypointArr[entrypointArr.length - 1]);
+                }
+                if (path_1.dirname(entrypointAbsolute) === goModPath || !isGoModExist) {
+                    build_utils_1.debug(`moving entrypoint "${entrypointAbsolute}" to "${finalDestination}"`);
+                    await fs_extra_1.move(entrypointAbsolute, finalDestination);
+                    undoFileActions.push({
+                        to: entrypointAbsolute,
+                        from: finalDestination,
+                    });
+                    undoDirectoryCreation.push(path_1.dirname(finalDestination));
+                }
             }
             catch (err) {
-                console.log(`Failed to create default go.mod for ${packageName}`);
+                console.log('Failed to move entry to package folder');
                 throw err;
             }
-        }
-        const mainModGoFileName = 'main__mod__.go';
-        const modMainGoContents = await fs_extra_1.readFile(__webpack_require__.ab + "main__mod__.go", 'utf8');
-        let goPackageName = `${packageName}/${packageName}`;
-        const goFuncName = `${packageName}.${handlerFunctionName}`;
-        if (isGoModExist) {
-            const goModContents = await fs_extra_1.readFile(path_1.join(goModPath, 'go.mod'), 'utf8');
-            const usrModName = goModContents.split('\n')[0].split(' ')[1];
-            if (entrypointArr.length > 1 && isGoModInRootDir) {
-                const cleanPackagePath = [...entrypointArr];
-                cleanPackagePath.pop();
-                goPackageName = `${usrModName}/${cleanPackagePath.join('/')}`;
+            let baseGoModPath = '';
+            if (isGoModExist && isGoModInRootDir) {
+                baseGoModPath = downloadPath;
+            }
+            else if (isGoModExist && !isGoModInRootDir) {
+                baseGoModPath = goModPath;
             }
             else {
-                goPackageName = `${usrModName}/${packageName}`;
+                baseGoModPath = entrypointDirname;
             }
-        }
-        const mainModGoContents = modMainGoContents
-            .replace('__VC_HANDLER_PACKAGE_NAME', goPackageName)
-            .replace('__VC_HANDLER_FUNC_NAME', goFuncName);
-        if (isGoModExist && isGoModInRootDir) {
-            build_utils_1.debug('[mod-root] Write main file to ' + downloadPath);
-            await fs_extra_1.writeFile(path_1.join(downloadPath, mainModGoFileName), mainModGoContents);
-        }
-        else if (isGoModExist && !isGoModInRootDir) {
-            build_utils_1.debug('[mod-other] Write main file to ' + goModPath);
-            await fs_extra_1.writeFile(path_1.join(goModPath, mainModGoFileName), mainModGoContents);
-        }
-        else {
-            build_utils_1.debug('[entrypoint] Write main file to ' + entrypointDirname);
-            await fs_extra_1.writeFile(path_1.join(entrypointDirname, mainModGoFileName), mainModGoContents);
-        }
-        // move user go file to folder
-        try {
-            // default path
-            let finalDestination = path_1.join(entrypointDirname, packageName, entrypoint);
-            // if `entrypoint` include folder, only use filename
-            if (entrypointArr.length > 1) {
-                finalDestination = path_1.join(entrypointDirname, packageName, entrypointArr[entrypointArr.length - 1]);
+            build_utils_1.debug('Tidy `go.mod` file...');
+            try {
+                // ensure go.mod up-to-date
+                await go.mod();
             }
-            if (path_1.dirname(downloadedFiles[entrypoint].fsPath) === goModPath ||
-                !isGoModExist) {
-                await fs_extra_1.move(downloadedFiles[entrypoint].fsPath, finalDestination);
+            catch (err) {
+                console.log('failed to `go mod tidy`');
+                throw err;
+            }
+            build_utils_1.debug('Running `go build`...');
+            const destPath = path_1.join(outDir, handlerFileName);
+            try {
+                const src = [path_1.join(baseGoModPath, mainModGoFileName)];
+                await go.build(src, destPath);
+            }
+            catch (err) {
+                console.log('failed to `go build`');
+                throw err;
             }
-        }
-        catch (err) {
-            console.log('Failed to move entry to package folder');
-            throw err;
-        }
-        let baseGoModPath = '';
-        if (isGoModExist && isGoModInRootDir) {
-            baseGoModPath = downloadPath;
-        }
-        else if (isGoModExist && !isGoModInRootDir) {
-            baseGoModPath = goModPath;
         }
         else {
-            baseGoModPath = entrypointDirname;
-        }
-        build_utils_1.debug('Tidy `go.mod` file...');
-        try {
-            // ensure go.mod up-to-date
-            await go.mod();
-        }
-        catch (err) {
-            console.log('failed to `go mod tidy`');
-            throw err;
-        }
-        build_utils_1.debug('Running `go build`...');
-        const destPath = path_1.join(outDir, handlerFileName);
-        try {
-            const src = [path_1.join(baseGoModPath, mainModGoFileName)];
-            await go.build(src, destPath);
+            // legacy mode
+            // we need `main.go` in the same dir as the entrypoint,
+            // otherwise `go build` will refuse to build
+            const go = await go_helpers_1.createGo(workPath, goPath, process.platform, process.arch, {
+                cwd: entrypointDirname,
+            }, false);
+            const origianlMainGoContents = await fs_extra_1.readFile(__webpack_require__.ab + "main.go", 'utf8');
+            const mainGoContents = origianlMainGoContents.replace('__VC_HANDLER_FUNC_NAME', handlerFunctionName);
+            // in order to allow the user to have `main.go`,
+            // we need our `main.go` to be called something else
+            const mainGoFileName = 'main__vc__go__.go';
+            // Go doesn't like to build files in different directories,
+            // so now we place `main.go` together with the user code
+            await fs_extra_1.writeFile(path_1.join(entrypointDirname, mainGoFileName), mainGoContents);
+            undoFileActions.push({
+                to: undefined,
+                from: path_1.join(entrypointDirname, mainGoFileName),
+            });
+            // `go get` will look at `*.go` (note we set `cwd`), parse the `import`s
+            // and download any packages that aren't part of the stdlib
+            build_utils_1.debug('Running `go get`...');
+            try {
+                await go.get();
+            }
+            catch (err) {
+                console.log('Failed to `go get`');
+                throw err;
+            }
+            build_utils_1.debug('Running `go build`...');
+            const destPath = path_1.join(outDir, handlerFileName);
+            try {
+                const src = [
+                    path_1.join(entrypointDirname, mainGoFileName),
+                    entrypointAbsolute,
+                ].map(file => path_1.normalize(file));
+                await go.build(src, destPath);
+            }
+            catch (err) {
+                console.log('failed to `go build`');
+                throw err;
+            }
         }
-        catch (err) {
-            console.log('failed to `go build`');
-            throw err;
+        const lambda = await build_utils_1.createLambda({
+            files: { ...(await build_utils_1.glob('**', outDir)), ...includedFiles },
+            handler: handlerFileName,
+            runtime: 'go1.x',
+            environment: {},
+        });
+        const watch = parsedAnalyzed.watch;
+        let watchSub = [];
+        // if `entrypoint` located in subdirectory
+        // we will need to concat it with return watch array
+        if (entrypointArr.length > 1) {
+            entrypointArr.pop();
+            watchSub = parsedAnalyzed.watch.map(file => path_1.join(...entrypointArr, file));
         }
+        return {
+            output: lambda,
+            watch: watch.concat(watchSub),
+        };
     }
-    else {
-        // legacy mode
-        // we need `main.go` in the same dir as the entrypoint,
-        // otherwise `go build` will refuse to build
-        const go = await go_helpers_1.createGo(workPath, goPath, process.platform, process.arch, {
-            cwd: entrypointDirname,
-        }, false);
-        const origianlMainGoContents = await fs_extra_1.readFile(__webpack_require__.ab + "main.go", 'utf8');
-        const mainGoContents = origianlMainGoContents.replace('__VC_HANDLER_FUNC_NAME', handlerFunctionName);
-        // in order to allow the user to have `main.go`,
-        // we need our `main.go` to be called something else
-        const mainGoFileName = 'main__vc__go__.go';
-        // Go doesn't like to build files in different directories,
-        // so now we place `main.go` together with the user code
-        await fs_extra_1.writeFile(path_1.join(entrypointDirname, mainGoFileName), mainGoContents);
-        // `go get` will look at `*.go` (note we set `cwd`), parse the `import`s
-        // and download any packages that aren't part of the stdlib
-        build_utils_1.debug('Running `go get`...');
+    catch (error) {
+        build_utils_1.debug('Go Builder Error: ' + error);
+        throw error;
+    }
+    finally {
         try {
-            await go.get();
+            await cleanupFileSystem(undoFileActions, undoDirectoryCreation);
         }
-        catch (err) {
-            console.log('Failed to `go get`');
-            throw err;
+        catch (error) {
+            console.log(`Build cleanup failed: ${error.message}`);
+            build_utils_1.debug('Cleanup Error: ' + error);
         }
-        build_utils_1.debug('Running `go build`...');
-        const destPath = path_1.join(outDir, handlerFileName);
-        try {
-            const src = [
-                path_1.join(entrypointDirname, mainGoFileName),
-                downloadedFiles[entrypoint].fsPath,
-            ].map(file => path_1.normalize(file));
-            await go.build(src, destPath);
+    }
+}
+exports.build = build;
+async function cleanupFileSystem(undoFileActions, undoDirectoryCreation) {
+    // we have to undo the actions in reverse order in cases
+    // where one file was moved multiple times, which happens
+    // using files that start with brackets
+    for (const action of undoFileActions.reverse()) {
+        if (action.to) {
+            await fs_extra_1.move(action.from, action.to);
         }
-        catch (err) {
-            console.log('failed to `go build`');
-            throw err;
+        else {
+            await fs_extra_1.remove(action.from);
         }
     }
-    const lambda = await build_utils_1.createLambda({
-        files: { ...(await build_utils_1.glob('**', outDir)), ...includedFiles },
-        handler: handlerFileName,
-        runtime: 'go1.x',
-        environment: {},
+    const undoDirectoryPromises = undoDirectoryCreation.map(async (directory) => {
+        const contents = await fs_extra_1.readdir(directory);
+        // only delete an empty directory
+        // if it has contents, either something went wrong during cleanup or this
+        // directory contains project source code that should not be deleted
+        if (!contents.length) {
+            return fs_extra_1.rmdir(directory);
+        }
+        return undefined;
     });
-    const watch = parsedAnalyzed.watch;
-    let watchSub = [];
-    // if `entrypoint` located in subdirectory
-    // we will need to concat it with return watch array
-    if (entrypointArr.length > 1) {
-        entrypointArr.pop();
-        watchSub = parsedAnalyzed.watch.map(file => path_1.join(...entrypointArr, file));
+    await Promise.all(undoDirectoryPromises);
+}
+async function findGoModPath(workPath) {
+    let checkPath = path_1.join(workPath, 'go.mod');
+    if (await fs_extra_1.pathExists(checkPath)) {
+        return checkPath;
     }
-    return {
-        output: lambda,
-        watch: watch.concat(watchSub),
-    };
+    checkPath = path_1.join(workPath, 'api/go.mod');
+    if (await fs_extra_1.pathExists(checkPath)) {
+        return checkPath;
+    }
+    return '';
 }
-exports.build = build;
 function isPortInfo(v) {
     return v && typeof v.port === 'number';
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/go",
-  "version": "2.0.12",
+  "version": "2.0.15",
   "license": "MIT",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/go",
@@ -11,9 +11,8 @@
   },
   "scripts": {
     "build": "node build",
-    "test": "yarn jest --env node --verbose --runInBand --bail",
-    "test-integration-once": "yarn test",
-    "prepublishOnly": "node build"
+    "test": "jest --env node --verbose --runInBand --bail",
+    "test-integration-once": "yarn test"
   },
   "files": [
     "dist"
@@ -25,7 +24,7 @@
     "@types/fs-extra": "^5.0.5",
     "@types/node-fetch": "^2.3.0",
     "@types/tar": "^4.0.0",
-    "@vercel/build-utils": "5.0.8",
+    "@vercel/build-utils": "5.2.0",
     "@vercel/ncc": "0.24.0",
     "async-retry": "1.3.1",
     "execa": "^1.0.0",
@@ -35,5 +34,5 @@
     "tar": "4.4.6",
     "typescript": "4.3.4"
   },
-  "gitHead": "543ffdfe5ccfb59c9c455fc50df3bb8ed1eaf567"
+  "gitHead": "32afd67d29d46f67027091ab9695d8ff330355b5"
 }