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

package/dist/archive.js

@@ -28,8 +28,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

package/dist/feature_flags.js

@@ -6,7 +6,6 @@ const FLAGS = {
     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),
-    parseISC: false,
     parseWithEsbuild: false,
     traceWithNft: false,
 };

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

@@ -20,43 +20,68 @@ var __rest = (this && this.__rest) || function (s, e) {
     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 = (func) => __awaiter(void 0, void 0, void 0, function* () {
+    // ISC is currently only supported in JavaScript and TypeScript functions.
+    if (func.runtime.name !== 'js') {
+        return func;
+    }
+    const inSourceConfig = yield (0, in_source_config_1.findISCDeclarationsInPath)(func.mainFile);
+    return Object.assign(Object.assign({}, func), { inSourceConfig });
+});
 // List all Netlify Functions main entry files for a specific directory
-const listFunctions = function (relativeSrcFolders, { featureFlags: inputFeatureFlags } = {}) {
+const listFunctions = function (relativeSrcFolders, { featureFlags: inputFeatureFlags, config, parseISC = false, } = {}) {
     return __awaiter(this, void 0, void 0, function* () {
         const featureFlags = (0, feature_flags_1.getFlags)(inputFeatureFlags);
         const srcFolders = (0, fs_1.resolveFunctionsDirectories)(relativeSrcFolders);
         const paths = yield (0, fs_1.listFunctionsDirectories)(srcFolders);
-        const functions = yield (0, runtimes_1.getFunctionsFromPaths)(paths, { featureFlags });
-        const listedFunctions = [...functions.values()].map(getListedFunction);
-        return listedFunctions;
+        const functionsMap = yield (0, runtimes_1.getFunctionsFromPaths)(paths, { featureFlags, config });
+        const functions = [...functionsMap.values()];
+        const augmentedFunctions = parseISC ? yield Promise.all(functions.map(augmentWithISC)) : functions;
+        return augmentedFunctions.map(getListedFunction);
     });
 };
 exports.listFunctions = listFunctions;
+// Finds a function at a specific path.
+const listFunction = function (path, { featureFlags: inputFeatureFlags, config, parseISC = false, } = {}) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const featureFlags = (0, feature_flags_1.getFlags)(inputFeatureFlags);
+        const func = yield (0, runtimes_1.getFunctionFromPath)(path, { featureFlags, config });
+        if (!func) {
+            return;
+        }
+        const augmentedFunction = parseISC ? yield augmentWithISC(func) : func;
+        return getListedFunction(augmentedFunction);
+    });
+};
+exports.listFunction = listFunction;
 // List all Netlify Functions files for a specific directory
-const listFunctionsFiles = function (relativeSrcFolders, { basePath, config, featureFlags: inputFeatureFlags } = {}) {
+const listFunctionsFiles = function (relativeSrcFolders, { basePath, config, featureFlags: inputFeatureFlags, parseISC = false } = {}) {
     return __awaiter(this, void 0, void 0, function* () {
         const featureFlags = (0, feature_flags_1.getFlags)(inputFeatureFlags);
         const srcFolders = (0, fs_1.resolveFunctionsDirectories)(relativeSrcFolders);
         const paths = yield (0, fs_1.listFunctionsDirectories)(srcFolders);
-        const functions = yield (0, runtimes_1.getFunctionsFromPaths)(paths, { config, featureFlags });
-        const listedFunctionsFiles = yield Promise.all([...functions.values()].map((func) => getListedFunctionFiles(func, { basePath, featureFlags })));
+        const functionsMap = yield (0, runtimes_1.getFunctionsFromPaths)(paths, { config, featureFlags });
+        const functions = [...functionsMap.values()];
+        const augmentedFunctions = parseISC ? yield Promise.all(functions.map(augmentWithISC)) : functions;
+        const listedFunctionsFiles = yield Promise.all(augmentedFunctions.map((func) => getListedFunctionFiles(func, { basePath, featureFlags })));
         return listedFunctionsFiles.flat();
     });
 };
 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) }));
+        return srcFiles.map((srcFile) => (Object.assign(Object.assign({}, getListedFunction(func)), { srcFile, extension: (0, path_1.extname)(srcFile) })));
     });
 };
 const getSrcFiles = function (_a) {

package/dist/runtimes/go/index.js

@@ -35,22 +35,25 @@ const detectGoFunction = ({ fsCache, path }) => __awaiter(void 0, void 0, void 0
 });
 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 });
-            }
-        })));
+        const functions = yield Promise.all(paths.map((path) => findFunctionInPath({ featureFlags, fsCache, path })));
         return functions.filter(non_nullable_1.nonNullable);
     });
 };
+const findFunctionInPath = function ({ featureFlags, fsCache, path }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const runtime = yield (0, detect_runtime_1.detectBinaryRuntime)({ fsCache, path });
+        if (runtime === 'go') {
+            return processBinary({ fsCache, path });
+        }
+        if (featureFlags.buildGoSource !== true) {
+            return;
+        }
+        const goSourceFile = yield detectGoFunction({ fsCache, path });
+        if (goSourceFile) {
+            return processSource({ fsCache, mainFile: goSourceFile, path });
+        }
+    });
+};
 const processBinary = ({ fsCache, path }) => __awaiter(void 0, void 0, void 0, function* () {
     const stat = (yield (0, fs_1.cachedLstat)(fsCache, path));
     const extension = (0, path_1.extname)(path);
@@ -96,6 +99,6 @@ const zipFunction = function ({ config, destFolder, filename, mainFile, srcDir,
         return { config, path: destPath };
     });
 };
-const runtime = { findFunctionsInPaths, name: 'go', zipFunction };
+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 };

package/dist/runtimes/index.js

@@ -12,7 +12,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFunctionsFromPaths = void 0;
+exports.getFunctionFromPath = exports.getFunctionsFromPaths = void 0;
 const path_1 = require("path");
 const config_1 = require("../config");
 const feature_flags_1 = require("../feature_flags");
@@ -42,23 +42,24 @@ const findFunctionsInRuntime = function ({ dedupe = false, featureFlags, fsCache
         return { functions: augmentedFunctions, remainingPaths };
     });
 };
+// An object to cache filesystem operations. This allows different functions
+// to perform IO operations on the same file (i.e. getting its stats or its
+// contents) without duplicating work.
+const makeFsCache = () => ({});
+// The order of this array determines the priority of the runtimes. If a path
+// is used by the first time, it won't be made available to the subsequent
+// runtimes.
+const RUNTIMES = [node_1.default, go_1.default, rust_1.default];
 /**
  * Gets a list of functions found in a list of paths.
  */
 const getFunctionsFromPaths = (paths, { config, dedupe = false, featureFlags = feature_flags_1.defaultFlags, } = {}) => __awaiter(void 0, void 0, void 0, function* () {
-    // An object to cache filesystem operations. This allows different functions
-    // to perform IO operations on the same file (i.e. getting its stats or its
-    // contents) without duplicating work.
-    const fsCache = {};
-    // The order of this array determines the priority of the runtimes. If a path
-    // is used by the first time, it won't be made available to the subsequent
-    // runtimes.
-    const runtimes = [node_1.default, go_1.default, rust_1.default];
+    const fsCache = makeFsCache();
     // We cycle through the ordered array of runtimes, passing each one of them
     // through `findFunctionsInRuntime`. For each iteration, we collect all the
     // functions found plus the list of paths that still need to be evaluated,
     // using them as the input for the next iteration until the last runtime.
-    const { functions } = yield runtimes.reduce((aggregate, runtime) => __awaiter(void 0, void 0, void 0, function* () {
+    const { functions } = yield RUNTIMES.reduce((aggregate, runtime) => __awaiter(void 0, void 0, void 0, function* () {
         const { functions: aggregateFunctions, remainingPaths: aggregatePaths } = yield aggregate;
         const { functions: runtimeFunctions, remainingPaths: runtimePaths } = yield findFunctionsInRuntime({
             dedupe,
@@ -79,4 +80,19 @@ const getFunctionsFromPaths = (paths, { config, dedupe = false, featureFlags = f
     return new Map(functionsWithConfig);
 });
 exports.getFunctionsFromPaths = getFunctionsFromPaths;
+/**
+ * Gets a list of functions found in a list of paths.
+ */
+const getFunctionFromPath = (path, { config, featureFlags = feature_flags_1.defaultFlags } = {}) => __awaiter(void 0, void 0, void 0, function* () {
+    const fsCache = makeFsCache();
+    for (const runtime of RUNTIMES) {
+        // eslint-disable-next-line no-await-in-loop
+        const func = yield runtime.findFunctionInPath({ path, fsCache, featureFlags });
+        if (func) {
+            return Object.assign(Object.assign({}, func), { runtime, config: (0, config_1.getConfigForFunction)({ config, func: Object.assign(Object.assign({}, func), { runtime }) }) });
+        }
+    }
+    return undefined;
+});
+exports.getFunctionFromPath = getFunctionFromPath;
 //# sourceMappingURL=index.js.map

package/dist/runtimes/node/finder.d.ts

@@ -1,6 +1,4 @@
-import { SourceFile } from '../../function';
-declare const findFunctionsInPaths: ({ paths }: {
-    paths: string[];
-}) => Promise<SourceFile[]>;
-declare const getFunctionAtPath: (srcPath: string) => Promise<SourceFile | undefined>;
-export { findFunctionsInPaths, getFunctionAtPath };
+import { FindFunctionsInPathsFunction, FindFunctionInPathFunction } from '../runtime';
+declare const findFunctionsInPaths: FindFunctionsInPathsFunction;
+declare const findFunctionInPath: FindFunctionInPathFunction;
+export { findFunctionsInPaths, findFunctionInPath };

package/dist/runtimes/node/finder.js

@@ -12,7 +12,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFunctionAtPath = exports.findFunctionsInPaths = void 0;
+exports.findFunctionInPath = exports.findFunctionsInPaths = void 0;
 const fs_1 = require("fs");
 const path_1 = require("path");
 const util_1 = require("util");
@@ -30,9 +30,9 @@ const sortByExtension = (fA, fB) => {
     const indexB = allowedExtensions.indexOf(fB.extension);
     return indexB - indexA;
 };
-const findFunctionsInPaths = function ({ paths }) {
+const findFunctionsInPaths = function ({ paths, fsCache, featureFlags }) {
     return __awaiter(this, void 0, void 0, function* () {
-        const functions = yield Promise.all(paths.map(getFunctionAtPath));
+        const functions = yield Promise.all(paths.map((path) => findFunctionInPath({ path, fsCache, featureFlags })));
         // It's fine to mutate the array since its scope is local to this function.
         const sortedFunctions = functions.filter(non_nullable_1.nonNullable).sort((fA, fB) => {
             // We first sort the functions array to put directories first. This is so
@@ -52,7 +52,7 @@ const findFunctionsInPaths = function ({ paths }) {
     });
 };
 exports.findFunctionsInPaths = findFunctionsInPaths;
-const getFunctionAtPath = function (srcPath) {
+const findFunctionInPath = function ({ path: srcPath }) {
     return __awaiter(this, void 0, void 0, function* () {
         const filename = (0, path_1.basename)(srcPath);
         if (filename === 'node_modules') {
@@ -69,7 +69,7 @@ const getFunctionAtPath = function (srcPath) {
         return { extension, filename, mainFile, name, srcDir, srcPath, stat };
     });
 };
-exports.getFunctionAtPath = getFunctionAtPath;
+exports.findFunctionInPath = findFunctionInPath;
 // Each `srcPath` can also be a directory with an `index` file or a file using
 // the same filename as its directory.
 const getMainFile = function (srcPath, filename, stat) {

package/dist/runtimes/node/index.js

@@ -89,10 +89,7 @@ const zipFunction = function ({ archiveFormat, basePath, config = {}, destFolder
             srcPath,
             stat,
         });
-        let inSourceConfig = {};
-        if (featureFlags.parseISC) {
-            inSourceConfig = yield (0, in_source_config_1.findISCDeclarationsInPath)(mainFile);
-        }
+        const inSourceConfig = yield (0, in_source_config_1.findISCDeclarationsInPath)(mainFile);
         (0, plugin_modules_path_1.createAliases)(srcFiles, pluginsModulesPath, aliases, finalBasePath);
         const zipPath = yield (0, zip_1.zipNodeJs)({
             aliases,
@@ -141,6 +138,7 @@ const zipWithFunctionWithFallback = (_a) => __awaiter(void 0, void 0, void 0, fu
 });
 const runtime = {
     findFunctionsInPaths: finder_1.findFunctionsInPaths,
+    findFunctionInPath: finder_1.findFunctionInPath,
     getSrcFiles: getSrcFilesWithBundler,
     name: 'js',
     zipFunction: zipWithFunctionWithFallback,

package/dist/runtimes/node/parser/exports.js

@@ -23,11 +23,16 @@ const getMainExport = (nodes) => {
 exports.getMainExport = getMainExport;
 // Finds the main handler export in a CJS AST.
 const getMainExportFromCJS = (node) => {
-    const handlerPath = ['module', 'exports', 'handler'];
-    if (!(0, helpers_1.isModuleExports)(node, handlerPath) || node.expression.right.type !== 'CallExpression') {
-        return [];
-    }
-    return getExportsFromCallExpression(node.expression.right);
+    const handlerPaths = [
+        ['module', 'exports', 'handler'],
+        ['exports', 'handler'],
+    ];
+    return handlerPaths.flatMap((handlerPath) => {
+        if (!(0, helpers_1.isModuleExports)(node, handlerPath) || node.expression.right.type !== 'CallExpression') {
+            return [];
+        }
+        return getExportsFromCallExpression(node.expression.right);
+    });
 };
 // Finds the main handler export in an ESM AST.
 // eslint-disable-next-line complexity

package/dist/runtimes/node/utils/zip.js

@@ -37,7 +37,7 @@ const p_map_1 = __importDefault(require("p-map"));
 const unixify_1 = __importDefault(require("unixify"));
 const archive_1 = require("../../../archive");
 const fs_2 = require("../../../utils/fs");
-const pStat = (0, util_1.promisify)(fs_1.default.stat);
+const pLstat = (0, util_1.promisify)(fs_1.default.lstat);
 const pWriteFile = (0, util_1.promisify)(fs_1.default.writeFile);
 // Taken from https://www.npmjs.com/package/cpy.
 const COPY_FILE_CONCURRENCY = os_1.default.cpus().length === 0 ? 2 : os_1.default.cpus().length * 2;
@@ -127,7 +127,7 @@ const addEntryFileToZip = function (archive, { contents, filename }) {
 };
 const addStat = function (srcFile) {
     return __awaiter(this, void 0, void 0, function* () {
-        const stat = yield pStat(srcFile);
+        const stat = yield pLstat(srcFile);
         return { srcFile, stat };
     });
 };

package/dist/runtimes/runtime.d.ts

@@ -11,6 +11,11 @@ declare type FindFunctionsInPathsFunction = (args: {
     fsCache: FsCache;
     paths: string[];
 }) => Promise<SourceFile[]>;
+declare type FindFunctionInPathFunction = (args: {
+    featureFlags: FeatureFlags;
+    fsCache: FsCache;
+    path: string;
+}) => Promise<SourceFile | undefined>;
 declare type GetSrcFilesFunction = (args: {
     basePath?: string;
     config: FunctionConfig;
@@ -38,8 +43,9 @@ declare type ZipFunction = (args: {
 } & FunctionSource) => Promise<ZipFunctionResult>;
 interface Runtime {
     findFunctionsInPaths: FindFunctionsInPathsFunction;
+    findFunctionInPath: FindFunctionInPathFunction;
     getSrcFiles?: GetSrcFilesFunction;
     name: RuntimeName;
     zipFunction: ZipFunction;
 }
-export { FindFunctionsInPathsFunction, GetSrcFilesFunction, Runtime, RuntimeName, ZipFunction, ZipFunctionResult };
+export { FindFunctionInPathFunction, FindFunctionsInPathsFunction, GetSrcFilesFunction, Runtime, RuntimeName, ZipFunction, ZipFunctionResult, };

package/dist/runtimes/rust/index.js

@@ -41,22 +41,25 @@ const detectRustFunction = ({ fsCache, path }) => __awaiter(void 0, void 0, void
 });
 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 });
-            }
-        })));
+        const functions = yield Promise.all(paths.map((path) => findFunctionInPath({ path, featureFlags, fsCache })));
         return functions.filter(non_nullable_1.nonNullable);
     });
 };
+const findFunctionInPath = function ({ path, featureFlags, fsCache }) {
+    return __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 });
+        }
+    });
+};
 const processBinary = ({ fsCache, path }) => __awaiter(void 0, void 0, void 0, function* () {
     const stat = (yield (0, fs_1.cachedLstat)(fsCache, path));
     const filename = (0, path_1.basename)(path);
@@ -116,6 +119,6 @@ const zipFunction = function ({ config, destFolder, filename, mainFile, runtime,
         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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/zip-it-and-ship-it",
-  "version": "5.2.0",
+  "version": "5.4.0",
   "description": "Zip it and ship it",
   "main": "./dist/main.js",
   "bin": {
@@ -93,14 +93,13 @@
   },
   "devDependencies": {
     "@babel/types": "^7.15.6",
-    "@netlify/eslint-config-node": "^3.3.10",
+    "@netlify/eslint-config-node": "^4.0.2",
     "@types/archiver": "^5.1.1",
     "@types/end-of-stream": "^1.4.1",
     "@types/resolve": "^1.20.1",
     "@types/semver": "^7.3.8",
     "@types/unixify": "^1.0.0",
     "@types/yargs": "^17.0.4",
-    "adm-zip": "0.5.5",
     "ava": "^3.0.0",
     "cpy": "^8.0.0",
     "deepmerge": "^4.2.2",