@netlify/zip-it-and-ship-it 4.26.0 → 4.28.1

package/dist/archive.d.ts

@@ -2,12 +2,13 @@ import { Buffer } from 'buffer';
 import { Stats } from 'fs';
 import { Writable } from 'stream';
 import { Archiver } from 'archiver';
+declare type ArchiveFormat = 'none' | 'zip';
 declare const startZip: (destPath: string) => {
     archive: Archiver;
     output: Writable;
 };
 declare const addZipFile: (archive: Archiver, file: string, name: string, stat: Stats) => void;
-declare const addZipContent: (archive: Archiver, content: Buffer, name: string) => void;
+declare const addZipContent: (archive: Archiver, content: Buffer | string, name: string) => void;
 declare const endZip: (archive: Archiver, output: Writable) => Promise<void>;
 export { startZip, addZipFile, addZipContent, endZip };
-export type { Archiver as ZipArchive };
+export type { ArchiveFormat, Archiver as ZipArchive };

package/dist/bin.js

@@ -20,32 +20,45 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-const { exit } = require('process');
-const yargs = require('yargs');
-const zipIt = require('./main');
-const { ARCHIVE_FORMAT_NONE, ARCHIVE_FORMAT_ZIP } = require('./utils/consts');
+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 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 {
-            const zipped = yield zipIt.zipFunctions(srcFolder, destFolder, options);
+            // @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());
-            exit(1);
+            (0, process_1.exit)(1);
         }
     });
 };
 const parseArgs = function () {
-    return yargs.command('* <srcFolder> <destFolder>').options(OPTIONS).usage(USAGE).strict().parse();
+    return yargs_1.default
+        .command('* <srcFolder> <destFolder>', 'Create ZIP archives from a directory')
+        .options(OPTIONS)
+        .usage(USAGE)
+        .strict()
+        .parse();
 };
+const archiveFormats = ['none', 'zip'];
+const defaultArchiveFormat = 'zip';
 const OPTIONS = {
     'archive-format': {
         string: true,
-        choices: [ARCHIVE_FORMAT_NONE, ARCHIVE_FORMAT_ZIP],
-        default: ARCHIVE_FORMAT_ZIP,
+        choices: archiveFormats,
+        default: defaultArchiveFormat,
         describe: 'Format of the archive created for each function',
     },
     config: {

package/dist/config.d.ts

@@ -1,4 +1,24 @@
-export function getConfigForFunction({ config, func }: {
-    config: any;
-    func: any;
-}): any;
+import { FunctionSource } from './function';
+import type { NodeBundlerName } from './runtimes/node';
+declare type SupportedVersionNumbers = 8 | 10 | 12 | 14;
+declare type NodeVersion = `${SupportedVersionNumbers}.x` | `nodejs${SupportedVersionNumbers}.x`;
+interface FunctionConfig {
+    externalNodeModules?: string[];
+    includedFiles?: string[];
+    includedFilesBasePath?: string;
+    ignoredNodeModules?: string[];
+    nodeBundler?: NodeBundlerName;
+    nodeSourcemap?: boolean;
+    nodeVersion?: NodeVersion;
+    processDynamicNodeImports?: boolean;
+    rustTargetDirectory?: string;
+    schedule?: string;
+}
+declare type GlobPattern = string;
+declare type Config = Record<GlobPattern, FunctionConfig>;
+declare const getConfigForFunction: ({ config, func, }: {
+    config?: Config | undefined;
+    func: Omit<FunctionSource, 'config'>;
+}) => FunctionConfig;
+export { getConfigForFunction };
+export type { Config, FunctionConfig };

package/dist/config.js

@@ -1,13 +1,18 @@
 "use strict";
-const mergeOptions = require('merge-options');
-const minimatch = require('minimatch');
-const getConfigForFunction = ({ config, func }) => {
+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 merge_options_1 = __importDefault(require("merge-options"));
+const minimatch_1 = __importDefault(require("minimatch"));
+const getConfigForFunction = ({ 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) => minimatch(func.name, expression))
+        .filter((expression) => (0, minimatch_1.default)(func.name, expression))
         .map((expression) => {
         const wildcardCount = [...expression].filter((char) => char === '*').length;
         // The weight increases with the number of hardcoded (i.e. non-wildcard)
@@ -22,7 +27,7 @@ const getConfigForFunction = ({ config, func }) => {
     })
         .sort(({ weight: weightA }, { weight: weightB }) => weightA - weightB)
         .map(({ expression }) => config[expression]);
-    return mergeOptions.apply({ concatArrays: true, ignoreUndefined: true }, matches);
+    return merge_options_1.default.apply({ concatArrays: true, ignoreUndefined: true }, matches);
 };
-module.exports = { getConfigForFunction };
+exports.getConfigForFunction = getConfigForFunction;
 //# sourceMappingURL=config.js.map

package/dist/feature_flags.d.ts

@@ -1,12 +1,6 @@
-export namespace FLAGS {
-    const buildGoSource: boolean;
-    const buildRustSource: boolean;
-    const defaultEsModulesToEsbuild: boolean;
-    const parseWithEsbuild: boolean;
-}
-export function getFlags(input?: {}, flags?: {
-    buildGoSource: boolean;
-    buildRustSource: boolean;
-    defaultEsModulesToEsbuild: boolean;
-    parseWithEsbuild: boolean;
-}): {};
+declare const FLAGS: Record<string, boolean>;
+declare type FeatureFlag = keyof typeof FLAGS;
+declare type FeatureFlags = Record<FeatureFlag, boolean>;
+declare const getFlags: (input?: Record<string, boolean>, flags?: Record<string, boolean>) => {};
+export { FLAGS as defaultFlags, getFlags };
+export type { FeatureFlag, FeatureFlags };

package/dist/feature_flags.js

@@ -1,12 +1,16 @@
 "use strict";
-const { env } = require('process');
-// List of supported flags and their default value.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFlags = exports.defaultFlags = void 0;
+const process_1 = require("process");
 const FLAGS = {
-    buildGoSource: Boolean(env.NETLIFY_EXPERIMENTAL_BUILD_GO_SOURCE),
-    buildRustSource: Boolean(env.NETLIFY_EXPERIMENTAL_BUILD_RUST_SOURCE),
-    defaultEsModulesToEsbuild: Boolean(env.NETLIFY_EXPERIMENTAL_DEFAULT_ES_MODULES_TO_ESBUILD),
+    buildGoSource: Boolean(process_1.env.NETLIFY_EXPERIMENTAL_BUILD_GO_SOURCE),
+    buildRustSource: Boolean(process_1.env.NETLIFY_EXPERIMENTAL_BUILD_RUST_SOURCE),
+    defaultEsModulesToEsbuild: Boolean(process_1.env.NETLIFY_EXPERIMENTAL_DEFAULT_ES_MODULES_TO_ESBUILD),
     parseWithEsbuild: false,
+    traceWithNft: false,
 };
+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] })), {});
-module.exports = { FLAGS, getFlags };
+exports.getFlags = getFlags;
 //# sourceMappingURL=feature_flags.js.map

package/dist/function.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+import { Stats } from 'fs';
+import type { FunctionConfig } from './config';
+import type { Runtime, ZipFunctionResult } from './runtimes/runtime';
+declare type FunctionArchive = ZipFunctionResult & {
+    mainFile: string;
+    name: string;
+    runtime: Runtime;
+    size?: number;
+};
+interface SourceFile {
+    extension: string;
+    filename: string;
+    mainFile: string;
+    name: string;
+    srcDir: string;
+    srcPath: string;
+    stat: Stats;
+}
+declare type FunctionSource = SourceFile & {
+    config: FunctionConfig;
+    runtime: Runtime;
+};
+export { FunctionArchive, FunctionSource, SourceFile };

package/dist/function.js

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

package/dist/main.d.ts

@@ -1,16 +1,25 @@
-import { zipFunctions } from "./zip";
-import { zipFunction } from "./zip";
-export function listFunctions(relativeSrcFolders: any, { featureFlags: inputFeatureFlags }?: {
-    featureFlags: any;
-}): Promise<{
-    name: any;
-    mainFile: any;
-    runtime: any;
-    extension: any;
-}[]>;
-export function listFunctionsFiles(relativeSrcFolders: any, { basePath, config, featureFlags: inputFeatureFlags }?: {
-    basePath: any;
-    config: any;
-    featureFlags: any;
-}): Promise<never[]>;
-export { zipFunctions, zipFunction };
+import './utils/polyfills';
+import { Config } from './config';
+import { FeatureFlags } from './feature_flags';
+import { RuntimeName } from './runtimes/runtime';
+import { zipFunction, zipFunctions } from './zip';
+interface ListedFunction {
+    name: string;
+    mainFile: string;
+    runtime: RuntimeName;
+    extension: string;
+}
+declare type ListedFunctionFile = ListedFunction & {
+    srcFile: string;
+};
+interface ListFunctionsOptions {
+    basePath?: string;
+    config?: Config;
+    featureFlags?: FeatureFlags;
+    pluginsModulesPath?: string;
+}
+declare const listFunctions: (relativeSrcFolders: string | string[], { featureFlags: inputFeatureFlags }?: {
+    featureFlags?: FeatureFlags;
+}) => Promise<ListedFunction[]>;
+declare const listFunctionsFiles: (relativeSrcFolders: string | string[], { basePath, config, featureFlags: inputFeatureFlags }?: ListFunctionsOptions) => Promise<ListedFunctionFile[]>;
+export { zipFunctions, zipFunction, listFunctions, listFunctionsFiles };

package/dist/main.js

@@ -8,77 +8,75 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-const { extname } = require('path');
-require('./utils/polyfills');
-const { getFlags } = require('./feature_flags');
-const { getFunctionsFromPaths } = require('./runtimes');
-const { getPluginsModulesPath } = require('./runtimes/node/utils/plugin_modules_path');
-const { listFunctionsDirectories, resolveFunctionsDirectories } = require('./utils/fs');
-const { zipFunction, zipFunctions } = require('./zip');
+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.listFunctionsFiles = exports.listFunctions = exports.zipFunction = exports.zipFunctions = void 0;
+const path_1 = require("path");
+require("./utils/polyfills");
+const feature_flags_1 = require("./feature_flags");
+const runtimes_1 = require("./runtimes");
+const plugin_modules_path_1 = require("./runtimes/node/utils/plugin_modules_path");
+const fs_1 = require("./utils/fs");
+const zip_1 = require("./zip");
+Object.defineProperty(exports, "zipFunction", { enumerable: true, get: function () { return zip_1.zipFunction; } });
+Object.defineProperty(exports, "zipFunctions", { enumerable: true, get: function () { return zip_1.zipFunctions; } });
 // 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 = getFlags(inputFeatureFlags);
-        const srcFolders = resolveFunctionsDirectories(relativeSrcFolders);
-        const paths = yield listFunctionsDirectories(srcFolders);
-        const functions = yield getFunctionsFromPaths(paths, { featureFlags });
+        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;
     });
 };
+exports.listFunctions = listFunctions;
 // 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 = getFlags(inputFeatureFlags);
-        const srcFolders = resolveFunctionsDirectories(relativeSrcFolders);
-        const paths = yield listFunctionsDirectories(srcFolders);
+        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, pluginsModulesPath] = yield Promise.all([
-            getFunctionsFromPaths(paths, { config, featureFlags }),
-            getPluginsModulesPath(srcFolders[0]),
+            (0, runtimes_1.getFunctionsFromPaths)(paths, { config, featureFlags }),
+            (0, plugin_modules_path_1.getPluginsModulesPath)(srcFolders[0]),
         ]);
         const listedFunctionsFiles = yield Promise.all([...functions.values()].map((func) => getListedFunctionFiles(func, { basePath, featureFlags, pluginsModulesPath })));
-        // TODO: switch to Array.flat() once we drop support for Node.js < 11.0.0
-        // eslint-disable-next-line unicorn/prefer-spread
-        return [].concat(...listedFunctionsFiles);
+        return listedFunctionsFiles.flat();
     });
 };
+exports.listFunctionsFiles = listFunctionsFiles;
 const getListedFunction = function ({ runtime, name, mainFile, extension }) {
     return { name, mainFile, runtime: runtime.name, extension };
 };
-const getListedFunctionFiles = function ({ config, runtime, name, stat, mainFile, extension, srcPath, srcDir }, { basePath, featureFlags, pluginsModulesPath }) {
+const getListedFunctionFiles = function (func, options) {
     return __awaiter(this, void 0, void 0, function* () {
-        const srcFiles = yield getSrcFiles({
-            basePath,
-            featureFlags,
-            runtime,
-            stat,
-            mainFile,
-            extension,
-            srcPath,
-            srcDir,
-            pluginsModulesPath,
-            config,
-        });
-        return srcFiles.map((srcFile) => ({ srcFile, name, mainFile, runtime: runtime.name, extension: extname(srcFile) }));
+        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 getSrcFiles = function ({ basePath, bundler, config, featureFlags, runtime, stat, mainFile, extension, srcPath, srcDir, pluginsModulesPath, }) {
-    const { getSrcFiles: getRuntimeSrcFiles } = runtime;
-    if (extension === '.zip' || typeof getRuntimeSrcFiles !== 'function') {
-        return [srcPath];
-    }
-    return getRuntimeSrcFiles({
-        basePath,
-        bundler,
-        config,
-        extension,
-        featureFlags,
-        srcPath,
-        mainFile,
-        srcDir,
-        stat,
-        pluginsModulesPath,
+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));
     });
 };
-module.exports = { zipFunctions, zipFunction, listFunctions, listFunctionsFiles };
 //# sourceMappingURL=main.js.map

package/dist/manifest.d.ts

@@ -1,4 +1,23 @@
-export function createManifest({ functions, path }: {
-    functions: any;
-    path: any;
-}): Promise<void>;
+import { FunctionResult } from './utils/format_result';
+interface ManifestFunction {
+    mainFile: string;
+    name: string;
+    path: string;
+    runtime: string;
+    schedule?: string;
+}
+interface Manifest {
+    functions: ManifestFunction[];
+    system: {
+        arch: string;
+        platform: string;
+    };
+    timestamp: number;
+    version: number;
+}
+declare const createManifest: ({ functions, path }: {
+    functions: FunctionResult[];
+    path: string;
+}) => Promise<void>;
+export { createManifest };
+export type { Manifest };

package/dist/manifest.js

@@ -8,20 +8,28 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-const { resolve } = require('path');
-const { arch, platform } = require('process');
-const { writeFile } = require('./utils/fs');
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createManifest = void 0;
+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 formattedFunctions = functions.map(formatFunction);
+    const formattedFunctions = functions.map(formatFunctionForManifest);
     const payload = {
         functions: formattedFunctions,
-        system: { arch, platform },
+        system: { arch: process_1.arch, platform: process_1.platform },
         timestamp: Date.now(),
         version: MANIFEST_VERSION,
     };
-    yield writeFile(path, JSON.stringify(payload));
+    yield (0, fs_1.writeFile)(path, JSON.stringify(payload));
+});
+exports.createManifest = createManifest;
+const formatFunctionForManifest = ({ config, mainFile, name, path, runtime }) => ({
+    mainFile,
+    name,
+    path: (0, path_1.resolve)(path),
+    runtime,
+    schedule: config.schedule,
 });
-const formatFunction = ({ mainFile, name, path, runtime }) => ({ mainFile, name, path: resolve(path), runtime });
-module.exports = { createManifest };
 //# sourceMappingURL=manifest.js.map

package/dist/runtimes/detect_runtime.d.ts

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

package/dist/runtimes/detect_runtime.js

@@ -8,22 +8,30 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-const { detect, Runtime } = require('elf-cam');
-const { RUNTIME_GO, RUNTIME_RUST } = require('../utils/consts');
-const { cachedReadFile } = require('../utils/fs');
+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 }) {
+const detectBinaryRuntime = function ({ fsCache, path, }) {
     return __awaiter(this, void 0, void 0, function* () {
         try {
-            const buffer = yield cachedReadFile(fsCache, path);
-            return RUNTIMES[detect(buffer)];
+            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;
+            }
         }
         catch (error) { }
     });
 };
-const RUNTIMES = {
-    [Runtime.Go]: RUNTIME_GO,
-    [Runtime.Rust]: RUNTIME_RUST,
-};
-module.exports = { detectBinaryRuntime };
+exports.detectBinaryRuntime = detectBinaryRuntime;
 //# sourceMappingURL=detect_runtime.js.map

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

@@ -1,12 +1,13 @@
 /// <reference types="node" />
-export function build({ destPath, mainFile, srcDir }: {
-    destPath: any;
-    mainFile: any;
-    srcDir: any;
-}): Promise<{
-    mainFile: any;
+declare const build: ({ destPath, mainFile, srcDir }: {
+    destPath: string;
+    mainFile: string;
+    srcDir: string;
+}) => Promise<{
+    mainFile: string;
     name: string;
-    srcDir: any;
-    srcPath: any;
+    srcDir: string;
+    srcPath: string;
     stat: import("fs").Stats;
 }>;
+export { build };

package/dist/runtimes/go/builder.js

@@ -8,14 +8,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-const { basename } = require('path');
-const { RUNTIME_GO } = require('../../utils/consts');
-const { lstat } = require('../../utils/fs');
-const { runCommand } = require('../../utils/shell');
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.build = void 0;
+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 functionName = basename(srcDir);
+    const functionName = (0, path_1.basename)(srcDir);
     try {
-        yield runCommand('go', ['build', '-o', destPath, '-ldflags', '-s -w'], {
+        yield (0, shell_1.runCommand)('go', ['build', '-o', destPath, '-ldflags', '-s -w'], {
             cwd: srcDir,
             env: {
                 CGO_ENABLED: '0',
@@ -24,11 +25,12 @@ const build = ({ destPath, mainFile, srcDir }) => __awaiter(void 0, void 0, void
         });
     }
     catch (error) {
-        error.customErrorInfo = { type: 'functionsBundling', location: { functionName, runtime: RUNTIME_GO } };
+        const runtime = 'go';
+        error.customErrorInfo = { type: 'functionsBundling', location: { functionName, runtime } };
         console.error(`Could not compile Go function ${functionName}:\n`);
         throw error;
     }
-    const stat = yield lstat(destPath);
+    const stat = yield (0, fs_1.lstat)(destPath);
     return {
         mainFile,
         name: functionName,
@@ -37,5 +39,5 @@ const build = ({ destPath, mainFile, srcDir }) => __awaiter(void 0, void 0, void
         stat,
     };
 });
-module.exports = { build };
+exports.build = build;
 //# sourceMappingURL=builder.js.map

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

@@ -1,18 +1,3 @@
-export function findFunctionsInPaths({ featureFlags, fsCache, paths }: {
-    featureFlags: any;
-    fsCache: any;
-    paths: any;
-}): Promise<any[]>;
-import { RUNTIME_GO } from "../../utils/consts";
-export function zipFunction({ config, destFolder, filename, mainFile, srcDir, srcPath }: {
-    config: any;
-    destFolder: any;
-    filename: any;
-    mainFile: any;
-    srcDir: any;
-    srcPath: any;
-}): Promise<{
-    config: any;
-    path: string;
-}>;
-export { RUNTIME_GO as name };
+import { Runtime } from '../runtime';
+declare const runtime: Runtime;
+export default runtime;