@netlify/zip-it-and-ship-it 8.0.0 → 8.2.0

package/dist/utils/logger.js

@@ -0,0 +1,15 @@
+const noopLogger = () => {
+    // no-op
+};
+const getLogger = (systemLogger, debug = false) => {
+    // If there is a system logger configured, we'll use that. If there isn't,
+    // we'll pipe system logs to stdout if `debug` is enabled and swallow them
+    // otherwise.
+    const system = systemLogger ?? (debug ? console.log : noopLogger);
+    return {
+        system,
+        user: console.log,
+    };
+};
+export { getLogger };
+//# sourceMappingURL=logger.js.map

package/dist/utils/remove_undefined.js

@@ -1,5 +1,6 @@
-import filterObj from 'filter-obj';
+import { includeKeys } from 'filter-obj';
+const isUndefined = (key, value) => value !== undefined;
 export const removeUndefined = function (obj) {
-    return filterObj(obj, (key, value) => value !== undefined);
+    return includeKeys(obj, isUndefined);
 };
 //# sourceMappingURL=remove_undefined.js.map

package/dist/utils/shell.d.ts

@@ -1,22 +1,4 @@
-/// <reference types="node" resolution-mode="require"/>
-import execa from 'execa';
+import { execa } from 'execa';
 export declare const shellUtils: {
-    runCommand: {
-        (file: string, arguments?: readonly string[] | undefined, options?: execa.Options<string> | undefined): execa.ExecaChildProcess<string>;
-        (file: string, arguments?: readonly string[] | undefined, options?: execa.Options<null> | undefined): execa.ExecaChildProcess<Buffer>;
-        (file: string, options?: execa.Options<string> | undefined): execa.ExecaChildProcess<string>;
-        (file: string, options?: execa.Options<null> | undefined): execa.ExecaChildProcess<Buffer>;
-        sync(file: string, arguments?: readonly string[] | undefined, options?: execa.SyncOptions<string> | undefined): execa.ExecaSyncReturnValue<string>;
-        sync(file: string, arguments?: readonly string[] | undefined, options?: execa.SyncOptions<null> | undefined): execa.ExecaSyncReturnValue<Buffer>;
-        sync(file: string, options?: execa.SyncOptions<string> | undefined): execa.ExecaSyncReturnValue<string>;
-        sync(file: string, options?: execa.SyncOptions<null> | undefined): execa.ExecaSyncReturnValue<Buffer>;
-        command(command: string, options?: execa.Options<string> | undefined): execa.ExecaChildProcess<string>;
-        command(command: string, options?: execa.Options<null> | undefined): execa.ExecaChildProcess<Buffer>;
-        commandSync(command: string, options?: execa.SyncOptions<string> | undefined): execa.ExecaSyncReturnValue<string>;
-        commandSync(command: string, options?: execa.SyncOptions<null> | undefined): execa.ExecaSyncReturnValue<Buffer>;
-        node(scriptPath: string, arguments?: readonly string[] | undefined, options?: execa.NodeOptions<string> | undefined): execa.ExecaChildProcess<string>;
-        node(scriptPath: string, arguments?: readonly string[] | undefined, options?: execa.Options<null> | undefined): execa.ExecaChildProcess<Buffer>;
-        node(scriptPath: string, options?: execa.Options<string> | undefined): execa.ExecaChildProcess<string>;
-        node(scriptPath: string, options?: execa.Options<null> | undefined): execa.ExecaChildProcess<Buffer>;
-    };
+    runCommand: typeof execa;
 };

package/dist/utils/shell.js

@@ -1,3 +1,3 @@
-import execa from 'execa';
+import { execa } from 'execa';
 export const shellUtils = { runCommand: execa };
 //# sourceMappingURL=shell.js.map

package/dist/utils/timer.d.ts

@@ -0,0 +1,2 @@
+export declare const startTimer: () => [number, number];
+export declare const endTimer: ([startSecs, startNsecs]: [number, number]) => number;

package/dist/utils/timer.js

@@ -0,0 +1,12 @@
+import { hrtime } from 'process';
+const NANOSECS_TO_SECS = 1e9;
+export const startTimer = function () {
+    return hrtime();
+};
+// returns the time in nanoseconds
+export const endTimer = function ([startSecs, startNsecs]) {
+    const [endSecs, endNsecs] = hrtime();
+    const durationNs = (endSecs - startSecs) * NANOSECS_TO_SECS + endNsecs - startNsecs;
+    return durationNs;
+};
+//# sourceMappingURL=timer.js.map

package/dist/zip.d.ts

@@ -1,6 +1,7 @@
 import { ArchiveFormat } from './archive.js';
 import { Config } from './config.js';
 import { FeatureFlags } from './feature_flags.js';
+import { LogFunction } from './utils/logger.js';
 interface ZipFunctionOptions {
     archiveFormat?: ArchiveFormat;
     basePath?: string;
@@ -8,15 +9,17 @@ interface ZipFunctionOptions {
     featureFlags?: FeatureFlags;
     repositoryRoot?: string;
     zipGo?: boolean;
+    systemLog?: LogFunction;
+    debug?: boolean;
 }
-export declare type ZipFunctionsOptions = ZipFunctionOptions & {
+export type ZipFunctionsOptions = ZipFunctionOptions & {
     configFileDirectories?: string[];
     manifest?: string;
     parallelLimit?: number;
 };
-export declare const zipFunctions: (relativeSrcFolders: string | string[], destFolder: string, { archiveFormat, basePath, config, configFileDirectories, featureFlags: inputFeatureFlags, manifest, parallelLimit, repositoryRoot, }?: ZipFunctionsOptions) => Promise<(Omit<import("./function.js").FunctionArchive, "runtime"> & {
+export declare const zipFunctions: (relativeSrcFolders: string | string[], destFolder: string, { archiveFormat, basePath, config, configFileDirectories, featureFlags: inputFeatureFlags, manifest, parallelLimit, repositoryRoot, systemLog, debug, }?: ZipFunctionsOptions) => Promise<(Omit<import("./function.js").FunctionArchive, "runtime"> & {
     runtime: import("./main.js").RuntimeType;
     schedule?: string | undefined;
 })[]>;
-export declare const zipFunction: (relativeSrcPath: string, destFolder: string, { archiveFormat, basePath, config: inputConfig, featureFlags: inputFeatureFlags, repositoryRoot, }?: ZipFunctionOptions) => Promise<import("./utils/format_result.js").FunctionResult | undefined>;
+export declare const zipFunction: (relativeSrcPath: string, destFolder: string, { archiveFormat, basePath, config: inputConfig, featureFlags: inputFeatureFlags, repositoryRoot, systemLog, debug, }?: ZipFunctionOptions) => Promise<import("./utils/format_result.js").FunctionResult | undefined>;
 export {};

package/dist/zip.js

@@ -5,9 +5,12 @@ import { getFlags } from './feature_flags.js';
 import { createManifest } from './manifest.js';
 import { getFunctionsFromPaths } from './runtimes/index.js';
 import { addArchiveSize } from './utils/archive_size.js';
+import { RuntimeCache } from './utils/cache.js';
 import { formatZipResult } from './utils/format_result.js';
 import { listFunctionsDirectories, resolveFunctionsDirectories } from './utils/fs.js';
+import { getLogger } from './utils/logger.js';
 import { nonNullable } from './utils/non_nullable.js';
+import { endTimer, startTimer } from './utils/timer.js';
 const DEFAULT_PARALLEL_LIMIT = 5;
 // TODO: now that we have types, do we still need runtime validation?
 const validateArchiveFormat = (archiveFormat) => {
@@ -17,12 +20,20 @@ const validateArchiveFormat = (archiveFormat) => {
 };
 // Zip `srcFolder/*` (Node.js or Go files) to `destFolder/*.zip` so it can be
 // used by AWS Lambda
-export const zipFunctions = async function (relativeSrcFolders, destFolder, { archiveFormat = 'zip', basePath, config = {}, configFileDirectories, featureFlags: inputFeatureFlags, manifest, parallelLimit = DEFAULT_PARALLEL_LIMIT, repositoryRoot = basePath, } = {}) {
+export const zipFunctions = async function (relativeSrcFolders, destFolder, { archiveFormat = 'zip', basePath, config = {}, configFileDirectories, featureFlags: inputFeatureFlags, manifest, parallelLimit = DEFAULT_PARALLEL_LIMIT, repositoryRoot = basePath, systemLog, debug, } = {}) {
     validateArchiveFormat(archiveFormat);
+    const logger = getLogger(systemLog, debug);
+    const cache = new RuntimeCache();
     const featureFlags = getFlags(inputFeatureFlags);
     const srcFolders = resolveFunctionsDirectories(relativeSrcFolders);
     const [paths] = await Promise.all([listFunctionsDirectories(srcFolders), fs.mkdir(destFolder, { recursive: true })]);
-    const functions = await getFunctionsFromPaths(paths, { config, configFileDirectories, dedupe: true, featureFlags });
+    const functions = await getFunctionsFromPaths(paths, {
+        cache,
+        config,
+        configFileDirectories,
+        dedupe: true,
+        featureFlags,
+    });
     const results = await pMap(functions.values(), async (func) => {
         const functionFlags = {
             ...featureFlags,
@@ -30,9 +41,11 @@ export const zipFunctions = async function (relativeSrcFolders, destFolder, { ar
             // extend the feature flags with `zisi_pure_esm_mjs` enabled.
             ...(func.config.nodeModuleFormat === "esm" /* ModuleFormat.ESM */ ? { zisi_pure_esm_mjs: true } : {}),
         };
+        const startIntervalTime = startTimer();
         const zipResult = await func.runtime.zipFunction({
             archiveFormat,
             basePath,
+            cache,
             config: func.config,
             destFolder,
             extension: func.extension,
@@ -46,6 +59,14 @@ export const zipFunctions = async function (relativeSrcFolders, destFolder, { ar
             srcPath: func.srcPath,
             stat: func.stat,
         });
+        const durationNs = endTimer(startIntervalTime);
+        const logObject = {
+            name: func.name,
+            config: func.config,
+            featureFlags: functionFlags,
+            durationNs,
+        };
+        logger.system(`Function details: ${JSON.stringify(logObject, null, 2)}`);
         return { ...zipResult, mainFile: func.mainFile, name: func.name, runtime: func.runtime };
     }, {
         concurrency: parallelLimit,
@@ -59,11 +80,14 @@ export const zipFunctions = async function (relativeSrcFolders, destFolder, { ar
     }
     return formattedResults;
 };
-export const zipFunction = async function (relativeSrcPath, destFolder, { archiveFormat = 'zip', basePath, config: inputConfig = {}, featureFlags: inputFeatureFlags, repositoryRoot = basePath, } = {}) {
+// eslint-disable-next-line max-statements
+export const zipFunction = async function (relativeSrcPath, destFolder, { archiveFormat = 'zip', basePath, config: inputConfig = {}, featureFlags: inputFeatureFlags, repositoryRoot = basePath, systemLog, debug, } = {}) {
     validateArchiveFormat(archiveFormat);
+    const logger = getLogger(systemLog, debug);
     const featureFlags = getFlags(inputFeatureFlags);
     const srcPath = resolve(relativeSrcPath);
-    const functions = await getFunctionsFromPaths([srcPath], { config: inputConfig, dedupe: true, featureFlags });
+    const cache = new RuntimeCache();
+    const functions = await getFunctionsFromPaths([srcPath], { cache, config: inputConfig, dedupe: true, featureFlags });
     if (functions.size === 0) {
         return;
     }
@@ -75,9 +99,11 @@ export const zipFunction = async function (relativeSrcPath, destFolder, { archiv
         // extend the feature flags with `zisi_pure_esm_mjs` enabled.
         ...(config.nodeModuleFormat === "esm" /* ModuleFormat.ESM */ ? { zisi_pure_esm_mjs: true } : {}),
     };
+    const startIntervalTime = startTimer();
     const zipResult = await runtime.zipFunction({
         archiveFormat,
         basePath,
+        cache,
         config,
         destFolder,
         extension,
@@ -91,6 +117,14 @@ export const zipFunction = async function (relativeSrcPath, destFolder, { archiv
         srcPath,
         stat: stats,
     });
+    const durationNs = endTimer(startIntervalTime);
+    const logObject = {
+        name,
+        config,
+        featureFlags: functionFlags,
+        durationNs,
+    };
+    logger.system(`Function details: ${JSON.stringify(logObject, null, 2)}`);
     return formatZipResult({ ...zipResult, mainFile, name, runtime });
 };
 //# sourceMappingURL=zip.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/zip-it-and-ship-it",
-  "version": "8.0.0",
+  "version": "8.2.0",
   "description": "Zip it and ship it",
   "main": "./dist/main.js",
   "type": "module",
@@ -63,21 +63,20 @@
     "del": "^7.0.0",
     "end-of-stream": "^1.4.4",
     "es-module-lexer": "^1.0.0",
-    "execa": "^5.0.0",
-    "filter-obj": "^2.0.1",
-    "find-up": "^5.0.0",
+    "execa": "^6.0.0",
+    "filter-obj": "^5.0.0",
+    "find-up": "^6.0.0",
     "glob": "^8.0.3",
     "is-builtin-module": "^3.1.0",
-    "is-path-inside": "^3.0.3",
-    "junk": "^3.1.0",
-    "locate-path": "^6.0.0",
+    "is-path-inside": "^4.0.0",
+    "junk": "^4.0.0",
+    "locate-path": "^7.0.0",
     "merge-options": "^3.0.4",
     "minimatch": "^5.0.0",
     "normalize-path": "^3.0.0",
-    "p-map": "^4.0.0",
+    "p-map": "^5.0.0",
     "path-exists": "^5.0.0",
     "precinct": "^9.0.1",
-    "read-package-json-fast": "^2.0.2",
     "require-package-name": "^2.0.1",
     "resolve": "^2.0.0-next.1",
     "semver": "^7.0.0",
@@ -88,16 +87,17 @@
   },
   "devDependencies": {
     "@babel/types": "^7.15.6",
-    "@netlify/eslint-config-node": "^7.0.0",
+    "@netlify/eslint-config-node": "^7.0.1",
     "@types/archiver": "^5.1.1",
     "@types/end-of-stream": "^1.4.1",
     "@types/node": "^14.18.32",
     "@types/normalize-path": "^3.0.0",
     "@types/resolve": "^1.20.2",
     "@types/semver": "^7.3.8",
+    "@types/tmp": "^0.2.3",
     "@types/unixify": "^1.0.0",
     "@types/yargs": "^17.0.4",
-    "@vitest/coverage-c8": "^0.24.3",
+    "@vitest/coverage-c8": "^0.25.0",
     "cpy": "^9.0.0",
     "deepmerge": "^4.2.2",
     "get-stream": "^6.0.0",
@@ -107,8 +107,8 @@
     "source-map-support": "^0.5.21",
     "throat": "^6.0.1",
     "typescript": "^4.8.4",
-    "vite": "^3.1.8",
-    "vitest": "^0.24.3"
+    "vite": "^4.0.0",
+    "vitest": "^0.25.0"
   },
   "engines": {
     "node": "^14.16.0 || >=16.0.0"