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

package/dist/runtimes/rust/builder.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 };
 };
@@ -15,43 +6,39 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.build = void 0;
 const fs_1 = require("fs");
 const path_1 = require("path");
-const util_1 = require("util");
-const make_dir_1 = __importDefault(require("make-dir"));
 const tmp_promise_1 = __importDefault(require("tmp-promise"));
 const toml_1 = __importDefault(require("toml"));
-const fs_2 = require("../../utils/fs");
 const shell_1 = require("../../utils/shell");
 const constants_1 = require("./constants");
-const pReadFile = (0, util_1.promisify)(fs_1.readFile);
 const runtimeName = 'rs';
-const build = ({ config, name, srcDir }) => __awaiter(void 0, void 0, void 0, function* () {
+const build = async ({ config, name, srcDir }) => {
     const functionName = (0, path_1.basename)(srcDir);
     try {
-        yield installToolchainOnce();
+        await installToolchainOnce();
     }
     catch (error) {
         error.customErrorInfo = { type: 'functionsBundling', location: { functionName, runtime: runtimeName } };
         throw error;
     }
-    const targetDirectory = yield getTargetDirectory({ config, name });
-    yield cargoBuild({ functionName, srcDir, targetDirectory });
+    const targetDirectory = await getTargetDirectory({ config, name });
+    await cargoBuild({ functionName, srcDir, targetDirectory });
     // By default, the binary will have the same name as the crate and there's no
     // way to override it (https://github.com/rust-lang/cargo/issues/1706). We
     // must extract the crate name from the manifest and use it to form the path
     // to the binary.
-    const manifest = yield pReadFile((0, path_1.join)(srcDir, constants_1.MANIFEST_NAME), 'utf8');
+    const manifest = await fs_1.promises.readFile((0, path_1.join)(srcDir, constants_1.MANIFEST_NAME), 'utf8');
     const { package: { name: packageName }, } = toml_1.default.parse(manifest);
     const binaryPath = (0, path_1.join)(targetDirectory, constants_1.BUILD_TARGET, 'release', packageName);
-    const stat = yield (0, fs_2.lstat)(binaryPath);
+    const stat = await fs_1.promises.lstat(binaryPath);
     return {
         path: binaryPath,
         stat,
     };
-});
+};
 exports.build = build;
-const cargoBuild = ({ functionName, srcDir, targetDirectory, }) => __awaiter(void 0, void 0, void 0, function* () {
+const cargoBuild = async ({ functionName, srcDir, targetDirectory, }) => {
     try {
-        yield (0, shell_1.runCommand)('cargo', ['build', '--target', constants_1.BUILD_TARGET, '--release'], {
+        await (0, shell_1.runCommand)('cargo', ['build', '--target', constants_1.BUILD_TARGET, '--release'], {
             cwd: srcDir,
             env: {
                 CARGO_TARGET_DIR: targetDirectory,
@@ -59,7 +46,7 @@ const cargoBuild = ({ functionName, srcDir, targetDirectory, }) => __awaiter(voi
         });
     }
     catch (error) {
-        const hasToolchain = yield checkRustToolchain();
+        const hasToolchain = await checkRustToolchain();
         if (hasToolchain) {
             console.error(`Could not compile Rust function ${functionName}:\n`);
         }
@@ -70,38 +57,38 @@ const cargoBuild = ({ functionName, srcDir, targetDirectory, }) => __awaiter(voi
         error.customErrorInfo = { type: 'functionsBundling', location: { functionName, runtime: runtimeName } };
         throw error;
     }
-});
-const checkRustToolchain = () => __awaiter(void 0, void 0, void 0, function* () {
+};
+const checkRustToolchain = async () => {
     try {
-        yield (0, shell_1.runCommand)('cargo', ['-V']);
+        await (0, shell_1.runCommand)('cargo', ['-V']);
         return true;
     }
-    catch (_) {
+    catch {
         return false;
     }
-});
+};
 // Returns the path of the Cargo target directory.
-const getTargetDirectory = ({ config, name }) => __awaiter(void 0, void 0, void 0, function* () {
+const getTargetDirectory = async ({ config, name }) => {
     const { rustTargetDirectory } = config;
     // If the config includes a `rustTargetDirectory` path, we'll use that.
     if (rustTargetDirectory) {
         // We replace the [name] placeholder with the name of the function.
         const path = rustTargetDirectory.replace(/\[name]/g, name);
-        yield (0, make_dir_1.default)(path);
+        await fs_1.promises.mkdir(path, { recursive: true });
         return path;
     }
     // If the directory hasn't been configured, we'll use a temporary directory.
-    const { path } = yield tmp_promise_1.default.dir();
+    const { path } = await tmp_promise_1.default.dir();
     return path;
-});
+};
 let toolchainInstallation;
 // Sets the default toolchain and installs the build target defined in
 // `BUILD_TARGET`. The Promise is saved to `toolchainInstallation`, so
 // that we run the command just once for multiple Rust functions.
-const installToolchain = () => __awaiter(void 0, void 0, void 0, function* () {
-    yield (0, shell_1.runCommand)('rustup', ['default', 'stable']);
-    yield (0, shell_1.runCommand)('rustup', ['target', 'add', constants_1.BUILD_TARGET]);
-});
+const installToolchain = async () => {
+    await (0, shell_1.runCommand)('rustup', ['default', 'stable']);
+    await (0, shell_1.runCommand)('rustup', ['target', 'add', constants_1.BUILD_TARGET]);
+};
 const installToolchainOnce = () => {
     if (toolchainInstallation === undefined) {
         toolchainInstallation = installToolchain();

package/dist/runtimes/rust/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());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 const path_1 = require("path");
 const fs_1 = require("../../utils/fs");
@@ -16,49 +7,48 @@ const zip_binary_1 = require("../../zip_binary");
 const detect_runtime_1 = require("../detect_runtime");
 const builder_1 = require("./builder");
 const constants_1 = require("./constants");
-const detectRustFunction = ({ fsCache, path }) => __awaiter(void 0, void 0, void 0, function* () {
-    const stat = yield (0, fs_1.cachedLstat)(fsCache, path);
+const detectRustFunction = async ({ fsCache, path }) => {
+    const stat = await (0, fs_1.cachedLstat)(fsCache, path);
     if (!stat.isDirectory()) {
         return;
     }
     // @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 hasCargoManifest = files.includes(constants_1.MANIFEST_NAME);
     if (!hasCargoManifest) {
         return;
     }
     const mainFilePath = (0, path_1.join)(path, 'src', 'main.rs');
     try {
-        const mainFile = yield (0, fs_1.cachedLstat)(fsCache, mainFilePath);
+        const mainFile = await (0, fs_1.cachedLstat)(fsCache, mainFilePath);
         if (mainFile.isFile()) {
             return mainFilePath;
         }
     }
-    catch (_) {
+    catch {
         // no-op
     }
-});
-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 === 'rs') {
-                return processBinary({ fsCache, path });
-            }
-            if (featureFlags.buildRustSource !== true) {
-                return;
-            }
-            const rustSourceFile = yield detectRustFunction({ fsCache, path });
-            if (rustSourceFile) {
-                return processSource({ fsCache, mainFile: rustSourceFile, 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({ path, featureFlags, fsCache })));
+    return functions.filter(non_nullable_1.nonNullable);
+};
+const findFunctionInPath = async function ({ path, featureFlags, fsCache }) {
+    const runtime = await (0, detect_runtime_1.detectBinaryRuntime)({ fsCache, path });
+    if (runtime === 'rs') {
+        return processBinary({ fsCache, path });
+    }
+    if (featureFlags.buildRustSource !== true) {
+        return;
+    }
+    const rustSourceFile = await detectRustFunction({ fsCache, path });
+    if (rustSourceFile) {
+        return processSource({ fsCache, mainFile: rustSourceFile, path });
+    }
+};
+const processBinary = async ({ fsCache, path }) => {
+    const stat = (await (0, fs_1.cachedLstat)(fsCache, path));
     const filename = (0, path_1.basename)(path);
     const extension = (0, path_1.extname)(path);
     const name = (0, path_1.basename)(path, extension);
@@ -71,13 +61,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)(path);
     const name = (0, path_1.basename)(path, extension);
@@ -90,32 +80,30 @@ const processSource = ({ fsCache, mainFile, path, }) => __awaiter(void 0, void 0
         srcPath: path,
         stat,
     };
-});
+};
 // The name of the binary inside the zip file must always be `bootstrap`
 // because they include the Lambda runtime, and that's the name that AWS
 // expects for those kind of functions.
-const zipFunction = function ({ config, destFolder, filename, mainFile, runtime, srcDir, srcPath, stat, }) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const destPath = (0, path_1.join)(destFolder, `${filename}.zip`);
-        const isSource = (0, path_1.extname)(mainFile) === '.rs';
-        const zipOptions = {
-            destPath,
-            filename: 'bootstrap',
-            runtime,
-        };
-        // If we're building from source, we first need to build the source and zip
-        // the resulting binary. Otherwise, we're dealing with a binary so we zip it
-        // directly.
-        if (isSource) {
-            const { path: binaryPath, stat: binaryStat } = yield (0, builder_1.build)({ config, name: filename, srcDir });
-            yield (0, zip_binary_1.zipBinary)(Object.assign(Object.assign({}, zipOptions), { srcPath: binaryPath, stat: binaryStat }));
-        }
-        else {
-            yield (0, zip_binary_1.zipBinary)(Object.assign(Object.assign({}, zipOptions), { srcPath, stat }));
-        }
-        return { config, path: destPath };
-    });
+const zipFunction = async function ({ config, destFolder, filename, mainFile, runtime, srcDir, srcPath, stat, }) {
+    const destPath = (0, path_1.join)(destFolder, `${filename}.zip`);
+    const isSource = (0, path_1.extname)(mainFile) === '.rs';
+    const zipOptions = {
+        destPath,
+        filename: 'bootstrap',
+        runtime,
+    };
+    // If we're building from source, we first need to build the source and zip
+    // the resulting binary. Otherwise, we're dealing with a binary so we zip it
+    // directly.
+    if (isSource) {
+        const { path: binaryPath, stat: binaryStat } = await (0, builder_1.build)({ config, name: filename, srcDir });
+        await (0, zip_binary_1.zipBinary)({ ...zipOptions, srcPath: binaryPath, stat: binaryStat });
+    }
+    else {
+        await (0, zip_binary_1.zipBinary)({ ...zipOptions, srcPath, stat });
+    }
+    return { config, path: destPath };
 };
-const runtime = { findFunctionsInPaths, name: 'rs', zipFunction };
+const runtime = { findFunctionsInPaths, findFunctionInPath, name: 'rs', zipFunction };
 exports.default = runtime;
 //# sourceMappingURL=index.js.map

package/dist/utils/archive_size.js

@@ -1,26 +1,17 @@
 "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.addArchiveSize = void 0;
+const fs_1 = require("fs");
 const path_1 = require("path");
-const fs_1 = require("./fs");
 // Returns the input object with an additional `size` property containing the
 // size of the file at `path` when it is a ZIP archive.
-const addArchiveSize = (result) => __awaiter(void 0, void 0, void 0, function* () {
+const addArchiveSize = async (result) => {
     const { path } = result;
     if ((0, path_1.extname)(path) !== '.zip') {
         return result;
     }
-    const { size } = yield (0, fs_1.stat)(path);
-    return Object.assign(Object.assign({}, result), { size });
-});
+    const { size } = await fs_1.promises.stat(path);
+    return { ...result, size };
+};
 exports.addArchiveSize = addArchiveSize;
 //# sourceMappingURL=archive_size.js.map

package/dist/utils/format_result.js

@@ -5,7 +5,12 @@ const remove_undefined_1 = require("./remove_undefined");
 // Takes the result of zipping a function and formats it for output.
 const formatZipResult = (archive) => {
     var _a, _b, _c;
-    const functionResult = Object.assign(Object.assign({}, archive), { inSourceConfig: undefined, runtime: archive.runtime.name, schedule: (_b = (_a = archive.inSourceConfig) === null || _a === void 0 ? void 0 : _a.schedule) !== null && _b !== void 0 ? _b : (_c = archive === null || archive === void 0 ? void 0 : archive.config) === null || _c === void 0 ? void 0 : _c.schedule });
+    const functionResult = {
+        ...archive,
+        inSourceConfig: undefined,
+        runtime: archive.runtime.name,
+        schedule: (_b = (_a = archive.inSourceConfig) === null || _a === void 0 ? void 0 : _a.schedule) !== null && _b !== void 0 ? _b : (_c = archive === null || archive === void 0 ? void 0 : archive.config) === null || _c === void 0 ? void 0 : _c.schedule,
+    };
     return (0, remove_undefined_1.removeUndefined)(functionResult);
 };
 exports.formatZipResult = formatZipResult;

package/dist/utils/fs.d.ts

@@ -1,22 +1,18 @@
 /// <reference types="node" />
-import { lstat, readFile, stat, writeFile } from 'fs';
-declare const pLstat: typeof lstat.__promisify__;
-declare const pReadFile: typeof readFile.__promisify__;
-declare const pStat: typeof stat.__promisify__;
-declare const pWriteFile: typeof writeFile.__promisify__;
+import { promises as fs } from 'fs';
 declare type FsCache = Record<string, unknown>;
-declare const cachedLstat: (cache: FsCache, path: string, options?: import("fs").StatOptions | undefined) => Promise<import("fs").Stats | import("fs").BigIntStats>;
+declare const cachedLstat: (cache: FsCache, path: string, opts?: import("fs").StatOptions | undefined) => Promise<import("fs").Stats | import("fs").BigIntStats>;
 declare const cachedReaddir: (cache: FsCache, path: string, options: import("fs").ObjectEncodingOptions & {
     withFileTypes: true;
 }) => Promise<import("fs").Dirent[]>;
-declare const cachedReadFile: (cache: FsCache, path: string, options?: BufferEncoding | (import("fs").ObjectEncodingOptions & {
-    flag?: string | undefined;
+declare const cachedReadFile: (cache: FsCache, path: string, options?: BufferEncoding | (import("fs").ObjectEncodingOptions & import("events").Abortable & {
+    flag?: import("fs").OpenMode | undefined;
 }) | null | undefined) => Promise<string | Buffer>;
 declare const getPathWithExtension: (path: string, extension: string) => string;
 declare const safeUnlink: (path: string) => Promise<void>;
 declare const listFunctionsDirectories: (srcFolders: string[]) => Promise<string[]>;
 declare const listFunctionsDirectory: (srcFolder: string) => Promise<string[]>;
 declare const resolveFunctionsDirectories: (input: string | string[]) => string[];
-declare const mkdirAndWriteFile: typeof pWriteFile;
-export { cachedLstat, cachedReaddir, cachedReadFile, pLstat as lstat, getPathWithExtension, listFunctionsDirectories, listFunctionsDirectory, resolveFunctionsDirectories, safeUnlink, pStat as stat, pWriteFile as writeFile, pReadFile as readFile, mkdirAndWriteFile, };
+declare const mkdirAndWriteFile: typeof fs.writeFile;
+export { cachedLstat, cachedReaddir, cachedReadFile, getPathWithExtension, listFunctionsDirectories, listFunctionsDirectory, resolveFunctionsDirectories, safeUnlink, mkdirAndWriteFile, };
 export type { FsCache };

package/dist/utils/fs.js

@@ -1,33 +1,9 @@
 "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 };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mkdirAndWriteFile = exports.readFile = exports.writeFile = exports.stat = exports.safeUnlink = exports.resolveFunctionsDirectories = exports.listFunctionsDirectory = exports.listFunctionsDirectories = exports.getPathWithExtension = exports.lstat = exports.cachedReadFile = exports.cachedReaddir = exports.cachedLstat = void 0;
+exports.mkdirAndWriteFile = exports.safeUnlink = exports.resolveFunctionsDirectories = exports.listFunctionsDirectory = exports.listFunctionsDirectories = exports.getPathWithExtension = exports.cachedReadFile = exports.cachedReaddir = exports.cachedLstat = void 0;
 const fs_1 = require("fs");
 const path_1 = require("path");
-const util_1 = require("util");
-const make_dir_1 = __importDefault(require("make-dir"));
 const non_nullable_1 = require("./non_nullable");
-const pLstat = (0, util_1.promisify)(fs_1.lstat);
-exports.lstat = pLstat;
-const pReaddir = (0, util_1.promisify)(fs_1.readdir);
-const pReadFile = (0, util_1.promisify)(fs_1.readFile);
-exports.readFile = pReadFile;
-const pStat = (0, util_1.promisify)(fs_1.stat);
-exports.stat = pStat;
-const pUnlink = (0, util_1.promisify)(fs_1.unlink);
-const pWriteFile = (0, util_1.promisify)(fs_1.writeFile);
-exports.writeFile = pWriteFile;
 // This caches multiple FS calls to the same path. It creates a cache key with
 // the name of the function and the path (e.g. "readdir:/some/directory").
 //
@@ -42,53 +18,49 @@ const makeCachedFunction = (func) => (cache, path, ...args) => {
     }
     return cache[key];
 };
-const cachedLstat = makeCachedFunction(pLstat);
+const cachedLstat = makeCachedFunction(fs_1.promises.lstat);
 exports.cachedLstat = cachedLstat;
-const cachedReaddir = makeCachedFunction(pReaddir);
+const cachedReaddir = makeCachedFunction(fs_1.promises.readdir);
 exports.cachedReaddir = cachedReaddir;
-const cachedReadFile = makeCachedFunction(pReadFile);
+const cachedReadFile = makeCachedFunction(fs_1.promises.readFile);
 exports.cachedReadFile = cachedReadFile;
-const getPathWithExtension = (path, extension) => (0, path_1.format)(Object.assign(Object.assign({}, (0, path_1.parse)(path)), { base: undefined, ext: extension }));
+const getPathWithExtension = (path, extension) => (0, path_1.format)({ ...(0, path_1.parse)(path), base: undefined, ext: extension });
 exports.getPathWithExtension = getPathWithExtension;
-const safeUnlink = (path) => __awaiter(void 0, void 0, void 0, function* () {
+const safeUnlink = async (path) => {
     try {
-        yield pUnlink(path);
+        await fs_1.promises.unlink(path);
     }
-    catch (_) { }
-});
+    catch { }
+};
 exports.safeUnlink = safeUnlink;
 // Takes a list of absolute paths and returns an array containing all the
 // filenames within those directories, if at least one of the directories
 // exists. If not, an error is thrown.
-const listFunctionsDirectories = function (srcFolders) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const filenamesByDirectory = yield Promise.all(srcFolders.map((srcFolder) => __awaiter(this, void 0, void 0, function* () {
-            try {
-                const filenames = yield listFunctionsDirectory(srcFolder);
-                return filenames;
-            }
-            catch (error) {
-                return null;
-            }
-        })));
-        const validDirectories = filenamesByDirectory.filter(non_nullable_1.nonNullable);
-        if (validDirectories.length === 0) {
-            throw new Error(`Functions folder does not exist: ${srcFolders.join(', ')}`);
-        }
-        return validDirectories.flat();
-    });
-};
-exports.listFunctionsDirectories = listFunctionsDirectories;
-const listFunctionsDirectory = function (srcFolder) {
-    return __awaiter(this, void 0, void 0, function* () {
+const listFunctionsDirectories = async function (srcFolders) {
+    const filenamesByDirectory = await Promise.all(srcFolders.map(async (srcFolder) => {
         try {
-            const filenames = yield pReaddir(srcFolder);
-            return filenames.map((name) => (0, path_1.join)(srcFolder, name));
+            const filenames = await listFunctionsDirectory(srcFolder);
+            return filenames;
         }
-        catch (error) {
-            throw new Error(`Functions folder does not exist: ${srcFolder}`);
+        catch {
+            return null;
         }
-    });
+    }));
+    const validDirectories = filenamesByDirectory.filter(non_nullable_1.nonNullable);
+    if (validDirectories.length === 0) {
+        throw new Error(`Functions folder does not exist: ${srcFolders.join(', ')}`);
+    }
+    return validDirectories.flat();
+};
+exports.listFunctionsDirectories = listFunctionsDirectories;
+const listFunctionsDirectory = async function (srcFolder) {
+    try {
+        const filenames = await fs_1.promises.readdir(srcFolder);
+        return filenames.map((name) => (0, path_1.join)(srcFolder, name));
+    }
+    catch {
+        throw new Error(`Functions folder does not exist: ${srcFolder}`);
+    }
 };
 exports.listFunctionsDirectory = listFunctionsDirectory;
 const resolveFunctionsDirectories = (input) => {
@@ -97,12 +69,12 @@ const resolveFunctionsDirectories = (input) => {
     return absoluteDirectories;
 };
 exports.resolveFunctionsDirectories = resolveFunctionsDirectories;
-const mkdirAndWriteFile = (path, ...params) => __awaiter(void 0, void 0, void 0, function* () {
+const mkdirAndWriteFile = async (path, ...params) => {
     if (typeof path === 'string') {
         const directory = (0, path_1.dirname)(path);
-        yield (0, make_dir_1.default)(directory);
+        await fs_1.promises.mkdir(directory, { recursive: true });
     }
-    return pWriteFile(path, ...params);
-});
+    return fs_1.promises.writeFile(path, ...params);
+};
 exports.mkdirAndWriteFile = mkdirAndWriteFile;
 //# sourceMappingURL=fs.js.map