@netlify/zip-it-and-ship-it 5.3.0 → 5.4.1

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 };
 };
@@ -28,8 +19,19 @@ const startZip = function (destPath) {
 exports.startZip = startZip;
 // Add new file to zip
 const addZipFile = function (archive, file, name, stat) {
-    // Ensure sha256 stability regardless of mtime
-    archive.file(file, { name, mode: stat.mode, date: new Date(0), stats: stat });
+    if (stat.isSymbolicLink()) {
+        const linkContent = (0, fs_1.readlinkSync)(file);
+        archive.symlink(name, linkContent, stat.mode);
+    }
+    else {
+        archive.file(file, {
+            name,
+            mode: stat.mode,
+            // Ensure sha256 stability regardless of mtime
+            date: new Date(0),
+            stats: stat,
+        });
+    }
 };
 exports.addZipFile = addZipFile;
 // Add new file content to zip
@@ -38,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/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.d.ts

@@ -6,6 +6,7 @@ interface ListedFunction {
     mainFile: string;
     runtime: RuntimeName;
     extension: string;
+    schedule?: string;
 }
 declare type ListedFunctionFile = ListedFunction & {
     srcFile: string;
@@ -14,10 +15,18 @@ interface ListFunctionsOptions {
     basePath?: string;
     config?: Config;
     featureFlags?: FeatureFlags;
+    parseISC?: boolean;
 }
-declare const listFunctions: (relativeSrcFolders: string | string[], { featureFlags: inputFeatureFlags }?: {
-    featureFlags?: FeatureFlags;
+declare const listFunctions: (relativeSrcFolders: string | string[], { featureFlags: inputFeatureFlags, config, parseISC, }?: {
+    featureFlags?: FeatureFlags | undefined;
+    config?: Config | undefined;
+    parseISC?: boolean | undefined;
 }) => Promise<ListedFunction[]>;
-declare const listFunctionsFiles: (relativeSrcFolders: string | string[], { basePath, config, featureFlags: inputFeatureFlags }?: ListFunctionsOptions) => Promise<ListedFunctionFile[]>;
-export { listFunctions, listFunctionsFiles };
+declare const listFunction: (path: string, { featureFlags: inputFeatureFlags, config, parseISC, }?: {
+    featureFlags?: FeatureFlags | undefined;
+    config?: Config | undefined;
+    parseISC?: boolean | undefined;
+}) => Promise<ListedFunction | undefined>;
+declare const listFunctionsFiles: (relativeSrcFolders: string | string[], { basePath, config, featureFlags: inputFeatureFlags, parseISC }?: ListFunctionsOptions) => Promise<ListedFunctionFile[]>;
+export { listFunctions, listFunction, listFunctionsFiles };
 export { zipFunction, zipFunctions } from './zip';

package/dist/main.js

@@ -1,74 +1,71 @@
 "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.listFunctions = void 0;
+exports.zipFunctions = exports.zipFunction = exports.listFunctionsFiles = exports.listFunction = exports.listFunctions = void 0;
 const path_1 = require("path");
 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 = async (func) => {
+    // ISC is currently only supported in JavaScript and TypeScript functions.
+    if (func.runtime.name !== 'js') {
+        return func;
+    }
+    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 } = {}) {
-    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 functions = yield (0, runtimes_1.getFunctionsFromPaths)(paths, { featureFlags });
-        const listedFunctions = [...functions.values()].map(getListedFunction);
-        return listedFunctions;
-    });
+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 = 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 } = {}) {
-    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 functions = yield (0, runtimes_1.getFunctionsFromPaths)(paths, { config, featureFlags });
-        const listedFunctionsFiles = yield Promise.all([...functions.values()].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 }) {
-    return { name, mainFile, runtime: runtime.name, extension };
+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));
-        const { name, mainFile, runtime } = func;
-        return srcFiles.map((srcFile) => ({ srcFile, name, mainFile, runtime: runtime.name, 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 };
 };
@@ -18,41 +9,40 @@ const fs_1 = require("../../utils/fs");
 const non_nullable_1 = require("../../utils/non_nullable");
 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) => __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 });
-            }
-        })));
-        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 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 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));
@@ -65,13 +55,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));
@@ -84,18 +74,16 @@ 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 runtime = { findFunctionsInPaths, name: 'go', zipFunction };
+const zipFunction = async function ({ config, destFolder, filename, mainFile, srcDir, srcPath }) {
+    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.
+    await (isSource ? (0, builder_1.build)({ destPath, mainFile, srcDir }) : (0, cp_file_1.default)(srcPath, destPath));
+    return { config, path: destPath };
+};
+const runtime = { findFunctionsInPaths, findFunctionInPath, name: 'go', zipFunction };
 exports.default = runtime;
 //# sourceMappingURL=index.js.map

package/dist/runtimes/index.d.ts

@@ -10,4 +10,11 @@ declare const getFunctionsFromPaths: (paths: string[], { config, dedupe, feature
     dedupe?: boolean | undefined;
     featureFlags?: FeatureFlags | undefined;
 }) => Promise<FunctionMap>;
-export { getFunctionsFromPaths };
+/**
+ * Gets a list of functions found in a list of paths.
+ */
+declare const getFunctionFromPath: (path: string, { config, featureFlags }?: {
+    config?: Config | undefined;
+    featureFlags?: FeatureFlags | undefined;
+}) => Promise<FunctionSource | undefined>;
+export { getFunctionsFromPaths, getFunctionFromPath };