@netlify/zip-it-and-ship-it 7.1.2 → 8.1.0

package/dist/archive.js

@@ -1,26 +1,19 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.endZip = exports.addZipContent = exports.addZipFile = exports.startZip = void 0;
-const fs_1 = require("fs");
-const util_1 = require("util");
-const archiver_1 = __importDefault(require("archiver"));
-const end_of_stream_1 = __importDefault(require("end-of-stream"));
-const pEndOfStream = (0, util_1.promisify)(end_of_stream_1.default);
+import { createWriteStream, readlinkSync } from 'fs';
+import { promisify } from 'util';
+import archiver from 'archiver';
+import endOfStream from 'end-of-stream';
+const pEndOfStream = promisify(endOfStream);
 // Start zipping files
-const startZip = function (destPath) {
-    const output = (0, fs_1.createWriteStream)(destPath);
-    const archive = (0, archiver_1.default)('zip');
+export const startZip = function (destPath) {
+    const output = createWriteStream(destPath);
+    const archive = archiver('zip');
     archive.pipe(output);
     return { archive, output };
 };
-exports.startZip = startZip;
 // Add new file to zip
-const addZipFile = function (archive, file, name, stat) {
+export const addZipFile = function (archive, file, name, stat) {
     if (stat.isSymbolicLink()) {
-        const linkContent = (0, fs_1.readlinkSync)(file);
+        const linkContent = readlinkSync(file);
         archive.symlink(name, linkContent, stat.mode);
     }
     else {
@@ -33,16 +26,13 @@ const addZipFile = function (archive, file, name, stat) {
         });
     }
 };
-exports.addZipFile = addZipFile;
 // Add new file content to zip
-const addZipContent = function (archive, content, name) {
+export const addZipContent = function (archive, content, name) {
     archive.append(content, { name, date: new Date(0) });
 };
-exports.addZipContent = addZipContent;
 // End zipping files
-const endZip = async function (archive, output) {
+export const endZip = async function (archive, output) {
     archive.finalize();
     await pEndOfStream(output);
 };
-exports.endZip = endZip;
 //# sourceMappingURL=archive.js.map

package/dist/bin.js

@@ -1,13 +1,8 @@
 #!/usr/bin/env node
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const process_1 = require("process");
-const yargs_1 = __importDefault(require("yargs"));
-const helpers_1 = require("yargs/helpers");
-const main_js_1 = require("./main.js");
+import { argv, exit } from 'process';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import { zipFunctions } from './main.js';
 // CLI entry point
 const runCli = async function () {
     // @ts-expect-error TODO: `destFolder` and  `srcFolder` are not being passed
@@ -16,16 +11,16 @@ const runCli = async function () {
     try {
         global.ZISI_CLI = true;
         // @ts-expect-error TODO: `options` is not getting the right types.
-        const zipped = await (0, main_js_1.zipFunctions)(srcFolder, destFolder, options);
+        const zipped = await zipFunctions(srcFolder, destFolder, options);
         console.log(JSON.stringify(zipped, null, 2));
     }
     catch (error) {
         console.error(error.toString());
-        (0, process_1.exit)(1);
+        exit(1);
     }
 };
 const parseArgs = function () {
-    return (0, yargs_1.default)((0, helpers_1.hideBin)(process_1.argv))
+    return yargs(hideBin(argv))
         .command('* <srcFolder> <destFolder>', 'Create ZIP archives from a directory')
         .options(OPTIONS)
         .usage(USAGE)

package/dist/config.js

@@ -1,20 +1,15 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getConfigForFunction = void 0;
-const fs_1 = require("fs");
-const path_1 = require("path");
-const is_path_inside_1 = __importDefault(require("is-path-inside"));
-const merge_options_1 = __importDefault(require("merge-options"));
-const matching_js_1 = require("./utils/matching.js");
+import { promises as fs } from 'fs';
+import { basename, extname, dirname, join } from 'path';
+import isPathInside from 'is-path-inside';
+// @ts-expect-error Typescript cannot find definition
+import mergeOptions from 'merge-options';
+import { minimatch } from './utils/matching.js';
 const getConfigForFunction = async ({ config, configFileDirectories, func, featureFlags, }) => {
     const fromConfig = getFromMainConfig({ config, func });
     // We try to read from a function config file if the function directory is
     // inside one of `configFileDirectories`.
     const shouldReadConfigFile = featureFlags.project_deploy_configuration_api_use_per_function_configuration_files &&
-        (configFileDirectories === null || configFileDirectories === void 0 ? void 0 : configFileDirectories.some((directory) => (0, is_path_inside_1.default)(func.mainFile, directory)));
+        configFileDirectories?.some((directory) => isPathInside(func.mainFile, directory));
     if (!shouldReadConfigFile) {
         return fromConfig;
     }
@@ -24,14 +19,13 @@ const getConfigForFunction = async ({ config, configFileDirectories, func, featu
         ...fromFile,
     };
 };
-exports.getConfigForFunction = getConfigForFunction;
 const getFromMainConfig = ({ config, func, }) => {
     if (!config) {
         return {};
     }
     // It's safe to mutate the array because it's local to this function.
     const matches = Object.keys(config)
-        .filter((expression) => (0, matching_js_1.minimatch)(func.name, expression))
+        .filter((expression) => minimatch(func.name, expression))
         .map((expression) => {
         const wildcardCount = [...expression].filter((char) => char === '*').length;
         // The weight increases with the number of hardcoded (i.e. non-wildcard)
@@ -46,13 +40,13 @@ const getFromMainConfig = ({ config, func, }) => {
     })
         .sort(({ weight: weightA }, { weight: weightB }) => weightA - weightB)
         .map(({ expression }) => config[expression]);
-    return merge_options_1.default.apply({ concatArrays: true, ignoreUndefined: true }, matches);
+    return mergeOptions.apply({ concatArrays: true, ignoreUndefined: true }, matches);
 };
 const getFromFile = async (func) => {
-    const filename = `${(0, path_1.basename)(func.mainFile, (0, path_1.extname)(func.mainFile))}.json`;
-    const configFilePath = (0, path_1.join)((0, path_1.dirname)(func.mainFile), filename);
+    const filename = `${basename(func.mainFile, extname(func.mainFile))}.json`;
+    const configFilePath = join(dirname(func.mainFile), filename);
     try {
-        const data = await fs_1.promises.readFile(configFilePath, 'utf8');
+        const data = await fs.readFile(configFilePath, 'utf8');
         const configFile = JSON.parse(data);
         if (configFile.version === 1) {
             return configFile.config;
@@ -63,4 +57,5 @@ const getFromFile = async (func) => {
     }
     return {};
 };
+export { getConfigForFunction };
 //# sourceMappingURL=config.js.map

package/dist/feature_flags.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFlags = exports.defaultFlags = void 0;
-const process_1 = require("process");
-exports.defaultFlags = {
+import { env } from 'process';
+export const defaultFlags = {
     // Build Rust functions from source.
-    buildRustSource: Boolean(process_1.env.NETLIFY_EXPERIMENTAL_BUILD_RUST_SOURCE),
+    buildRustSource: Boolean(env.NETLIFY_EXPERIMENTAL_BUILD_RUST_SOURCE),
     // Use esbuild to trace dependencies in the legacy bundler.
     parseWithEsbuild: false,
     // Use NFT as the default bundler.
@@ -17,11 +14,16 @@ exports.defaultFlags = {
     zisi_pure_esm_mjs: false,
     // Load configuration from per-function JSON files.
     project_deploy_configuration_api_use_per_function_configuration_files: false,
+    // Enable runtime cache for NFT
+    zisi_nft_use_cache: false,
+    // Raise file IO limit for NFT
+    zisi_nft_higher_fileio_limit: false,
+    // Provide banner to esbuild which allows requires in ESM output
+    zisi_esbuild_require_banner: false,
 };
 // List of supported flags and their default value.
-const getFlags = (input = {}, flags = exports.defaultFlags) => Object.entries(flags).reduce((result, [key, defaultValue]) => ({
+export const getFlags = (input = {}, flags = defaultFlags) => 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/function.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="node" />
+/// <reference types="node" resolution-mode="require"/>
 import { Stats } from 'fs';
 import type { FunctionConfig } from './config.js';
 import type { Runtime, ZipFunctionResult } from './runtimes/runtime.js';

package/dist/function.js

@@ -1,3 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};
 //# sourceMappingURL=function.js.map

package/dist/main.d.ts

@@ -21,14 +21,14 @@ interface ListFunctionsOptions {
     featureFlags?: FeatureFlags;
     parseISC?: boolean;
 }
-export declare const listFunctions: (relativeSrcFolders: string | string[], { featureFlags, config, parseISC, }?: {
+export declare const listFunctions: (relativeSrcFolders: string | string[], { featureFlags: inputFeatureFlags, config, parseISC, }?: {
     featureFlags?: FeatureFlags | undefined;
     config?: Config | undefined;
     parseISC?: boolean | undefined;
 }) => Promise<ListedFunction[]>;
-export declare const listFunction: (path: string, { featureFlags, config, parseISC, }?: {
+export declare const listFunction: (path: string, { featureFlags: inputFeatureFlags, config, parseISC, }?: {
     featureFlags?: FeatureFlags | undefined;
     config?: Config | undefined;
     parseISC?: boolean | undefined;
 }) => Promise<ListedFunction | undefined>;
-export declare const listFunctionsFiles: (relativeSrcFolders: string | string[], { basePath, config, featureFlags, parseISC }?: ListFunctionsOptions) => Promise<ListedFunctionFile[]>;
+export declare const listFunctionsFiles: (relativeSrcFolders: string | string[], { basePath, config, featureFlags: inputFeatureFlags, parseISC }?: ListFunctionsOptions) => Promise<ListedFunctionFile[]>;

package/dist/main.js

@@ -1,63 +1,58 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.listFunctionsFiles = exports.listFunction = exports.listFunctions = exports.zipFunctions = exports.zipFunction = void 0;
-const path_1 = require("path");
-const feature_flags_js_1 = require("./feature_flags.js");
-const index_js_1 = require("./runtimes/index.js");
-const index_js_2 = require("./runtimes/node/in_source_config/index.js");
-const fs_js_1 = require("./utils/fs.js");
-var zip_js_1 = require("./zip.js");
-Object.defineProperty(exports, "zipFunction", { enumerable: true, get: function () { return zip_js_1.zipFunction; } });
-Object.defineProperty(exports, "zipFunctions", { enumerable: true, get: function () { return zip_js_1.zipFunctions; } });
+import { extname } from 'path';
+import { getFlags } from './feature_flags.js';
+import { getFunctionFromPath, getFunctionsFromPaths } from './runtimes/index.js';
+import { findISCDeclarationsInPath } from './runtimes/node/in_source_config/index.js';
+import { RuntimeCache } from './utils/cache.js';
+import { listFunctionsDirectories, resolveFunctionsDirectories } from './utils/fs.js';
+export { zipFunction, zipFunctions } from './zip.js';
 const augmentWithISC = async (func) => {
     // ISC is currently only supported in JavaScript and TypeScript functions.
     if (func.runtime.name !== "js" /* RuntimeType.JAVASCRIPT */) {
         return func;
     }
-    const inSourceConfig = await (0, index_js_2.findISCDeclarationsInPath)(func.mainFile, func.name);
+    const inSourceConfig = await findISCDeclarationsInPath(func.mainFile, func.name);
     return { ...func, inSourceConfig };
 };
 // List all Netlify Functions main entry files for a specific directory
-const listFunctions = async function (relativeSrcFolders, { featureFlags: inputFeatureFlags, config, parseISC = false, } = {}) {
-    const featureFlags = (0, feature_flags_js_1.getFlags)(inputFeatureFlags);
-    const srcFolders = (0, fs_js_1.resolveFunctionsDirectories)(relativeSrcFolders);
-    const paths = await (0, fs_js_1.listFunctionsDirectories)(srcFolders);
-    const functionsMap = await (0, index_js_1.getFunctionsFromPaths)(paths, { featureFlags, config });
+export const listFunctions = async function (relativeSrcFolders, { featureFlags: inputFeatureFlags, config, parseISC = false, } = {}) {
+    const featureFlags = getFlags(inputFeatureFlags);
+    const srcFolders = resolveFunctionsDirectories(relativeSrcFolders);
+    const paths = await listFunctionsDirectories(srcFolders);
+    const cache = new RuntimeCache();
+    const functionsMap = await getFunctionsFromPaths(paths, { cache, config, featureFlags });
     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_js_1.getFlags)(inputFeatureFlags);
-    const func = await (0, index_js_1.getFunctionFromPath)(path, { featureFlags, config });
+export const listFunction = async function (path, { featureFlags: inputFeatureFlags, config, parseISC = false, } = {}) {
+    const featureFlags = getFlags(inputFeatureFlags);
+    const cache = new RuntimeCache();
+    const func = await getFunctionFromPath(path, { cache, config, featureFlags });
     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 = async function (relativeSrcFolders, { basePath, config, featureFlags: inputFeatureFlags, parseISC = false } = {}) {
-    const featureFlags = (0, feature_flags_js_1.getFlags)(inputFeatureFlags);
-    const srcFolders = (0, fs_js_1.resolveFunctionsDirectories)(relativeSrcFolders);
-    const paths = await (0, fs_js_1.listFunctionsDirectories)(srcFolders);
-    const functionsMap = await (0, index_js_1.getFunctionsFromPaths)(paths, { config, featureFlags });
+export const listFunctionsFiles = async function (relativeSrcFolders, { basePath, config, featureFlags: inputFeatureFlags, parseISC = false } = {}) {
+    const featureFlags = getFlags(inputFeatureFlags);
+    const srcFolders = resolveFunctionsDirectories(relativeSrcFolders);
+    const paths = await listFunctionsDirectories(srcFolders);
+    const cache = new RuntimeCache();
+    const functionsMap = await getFunctionsFromPaths(paths, { cache, 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 };
+    return { name, mainFile, runtime: runtime.name, extension, schedule: inSourceConfig?.schedule ?? config.schedule };
 };
 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) }));
+    return srcFiles.map((srcFile) => ({ ...getListedFunction(func), srcFile, extension: extname(srcFile) }));
 };
 const getSrcFiles = async function ({ extension, runtime, srcPath, ...args }) {
     const { getSrcFiles: getRuntimeSrcFiles } = runtime;

package/dist/manifest.js

@@ -1,25 +1,21 @@
-"use strict";
-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");
+import { promises as fs } from 'fs';
+import { resolve } from 'path';
+import { arch, platform } from 'process';
 const MANIFEST_VERSION = 1;
-const createManifest = async ({ functions, path }) => {
+export const createManifest = async ({ functions, path }) => {
     const formattedFunctions = functions.map(formatFunctionForManifest);
     const payload = {
         functions: formattedFunctions,
-        system: { arch: process_1.arch, platform: process_1.platform },
+        system: { arch, platform },
         timestamp: Date.now(),
         version: MANIFEST_VERSION,
     };
-    await fs_1.promises.writeFile(path, JSON.stringify(payload));
+    await fs.writeFile(path, JSON.stringify(payload));
 };
-exports.createManifest = createManifest;
 const formatFunctionForManifest = ({ mainFile, name, path, runtime, schedule }) => ({
     mainFile,
     name,
-    path: (0, path_1.resolve)(path),
+    path: resolve(path),
     runtime,
     schedule,
 });

package/dist/runtimes/detect_runtime.d.ts

@@ -1,6 +1,4 @@
-import { FsCache } from '../utils/fs.js';
 import { RuntimeType } from './runtime.js';
-export declare const detectBinaryRuntime: ({ fsCache, path, }: {
-    fsCache: FsCache;
+export declare const detectBinaryRuntime: ({ path }: {
     path: string;
 }) => Promise<RuntimeType | undefined>;

package/dist/runtimes/detect_runtime.js

@@ -1,32 +1,26 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.detectBinaryRuntime = void 0;
-const binary_info_1 = require("@netlify/binary-info");
-const fs_js_1 = require("../utils/fs.js");
-const isValidFunctionBinary = (info) => info.arch === binary_info_1.Arch.Amd64 && info.platform === binary_info_1.Platform.Linux;
+import { readFile } from 'fs/promises';
+import { detect, Runtime as BinaryRuntime, Arch, Platform } from '@netlify/binary-info';
+const isValidFunctionBinary = (info) => info.arch === Arch.Amd64 && info.platform === Platform.Linux;
 const warnIncompatibleBinary = function (path, binaryInfo) {
     if (!global.ZISI_CLI) {
         console.warn(`
 Found incompatible prebuilt function binary in ${path}.
-The binary needs to be built for Linux/Amd64, but it was built for ${binary_info_1.Platform[binaryInfo.platform]}/${binary_info_1.Arch[binaryInfo.arch]}`);
+The binary needs to be built for Linux/Amd64, but it was built for ${Platform[binaryInfo.platform]}/${Arch[binaryInfo.arch]}`);
     }
     return undefined;
 };
 // Try to guess the runtime by inspecting the binary file.
-const detectBinaryRuntime = async function ({ fsCache, path, }) {
+export const detectBinaryRuntime = async function ({ path }) {
     try {
-        const buffer = await (0, fs_js_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 binaryInfo = (0, binary_info_1.detect)(buffer);
+        const fileContents = await readFile(path);
+        const binaryInfo = detect(fileContents);
         if (!isValidFunctionBinary(binaryInfo)) {
             return warnIncompatibleBinary(path, binaryInfo);
         }
         switch (binaryInfo.runtime) {
-            case binary_info_1.Runtime.Go:
+            case BinaryRuntime.Go:
                 return "go" /* RuntimeType.GO */;
-            case binary_info_1.Runtime.Rust:
+            case BinaryRuntime.Rust:
                 return "rs" /* RuntimeType.RUST */;
             default:
                 return undefined;
@@ -36,5 +30,4 @@ const detectBinaryRuntime = async function ({ fsCache, path, }) {
         // Possible errors are: non binary files, arch/platforms not supported by binary-info, path is directory
     }
 };
-exports.detectBinaryRuntime = detectBinaryRuntime;
 //# sourceMappingURL=detect_runtime.js.map

package/dist/runtimes/go/builder.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="node" />
+/// <reference types="node" resolution-mode="require"/>
 export declare const build: ({ destPath, mainFile, srcDir }: {
     destPath: string;
     mainFile: string;

package/dist/runtimes/go/builder.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.build = void 0;
-const fs_1 = require("fs");
-const path_1 = require("path");
-const error_js_1 = require("../../utils/error.js");
-const shell_js_1 = require("../../utils/shell.js");
-const build = async ({ destPath, mainFile, srcDir }) => {
-    const functionName = (0, path_1.basename)(srcDir);
+import { promises as fs } from 'fs';
+import { basename } from 'path';
+import { FunctionBundlingUserError } from '../../utils/error.js';
+import { shellUtils } from '../../utils/shell.js';
+export const build = async ({ destPath, mainFile, srcDir }) => {
+    const functionName = basename(srcDir);
     try {
-        await shell_js_1.shellUtils.runCommand('go', ['build', '-o', destPath, '-ldflags', '-s -w'], {
+        await shellUtils.runCommand('go', ['build', '-o', destPath, '-ldflags', '-s -w'], {
             cwd: srcDir,
             env: {
                 CGO_ENABLED: '0',
@@ -19,9 +16,9 @@ const build = async ({ destPath, mainFile, srcDir }) => {
     }
     catch (error) {
         console.error(`Could not compile Go function ${functionName}:\n`);
-        throw error_js_1.FunctionBundlingUserError.addCustomErrorInfo(error, { functionName, runtime: "go" /* RuntimeType.GO */ });
+        throw FunctionBundlingUserError.addCustomErrorInfo(error, { functionName, runtime: "go" /* RuntimeType.GO */ });
     }
-    const stat = await fs_1.promises.lstat(destPath);
+    const stat = await fs.lstat(destPath);
     return {
         mainFile,
         name: functionName,
@@ -30,5 +27,4 @@ const build = async ({ destPath, mainFile, srcDir }) => {
         stat,
     };
 };
-exports.build = build;
 //# sourceMappingURL=builder.js.map

package/dist/runtimes/go/index.js

@@ -1,72 +1,65 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const path_1 = require("path");
-const cp_file_1 = __importDefault(require("cp-file"));
-const fs_js_1 = require("../../utils/fs.js");
-const non_nullable_js_1 = require("../../utils/non_nullable.js");
-const zip_binary_js_1 = require("../../zip_binary.js");
-const detect_runtime_js_1 = require("../detect_runtime.js");
-const builder_js_1 = require("./builder.js");
-const detectGoFunction = async ({ fsCache, path }) => {
-    const stat = await (0, fs_js_1.cachedLstat)(fsCache, path);
+import { basename, dirname, extname, join } from 'path';
+import { copyFile } from 'cp-file';
+import { cachedLstat, cachedReaddir } from '../../utils/fs.js';
+import { nonNullable } from '../../utils/non_nullable.js';
+import { zipBinary } from '../../zip_binary.js';
+import { detectBinaryRuntime } from '../detect_runtime.js';
+import { build } from './builder.js';
+const detectGoFunction = async ({ cache, path }) => {
+    const stat = await cachedLstat(cache.lstatCache, 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 = (await (0, fs_js_1.cachedReaddir)(fsCache, path));
+    const directoryName = basename(path);
+    const files = await cachedReaddir(cache.readdirCache, path);
     const mainFileName = [`${directoryName}.go`, 'main.go'].find((name) => files.includes(name));
     if (mainFileName === undefined) {
         return;
     }
     return mainFileName;
 };
-const findFunctionsInPaths = async function ({ featureFlags, fsCache, paths }) {
-    const functions = await Promise.all(paths.map((path) => findFunctionInPath({ featureFlags, fsCache, path })));
-    return functions.filter(non_nullable_js_1.nonNullable);
+const findFunctionsInPaths = async function ({ cache, featureFlags, paths }) {
+    const functions = await Promise.all(paths.map((path) => findFunctionInPath({ cache, featureFlags, path })));
+    return functions.filter(nonNullable);
 };
-const findFunctionInPath = async function ({ fsCache, path }) {
-    const runtime = await (0, detect_runtime_js_1.detectBinaryRuntime)({ fsCache, path });
+const findFunctionInPath = async function ({ cache, path }) {
+    const runtime = await detectBinaryRuntime({ path });
     if (runtime === "go" /* RuntimeType.GO */) {
-        return processBinary({ fsCache, path });
+        return processBinary({ cache, path });
     }
-    const goSourceFile = await detectGoFunction({ fsCache, path });
+    const goSourceFile = await detectGoFunction({ cache, path });
     if (goSourceFile) {
-        return processSource({ fsCache, mainFile: goSourceFile, path });
+        return processSource({ cache, mainFile: goSourceFile, path });
     }
 };
-const processBinary = async ({ fsCache, path }) => {
-    const stat = (await (0, fs_js_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));
+const processBinary = async ({ cache, path }) => {
+    const stat = await cachedLstat(cache.lstatCache, path);
+    const extension = extname(path);
+    const filename = basename(path);
+    const name = basename(path, extname(path));
     return {
         extension,
         filename,
         mainFile: path,
         name,
-        srcDir: (0, path_1.dirname)(path),
+        srcDir: dirname(path),
         srcPath: path,
         stat,
     };
 };
-const processSource = async ({ fsCache, mainFile, path, }) => {
+const processSource = async ({ cache, 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 = (await (0, fs_js_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));
+    const stat = (await cachedLstat(cache.lstatCache, path));
+    const filename = basename(path);
+    const extension = extname(mainFile);
+    const name = basename(path, extname(path));
     return {
         extension,
         filename,
-        mainFile: (0, path_1.join)(path, mainFile),
+        mainFile: join(path, mainFile),
         name,
         srcDir: path,
         srcPath: path,
@@ -74,8 +67,8 @@ const processSource = async ({ fsCache, mainFile, path, }) => {
     };
 };
 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';
+    const destPath = join(destFolder, filename);
+    const isSource = extname(mainFile) === '.go';
     let binary = {
         path: srcPath,
         stat,
@@ -83,7 +76,7 @@ const zipFunction = async function ({ config, destFolder, filename, mainFile, sr
     // 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_js_1.build)({ destPath, mainFile, srcDir });
+        const { stat: binaryStat } = await build({ destPath, mainFile, srcDir });
         binary = {
             path: destPath,
             stat: binaryStat,
@@ -95,20 +88,20 @@ const zipFunction = async function ({ config, destFolder, filename, mainFile, sr
         const zipPath = `${destPath}.zip`;
         const zipOptions = {
             destPath: zipPath,
-            filename: (0, path_1.basename)(destPath),
+            filename: basename(destPath),
             runtime,
         };
-        await (0, zip_binary_js_1.zipBinary)({ ...zipOptions, srcPath: binary.path, stat: binary.stat });
+        await 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);
+        await copyFile(binary.path, destPath);
     }
     return { config, path: destPath };
 };
 const runtime = { findFunctionsInPaths, findFunctionInPath, name: "go" /* RuntimeType.GO */, zipFunction };
-exports.default = runtime;
+export default runtime;
 //# sourceMappingURL=index.js.map

package/dist/runtimes/index.d.ts

@@ -1,11 +1,13 @@
 import { Config } from '../config.js';
 import { FeatureFlags } from '../feature_flags.js';
 import { FunctionSource } from '../function.js';
+import type { RuntimeCache } from '../utils/cache.js';
 declare type FunctionMap = Map<string, FunctionSource>;
 /**
  * Gets a list of functions found in a list of paths.
  */
-export declare const getFunctionsFromPaths: (paths: string[], { config, configFileDirectories, dedupe, featureFlags, }?: {
+export declare const getFunctionsFromPaths: (paths: string[], { cache, config, configFileDirectories, dedupe, featureFlags, }: {
+    cache: RuntimeCache;
     config?: Config | undefined;
     configFileDirectories?: string[] | undefined;
     dedupe?: boolean | undefined;
@@ -14,7 +16,8 @@ export declare const getFunctionsFromPaths: (paths: string[], { config, configFi
 /**
  * Gets a list of functions found in a list of paths.
  */
-export declare const getFunctionFromPath: (path: string, { config, featureFlags }?: {
+export declare const getFunctionFromPath: (path: string, { cache, config, featureFlags }: {
+    cache: RuntimeCache;
     config?: Config | undefined;
     featureFlags?: FeatureFlags | undefined;
 }) => Promise<FunctionSource | undefined>;