@netlify/zip-it-and-ship-it 5.4.0 → 5.5.2

package/README.md

@@ -463,7 +463,7 @@ In Netlify, this is done by ensuring that the following Node.js versions are the
 - Build-time Node.js version: this defaults to Node `12`, but can be
   [overridden with a `.nvmrc` or `NODE_VERSION` environment variable](https://docs.netlify.com/configure-builds/manage-dependencies/#node-js-and-javascript).
 - Function runtime Node.js version: this defaults to `nodejs12.x` but can be
-  [overriden with a `AWS_LAMBDA_JS_RUNTIME` environment variable](https://docs.netlify.com/functions/build-with-javascript/#runtime-settings).
+  [overridden with a `AWS_LAMBDA_JS_RUNTIME` environment variable](https://docs.netlify.com/functions/build-with-javascript/#runtime-settings).
 
 Note that this problem might not apply for Node.js native modules using the [N-API](https://nodejs.org/api/n-api.html).
 

package/dist/archive.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -49,11 +40,9 @@ const addZipContent = function (archive, content, name) {
 };
 exports.addZipContent = addZipContent;
 // End zipping files
-const endZip = function (archive, output) {
-    return __awaiter(this, void 0, void 0, function* () {
-        archive.finalize();
-        yield pEndOfStream(output);
-    });
+const endZip = async function (archive, output) {
+    archive.finalize();
+    await pEndOfStream(output);
 };
 exports.endZip = endZip;
 //# sourceMappingURL=archive.js.map

package/dist/bin.js

@@ -1,25 +1,5 @@
 #!/usr/bin/env node
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -28,21 +8,19 @@ const process_1 = require("process");
 const yargs_1 = __importDefault(require("yargs"));
 const main_1 = require("./main");
 // CLI entry point
-const runCli = function () {
-    return __awaiter(this, void 0, void 0, function* () {
-        // @ts-expect-error TODO: `destFolder` and  `srcFolder` are not being passed
-        // back from `parseArgs()`.
-        const _a = parseArgs(), { destFolder, srcFolder } = _a, options = __rest(_a, ["destFolder", "srcFolder"]);
-        try {
-            // @ts-expect-error TODO: `options` is not getting the right types.
-            const zipped = yield (0, main_1.zipFunctions)(srcFolder, destFolder, options);
-            console.log(JSON.stringify(zipped, null, 2));
-        }
-        catch (error) {
-            console.error(error.toString());
-            (0, process_1.exit)(1);
-        }
-    });
+const runCli = async function () {
+    // @ts-expect-error TODO: `destFolder` and  `srcFolder` are not being passed
+    // back from `parseArgs()`.
+    const { destFolder, srcFolder, ...options } = parseArgs();
+    try {
+        // @ts-expect-error TODO: `options` is not getting the right types.
+        const zipped = await (0, main_1.zipFunctions)(srcFolder, destFolder, options);
+        console.log(JSON.stringify(zipped, null, 2));
+    }
+    catch (error) {
+        console.error(error.toString());
+        (0, process_1.exit)(1);
+    }
 };
 const parseArgs = function () {
     return yargs_1.default

package/dist/config.d.ts

@@ -13,6 +13,7 @@ interface FunctionConfig {
     processDynamicNodeImports?: boolean;
     rustTargetDirectory?: string;
     schedule?: string;
+    zipGo?: boolean;
 }
 declare type GlobPattern = string;
 declare type Config = Record<GlobPattern, FunctionConfig>;

package/dist/feature_flags.js

@@ -11,6 +11,9 @@ const FLAGS = {
 };
 exports.defaultFlags = FLAGS;
 // List of supported flags and their default value.
-const getFlags = (input = {}, flags = FLAGS) => Object.entries(flags).reduce((result, [key, defaultValue]) => (Object.assign(Object.assign({}, result), { [key]: input[key] === undefined ? defaultValue : input[key] })), {});
+const getFlags = (input = {}, flags = FLAGS) => Object.entries(flags).reduce((result, [key, defaultValue]) => ({
+    ...result,
+    [key]: input[key] === undefined ? defaultValue : input[key],
+}), {});
 exports.getFlags = getFlags;
 //# sourceMappingURL=feature_flags.js.map

package/dist/main.js

@@ -1,24 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.zipFunctions = exports.zipFunction = exports.listFunctionsFiles = exports.listFunction = exports.listFunctions = void 0;
 const path_1 = require("path");
@@ -26,74 +6,66 @@ const feature_flags_1 = require("./feature_flags");
 const runtimes_1 = require("./runtimes");
 const in_source_config_1 = require("./runtimes/node/in_source_config");
 const fs_1 = require("./utils/fs");
-const augmentWithISC = (func) => __awaiter(void 0, void 0, void 0, function* () {
+const augmentWithISC = async (func) => {
     // ISC is currently only supported in JavaScript and TypeScript functions.
     if (func.runtime.name !== 'js') {
         return func;
     }
-    const inSourceConfig = yield (0, in_source_config_1.findISCDeclarationsInPath)(func.mainFile);
-    return Object.assign(Object.assign({}, func), { inSourceConfig });
-});
+    const inSourceConfig = await (0, in_source_config_1.findISCDeclarationsInPath)(func.mainFile);
+    return { ...func, inSourceConfig };
+};
 // List all Netlify Functions main entry files for a specific directory
-const listFunctions = function (relativeSrcFolders, { featureFlags: inputFeatureFlags, config, parseISC = false, } = {}) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const featureFlags = (0, feature_flags_1.getFlags)(inputFeatureFlags);
-        const srcFolders = (0, fs_1.resolveFunctionsDirectories)(relativeSrcFolders);
-        const paths = yield (0, fs_1.listFunctionsDirectories)(srcFolders);
-        const functionsMap = yield (0, runtimes_1.getFunctionsFromPaths)(paths, { featureFlags, config });
-        const functions = [...functionsMap.values()];
-        const augmentedFunctions = parseISC ? yield Promise.all(functions.map(augmentWithISC)) : functions;
-        return augmentedFunctions.map(getListedFunction);
-    });
+const listFunctions = async function (relativeSrcFolders, { featureFlags: inputFeatureFlags, config, parseISC = false, } = {}) {
+    const featureFlags = (0, feature_flags_1.getFlags)(inputFeatureFlags);
+    const srcFolders = (0, fs_1.resolveFunctionsDirectories)(relativeSrcFolders);
+    const paths = await (0, fs_1.listFunctionsDirectories)(srcFolders);
+    const functionsMap = await (0, runtimes_1.getFunctionsFromPaths)(paths, { featureFlags, config });
+    const functions = [...functionsMap.values()];
+    const augmentedFunctions = parseISC ? await Promise.all(functions.map(augmentWithISC)) : functions;
+    return augmentedFunctions.map(getListedFunction);
 };
 exports.listFunctions = listFunctions;
 // Finds a function at a specific path.
-const listFunction = function (path, { featureFlags: inputFeatureFlags, config, parseISC = false, } = {}) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const featureFlags = (0, feature_flags_1.getFlags)(inputFeatureFlags);
-        const func = yield (0, runtimes_1.getFunctionFromPath)(path, { featureFlags, config });
-        if (!func) {
-            return;
-        }
-        const augmentedFunction = parseISC ? yield augmentWithISC(func) : func;
-        return getListedFunction(augmentedFunction);
-    });
+const listFunction = async function (path, { featureFlags: inputFeatureFlags, config, parseISC = false, } = {}) {
+    const featureFlags = (0, feature_flags_1.getFlags)(inputFeatureFlags);
+    const func = await (0, runtimes_1.getFunctionFromPath)(path, { featureFlags, config });
+    if (!func) {
+        return;
+    }
+    const augmentedFunction = parseISC ? await augmentWithISC(func) : func;
+    return getListedFunction(augmentedFunction);
 };
 exports.listFunction = listFunction;
 // List all Netlify Functions files for a specific directory
-const listFunctionsFiles = function (relativeSrcFolders, { basePath, config, featureFlags: inputFeatureFlags, parseISC = false } = {}) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const featureFlags = (0, feature_flags_1.getFlags)(inputFeatureFlags);
-        const srcFolders = (0, fs_1.resolveFunctionsDirectories)(relativeSrcFolders);
-        const paths = yield (0, fs_1.listFunctionsDirectories)(srcFolders);
-        const functionsMap = yield (0, runtimes_1.getFunctionsFromPaths)(paths, { config, featureFlags });
-        const functions = [...functionsMap.values()];
-        const augmentedFunctions = parseISC ? yield Promise.all(functions.map(augmentWithISC)) : functions;
-        const listedFunctionsFiles = yield Promise.all(augmentedFunctions.map((func) => getListedFunctionFiles(func, { basePath, featureFlags })));
-        return listedFunctionsFiles.flat();
-    });
+const listFunctionsFiles = async function (relativeSrcFolders, { basePath, config, featureFlags: inputFeatureFlags, parseISC = false } = {}) {
+    const featureFlags = (0, feature_flags_1.getFlags)(inputFeatureFlags);
+    const srcFolders = (0, fs_1.resolveFunctionsDirectories)(relativeSrcFolders);
+    const paths = await (0, fs_1.listFunctionsDirectories)(srcFolders);
+    const functionsMap = await (0, runtimes_1.getFunctionsFromPaths)(paths, { config, featureFlags });
+    const functions = [...functionsMap.values()];
+    const augmentedFunctions = parseISC ? await Promise.all(functions.map(augmentWithISC)) : functions;
+    const listedFunctionsFiles = await Promise.all(augmentedFunctions.map((func) => getListedFunctionFiles(func, { basePath, featureFlags })));
+    return listedFunctionsFiles.flat();
 };
 exports.listFunctionsFiles = listFunctionsFiles;
 const getListedFunction = function ({ runtime, name, mainFile, extension, config, inSourceConfig, }) {
     var _a;
     return { name, mainFile, runtime: runtime.name, extension, schedule: (_a = inSourceConfig === null || inSourceConfig === void 0 ? void 0 : inSourceConfig.schedule) !== null && _a !== void 0 ? _a : config.schedule };
 };
-const getListedFunctionFiles = function (func, options) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const srcFiles = yield getSrcFiles(Object.assign(Object.assign({}, func), options));
-        return srcFiles.map((srcFile) => (Object.assign(Object.assign({}, getListedFunction(func)), { srcFile, extension: (0, path_1.extname)(srcFile) })));
-    });
+const getListedFunctionFiles = async function (func, options) {
+    const srcFiles = await getSrcFiles({ ...func, ...options });
+    return srcFiles.map((srcFile) => ({ ...getListedFunction(func), srcFile, extension: (0, path_1.extname)(srcFile) }));
 };
-const getSrcFiles = function (_a) {
-    var { extension, runtime, srcPath } = _a, args = __rest(_a, ["extension", "runtime", "srcPath"]);
-    return __awaiter(this, void 0, void 0, function* () {
-        const { getSrcFiles: getRuntimeSrcFiles } = runtime;
-        if (extension === '.zip' || typeof getRuntimeSrcFiles !== 'function') {
-            return [srcPath];
-        }
-        return yield getRuntimeSrcFiles(Object.assign({ extension,
-            runtime,
-            srcPath }, args));
+const getSrcFiles = async function ({ extension, runtime, srcPath, ...args }) {
+    const { getSrcFiles: getRuntimeSrcFiles } = runtime;
+    if (extension === '.zip' || typeof getRuntimeSrcFiles !== 'function') {
+        return [srcPath];
+    }
+    return await getRuntimeSrcFiles({
+        extension,
+        runtime,
+        srcPath,
+        ...args,
     });
 };
 var zip_1 = require("./zip");

package/dist/manifest.js

@@ -1,20 +1,11 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createManifest = void 0;
+const fs_1 = require("fs");
 const path_1 = require("path");
 const process_1 = require("process");
-const fs_1 = require("./utils/fs");
 const MANIFEST_VERSION = 1;
-const createManifest = ({ functions, path }) => __awaiter(void 0, void 0, void 0, function* () {
+const createManifest = async ({ functions, path }) => {
     const formattedFunctions = functions.map(formatFunctionForManifest);
     const payload = {
         functions: formattedFunctions,
@@ -22,8 +13,8 @@ const createManifest = ({ functions, path }) => __awaiter(void 0, void 0, void 0
         timestamp: Date.now(),
         version: MANIFEST_VERSION,
     };
-    yield (0, fs_1.writeFile)(path, JSON.stringify(payload));
-});
+    await fs_1.promises.writeFile(path, JSON.stringify(payload));
+};
 exports.createManifest = createManifest;
 const formatFunctionForManifest = ({ mainFile, name, path, runtime, schedule }) => ({
     mainFile,

package/dist/runtimes/detect_runtime.js

@@ -1,37 +1,26 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.detectBinaryRuntime = void 0;
 const elf_cam_1 = require("elf-cam");
 const fs_1 = require("../utils/fs");
 // Try to guess the runtime by inspecting the binary file.
-const detectBinaryRuntime = function ({ fsCache, path, }) {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            const buffer = yield (0, fs_1.cachedReadFile)(fsCache, path);
-            // We're using the Type Assertion because the `cachedReadFile` abstraction
-            // loses part of the return type information. We can safely say it's a
-            // Buffer in this case because we're not specifying an encoding.
-            const binaryType = (0, elf_cam_1.detect)(buffer);
-            switch (binaryType) {
-                case elf_cam_1.Runtime.Go:
-                    return 'go';
-                case elf_cam_1.Runtime.Rust:
-                    return 'rs';
-                default:
-                    return undefined;
-            }
+const detectBinaryRuntime = async function ({ fsCache, path, }) {
+    try {
+        const buffer = await (0, fs_1.cachedReadFile)(fsCache, path);
+        // We're using the Type Assertion because the `cachedReadFile` abstraction
+        // loses part of the return type information. We can safely say it's a
+        // Buffer in this case because we're not specifying an encoding.
+        const binaryType = (0, elf_cam_1.detect)(buffer);
+        switch (binaryType) {
+            case elf_cam_1.Runtime.Go:
+                return 'go';
+            case elf_cam_1.Runtime.Rust:
+                return 'rs';
+            default:
+                return undefined;
         }
-        catch (error) { }
-    });
+    }
+    catch { }
 };
 exports.detectBinaryRuntime = detectBinaryRuntime;
 //# sourceMappingURL=detect_runtime.js.map

package/dist/runtimes/go/builder.js

@@ -1,22 +1,13 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.build = void 0;
+const fs_1 = require("fs");
 const path_1 = require("path");
-const fs_1 = require("../../utils/fs");
 const shell_1 = require("../../utils/shell");
-const build = ({ destPath, mainFile, srcDir }) => __awaiter(void 0, void 0, void 0, function* () {
+const build = async ({ destPath, mainFile, srcDir }) => {
     const functionName = (0, path_1.basename)(srcDir);
     try {
-        yield (0, shell_1.runCommand)('go', ['build', '-o', destPath, '-ldflags', '-s -w'], {
+        await (0, shell_1.runCommand)('go', ['build', '-o', destPath, '-ldflags', '-s -w'], {
             cwd: srcDir,
             env: {
                 CGO_ENABLED: '0',
@@ -30,7 +21,7 @@ const build = ({ destPath, mainFile, srcDir }) => __awaiter(void 0, void 0, void
         console.error(`Could not compile Go function ${functionName}:\n`);
         throw error;
     }
-    const stat = yield (0, fs_1.lstat)(destPath);
+    const stat = await fs_1.promises.lstat(destPath);
     return {
         mainFile,
         name: functionName,
@@ -38,6 +29,6 @@ const build = ({ destPath, mainFile, srcDir }) => __awaiter(void 0, void 0, void
         srcPath: destPath,
         stat,
     };
-});
+};
 exports.build = build;
 //# sourceMappingURL=builder.js.map

package/dist/runtimes/go/index.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -16,46 +7,43 @@ const path_1 = require("path");
 const cp_file_1 = __importDefault(require("cp-file"));
 const fs_1 = require("../../utils/fs");
 const non_nullable_1 = require("../../utils/non_nullable");
+const zip_binary_1 = require("../../zip_binary");
 const detect_runtime_1 = require("../detect_runtime");
 const builder_1 = require("./builder");
-const detectGoFunction = ({ fsCache, path }) => __awaiter(void 0, void 0, void 0, function* () {
-    const stat = yield (0, fs_1.cachedLstat)(fsCache, path);
+const detectGoFunction = async ({ fsCache, path }) => {
+    const stat = await (0, fs_1.cachedLstat)(fsCache, path);
     if (!stat.isDirectory()) {
         return;
     }
     const directoryName = (0, path_1.basename)(path);
     // @ts-expect-error TODO: The `makeCachedFunction` abstraction is causing the
     // return value of `readdir` to be incorrectly typed.
-    const files = (yield (0, fs_1.cachedReaddir)(fsCache, path));
+    const files = (await (0, fs_1.cachedReaddir)(fsCache, path));
     const mainFileName = [`${directoryName}.go`, 'main.go'].find((name) => files.includes(name));
     if (mainFileName === undefined) {
         return;
     }
     return mainFileName;
-});
-const findFunctionsInPaths = function ({ featureFlags, fsCache, paths }) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const functions = yield Promise.all(paths.map((path) => findFunctionInPath({ featureFlags, fsCache, path })));
-        return functions.filter(non_nullable_1.nonNullable);
-    });
 };
-const findFunctionInPath = function ({ featureFlags, fsCache, path }) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const runtime = yield (0, detect_runtime_1.detectBinaryRuntime)({ fsCache, path });
-        if (runtime === 'go') {
-            return processBinary({ fsCache, path });
-        }
-        if (featureFlags.buildGoSource !== true) {
-            return;
-        }
-        const goSourceFile = yield detectGoFunction({ fsCache, path });
-        if (goSourceFile) {
-            return processSource({ fsCache, mainFile: goSourceFile, path });
-        }
-    });
+const findFunctionsInPaths = async function ({ featureFlags, fsCache, paths }) {
+    const functions = await Promise.all(paths.map((path) => findFunctionInPath({ featureFlags, fsCache, path })));
+    return functions.filter(non_nullable_1.nonNullable);
 };
-const processBinary = ({ fsCache, path }) => __awaiter(void 0, void 0, void 0, function* () {
-    const stat = (yield (0, fs_1.cachedLstat)(fsCache, path));
+const findFunctionInPath = async function ({ featureFlags, fsCache, path }) {
+    const runtime = await (0, detect_runtime_1.detectBinaryRuntime)({ fsCache, path });
+    if (runtime === 'go') {
+        return processBinary({ fsCache, path });
+    }
+    if (featureFlags.buildGoSource !== true) {
+        return;
+    }
+    const goSourceFile = await detectGoFunction({ fsCache, path });
+    if (goSourceFile) {
+        return processSource({ fsCache, mainFile: goSourceFile, path });
+    }
+};
+const processBinary = async ({ fsCache, path }) => {
+    const stat = (await (0, fs_1.cachedLstat)(fsCache, path));
     const extension = (0, path_1.extname)(path);
     const filename = (0, path_1.basename)(path);
     const name = (0, path_1.basename)(path, (0, path_1.extname)(path));
@@ -68,13 +56,13 @@ const processBinary = ({ fsCache, path }) => __awaiter(void 0, void 0, void 0, f
         srcPath: path,
         stat,
     };
-});
-const processSource = ({ fsCache, mainFile, path, }) => __awaiter(void 0, void 0, void 0, function* () {
+};
+const processSource = async ({ fsCache, mainFile, path, }) => {
     // TODO: This `stat` value is not going to be used, but we need it to satisfy
     // the `FunctionSource` interface. We should revisit whether `stat` should be
     // part of that interface in the first place, or whether we could compute it
     // downstream when needed (maybe using the FS cache as an optimisation).
-    const stat = (yield (0, fs_1.cachedLstat)(fsCache, path));
+    const stat = (await (0, fs_1.cachedLstat)(fsCache, path));
     const filename = (0, path_1.basename)(path);
     const extension = (0, path_1.extname)(mainFile);
     const name = (0, path_1.basename)(path, (0, path_1.extname)(path));
@@ -87,17 +75,42 @@ const processSource = ({ fsCache, mainFile, path, }) => __awaiter(void 0, void 0
         srcPath: path,
         stat,
     };
-});
-const zipFunction = function ({ config, destFolder, filename, mainFile, srcDir, srcPath }) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const destPath = (0, path_1.join)(destFolder, filename);
-        const isSource = (0, path_1.extname)(mainFile) === '.go';
-        // If we're building a Go function from source, we call the build method and
-        // it'll take care of placing the binary in the right location. If not, we
-        // need to copy the existing binary file to the destination directory.
-        yield (isSource ? (0, builder_1.build)({ destPath, mainFile, srcDir }) : (0, cp_file_1.default)(srcPath, destPath));
-        return { config, path: destPath };
-    });
+};
+const zipFunction = async function ({ config, destFolder, filename, mainFile, srcDir, srcPath, stat }) {
+    const destPath = (0, path_1.join)(destFolder, filename);
+    const isSource = (0, path_1.extname)(mainFile) === '.go';
+    let binary = {
+        path: srcPath,
+        stat,
+    };
+    // If we're building a Go function from source, we call the build method and
+    // update `binary` to point to the newly-created binary.
+    if (isSource) {
+        const { stat: binaryStat } = await (0, builder_1.build)({ destPath, mainFile, srcDir });
+        binary = {
+            path: destPath,
+            stat: binaryStat,
+        };
+    }
+    // If `zipGo` is enabled, we create a zip archive with the Go binary and the
+    // toolchain file.
+    if (config.zipGo) {
+        const zipPath = `${destPath}.zip`;
+        const zipOptions = {
+            destPath: zipPath,
+            filename: (0, path_1.basename)(destPath),
+            runtime,
+        };
+        await (0, zip_binary_1.zipBinary)({ ...zipOptions, srcPath: binary.path, stat: binary.stat });
+        return { config, path: zipPath };
+    }
+    // We don't need to zip the binary, so we can just copy it to the right path.
+    // We do this only if we're not building from source, as otherwise the build
+    // step already handled that.
+    if (!isSource) {
+        await (0, cp_file_1.default)(binary.path, destPath);
+    }
+    return { config, path: destPath };
 };
 const runtime = { findFunctionsInPaths, findFunctionInPath, name: 'go', zipFunction };
 exports.default = runtime;