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

package/dist/feature_flags.js

@@ -14,12 +14,8 @@ export const 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,
+    // Output CJS file extension
+    zisi_output_cjs_extension: false,
 };
 // List of supported flags and their default value.
 export const getFlags = (input = {}, flags = defaultFlags) => Object.entries(flags).reduce((result, [key, defaultValue]) => ({

package/dist/runtimes/node/bundlers/esbuild/bundler.d.ts

@@ -1,6 +1,6 @@
 import type { FunctionConfig } from '../../../../config.js';
 import { FeatureFlags } from '../../../../feature_flags.js';
-import { ModuleFileExtension, ModuleFormat } from '../../utils/module_format.js';
+import { ModuleFormat } from '../../utils/module_format.js';
 export declare const ESBUILD_LOG_LIMIT = 10;
 export declare const bundleJsFile: ({ additionalModulePaths, basePath, config, externalModules, featureFlags, ignoredModules, mainFile, name, srcDir, srcFile, }: {
     additionalModulePaths?: string[] | undefined;
@@ -17,10 +17,10 @@ export declare const bundleJsFile: ({ additionalModulePaths, basePath, config, e
     additionalPaths: string[];
     bundlePaths: Map<string, string>;
     cleanTempFiles: () => Promise<void>;
-    extension: ModuleFileExtension;
     inputs: string[];
     moduleFormat: ModuleFormat;
     nativeNodeModules: {};
     nodeModulesWithDynamicImports: string[];
+    outputExtension: import("../../utils/module_format.js").ModuleFileExtension;
     warnings: import("@netlify/esbuild").Message[];
 }>;

package/dist/runtimes/node/bundlers/esbuild/bundler.js

@@ -56,9 +56,7 @@ export const bundleJsFile = async function ({ additionalModulePaths, basePath, c
     // to a `package.json` with {"type": "module"} in case of an ESM function.
     const { includedFiles: includedFilesFromModuleDetection, moduleFormat } = await getModuleFormat(srcDir, featureFlags, extname(mainFile), config.nodeVersion);
     // The extension of the output file.
-    const extension = getFileExtensionForFormat(moduleFormat, featureFlags);
-    // When outputting an ESM file, configure esbuild to produce a `.mjs` file.
-    const outExtension = moduleFormat === "esm" /* ModuleFormat.ESM */ ? { [".js" /* ModuleFileExtension.JS */]: ".mjs" /* ModuleFileExtension.MJS */ } : undefined;
+    const outputExtension = getFileExtensionForFormat(moduleFormat, featureFlags);
     // We add this banner so that calls to require() still work in ESM modules, especially when importing node built-ins
     // We have to do this until this is fixed in esbuild: https://github.com/evanw/esbuild/pull/2067
     const esmJSBanner = `
@@ -71,7 +69,7 @@ export const bundleJsFile = async function ({ additionalModulePaths, basePath, c
   `;
     try {
         const { metafile = { inputs: {}, outputs: {} }, warnings } = await build({
-            banner: moduleFormat === "esm" /* ModuleFormat.ESM */ && featureFlags.zisi_esbuild_require_banner ? { js: esmJSBanner } : undefined,
+            banner: moduleFormat === "esm" /* ModuleFormat.ESM */ ? { js: esmJSBanner } : undefined,
             bundle: true,
             entryPoints: [srcFile],
             external,
@@ -80,8 +78,8 @@ export const bundleJsFile = async function ({ additionalModulePaths, basePath, c
             logLimit: ESBUILD_LOG_LIMIT,
             metafile: true,
             nodePaths: additionalModulePaths,
-            outExtension,
             outdir: targetDirectory,
+            outExtension: { '.js': outputExtension },
             platform: 'node',
             plugins,
             resolveExtensions: RESOLVE_EXTENSIONS,
@@ -91,9 +89,9 @@ export const bundleJsFile = async function ({ additionalModulePaths, basePath, c
         });
         const bundlePaths = getBundlePaths({
             destFolder: targetDirectory,
-            extension,
             outputs: metafile.outputs,
             srcFile,
+            outputExtension,
         });
         const inputs = Object.keys(metafile.inputs).map((path) => resolve(path));
         const cleanTempFiles = getCleanupFunction([...bundlePaths.keys()]);
@@ -102,11 +100,11 @@ export const bundleJsFile = async function ({ additionalModulePaths, basePath, c
             additionalPaths,
             bundlePaths,
             cleanTempFiles,
-            extension,
             inputs,
             moduleFormat,
             nativeNodeModules,
             nodeModulesWithDynamicImports: [...nodeModulesWithDynamicImports],
+            outputExtension,
             warnings,
         };
     }
@@ -122,7 +120,7 @@ export const bundleJsFile = async function ({ additionalModulePaths, basePath, c
 // absolute paths of the generated files as keys, and the paths that those
 // files should take in the generated bundle as values. This is compatible
 // with the `aliases` format used upstream.
-const getBundlePaths = ({ destFolder, extension: outputExtension, outputs, srcFile, }) => {
+const getBundlePaths = ({ destFolder, outputExtension, outputs, srcFile, }) => {
     const bundleFilename = basename(srcFile, extname(srcFile)) + outputExtension;
     const mainFileDirectory = dirname(srcFile);
     const bundlePaths = new Map();

package/dist/runtimes/node/bundlers/esbuild/bundler_target.d.ts

@@ -9,7 +9,7 @@ declare const versionMap: {
     readonly '16.x': "node16";
     readonly '18.x': "node18";
 };
-type VersionValues = typeof versionMap[keyof typeof versionMap];
+type VersionValues = (typeof versionMap)[keyof typeof versionMap];
 declare const getBundlerTarget: (suppliedVersion?: NodeVersionString) => VersionValues;
 declare const getModuleFormat: (srcDir: string, featureFlags: FeatureFlags, extension: string, configVersion?: string) => Promise<{
     includedFiles: string[];

package/dist/runtimes/node/bundlers/esbuild/index.js

@@ -28,7 +28,7 @@ const getExternalAndIgnoredModules = async ({ config, srcDir }) => {
 };
 const bundle = async ({ basePath, config = {}, extension, featureFlags, filename, mainFile, name, pluginsModulesPath, repositoryRoot, runtime, srcDir, srcPath, stat, }) => {
     const { externalModules, ignoredModules } = await getExternalAndIgnoredModules({ config, srcDir });
-    const { additionalPaths, bundlePaths, cleanTempFiles, extension: outputExtension, inputs, moduleFormat, nativeNodeModules = {}, nodeModulesWithDynamicImports, warnings, } = await bundleJsFile({
+    const { additionalPaths, bundlePaths, cleanTempFiles, inputs, moduleFormat, nativeNodeModules = {}, nodeModulesWithDynamicImports, outputExtension, warnings, } = await bundleJsFile({
         additionalModulePaths: pluginsModulesPath ? [pluginsModulesPath] : [],
         basePath,
         config,

package/dist/runtimes/node/bundlers/nft/index.js

@@ -43,9 +43,9 @@ const ignoreFunction = (path) => {
 const traceFilesAndTranspile = async function ({ basePath, cache, config, featureFlags, mainFile, pluginsModulesPath, name, }) {
     const { fileList: dependencyPaths, esmFileList, reasons, } = await nodeFileTrace([mainFile], {
         // Default is 1024. Allowing double the fileIO in parallel makes nft faster, but uses a little more memory.
-        fileIOConcurrency: featureFlags.zisi_nft_higher_fileio_limit ? 2048 : 1024,
+        fileIOConcurrency: 2048,
         base: basePath,
-        cache: featureFlags.zisi_nft_use_cache ? cache.nftCache : undefined,
+        cache: cache.nftCache,
         ignore: ignoreFunction,
         readFile: async (path) => {
             try {

package/dist/runtimes/node/utils/entry_file.d.ts

@@ -1,7 +1,23 @@
+import type { FeatureFlags } from '../../../feature_flags.js';
 import { ModuleFormat } from './module_format.js';
-export declare const getEntryFile: ({ commonPrefix, mainFile, moduleFormat, userNamespace, }: {
+export interface EntryFile {
+    contents: string;
+    filename: string;
+}
+export declare const isNamedLikeEntryFile: (file: string, { basePath, filename, }: {
+    basePath: string;
+    filename: string;
+}) => boolean;
+export declare const conflictsWithEntryFile: (srcFiles: string[], { basePath, mainFile, filename, }: {
+    basePath: string;
+    filename: string;
+    mainFile: string;
+}) => boolean;
+export declare const getEntryFile: ({ commonPrefix, featureFlags, filename, mainFile, moduleFormat, userNamespace, }: {
     commonPrefix: string;
+    featureFlags: FeatureFlags;
+    filename: string;
     mainFile: string;
     moduleFormat: ModuleFormat;
     userNamespace: string;
-}) => string;
+}) => EntryFile;

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

@@ -1,10 +1,35 @@
+import { basename, extname, resolve } from 'path';
+import { getFileExtensionForFormat } from './module_format.js';
 import { normalizeFilePath } from './normalize_path.js';
-export const getEntryFile = ({ commonPrefix, mainFile, moduleFormat, userNamespace, }) => {
-    const mainPath = normalizeFilePath({ commonPrefix, path: mainFile, userNamespace });
+const getEntryFileContents = (mainPath, moduleFormat) => {
     const importPath = `.${mainPath.startsWith('/') ? mainPath : `/${mainPath}`}`;
     if (moduleFormat === "cjs" /* ModuleFormat.COMMONJS */) {
         return `module.exports = require('${importPath}')`;
     }
     return `export { handler } from '${importPath}'`;
 };
+// They are in the order that AWS Lambda will try to find the entry point
+const POSSIBLE_LAMBDA_ENTRY_EXTENSIONS = [".js" /* ModuleFileExtension.JS */, ".mjs" /* ModuleFileExtension.MJS */, ".cjs" /* ModuleFileExtension.CJS */];
+// checks if the file is considered a entry-file in AWS Lambda
+export const isNamedLikeEntryFile = (file, { basePath, filename, }) => POSSIBLE_LAMBDA_ENTRY_EXTENSIONS.some((extension) => {
+    const entryFilename = getEntryFileName({ extension, filename });
+    const entryFilePath = resolve(basePath, entryFilename);
+    return entryFilePath === file;
+});
+// Check if any src file (except the mainFile) is considered an entry file for AWS Lambda
+export const conflictsWithEntryFile = (srcFiles, { basePath, mainFile, filename, }) => srcFiles.some((srcFile) => isNamedLikeEntryFile(srcFile, { basePath, filename }) && srcFile !== mainFile);
+// Returns the name for the AWS Lambda entry file
+// We do set the handler in AWS Lambda to `<func-name>.handler` and because of
+// this it considers `<func-name>.(c|m)?js` as possible entry-points
+const getEntryFileName = ({ extension, filename }) => `${basename(filename, extname(filename))}${extension}`;
+export const getEntryFile = ({ commonPrefix, featureFlags, filename, mainFile, moduleFormat, userNamespace, }) => {
+    const mainPath = normalizeFilePath({ commonPrefix, path: mainFile, userNamespace });
+    const extension = getFileExtensionForFormat(moduleFormat, featureFlags);
+    const entryFilename = getEntryFileName({ extension, filename });
+    const contents = getEntryFileContents(mainPath, moduleFormat);
+    return {
+        contents,
+        filename: entryFilename,
+    };
+};
 //# sourceMappingURL=entry_file.js.map

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

@@ -2,6 +2,9 @@ export const getFileExtensionForFormat = (moduleFormat, featureFlags) => {
     if (moduleFormat === "esm" /* ModuleFormat.ESM */ && featureFlags.zisi_pure_esm_mjs) {
         return ".mjs" /* ModuleFileExtension.MJS */;
     }
+    if (featureFlags.zisi_output_cjs_extension && moduleFormat === "cjs" /* ModuleFormat.COMMONJS */) {
+        return ".cjs" /* ModuleFileExtension.CJS */;
+    }
     return ".js" /* ModuleFileExtension.JS */;
 };
 //# sourceMappingURL=module_format.js.map

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

@@ -1,14 +1,13 @@
 import { Buffer } from 'buffer';
 import { promises as fs } from 'fs';
 import os from 'os';
-import { basename, join, resolve } from 'path';
+import { basename, join } from 'path';
 import { copyFile } from 'cp-file';
 import { deleteAsync as deleteFiles } from 'del';
 import pMap from 'p-map';
 import { startZip, addZipFile, addZipContent, endZip } from '../../../archive.js';
 import { cachedLstat, mkdirAndWriteFile } from '../../../utils/fs.js';
-import { getEntryFile } from './entry_file.js';
-import { getFileExtensionForFormat } from './module_format.js';
+import { conflictsWithEntryFile, getEntryFile, isNamedLikeEntryFile } from './entry_file.js';
 import { normalizeFilePath } from './normalize_path.js';
 // Taken from https://www.npmjs.com/package/cpy.
 const COPY_FILE_CONCURRENCY = os.cpus().length === 0 ? 2 : os.cpus().length * 2;
@@ -16,21 +15,20 @@ const COPY_FILE_CONCURRENCY = os.cpus().length === 0 ? 2 : os.cpus().length * 2;
 // the entry file generated by zip-it-and-ship-it).
 const DEFAULT_USER_SUBDIRECTORY = 'src';
 const createDirectory = async function ({ aliases = new Map(), basePath, destFolder, extension, featureFlags, filename, mainFile, moduleFormat, rewrites = new Map(), srcFiles, }) {
-    const entryFile = getEntryFile({
+    const { contents: entryContents, filename: entryFilename } = getEntryFile({
         commonPrefix: basePath,
+        featureFlags,
+        filename,
         mainFile,
         moduleFormat,
         userNamespace: DEFAULT_USER_SUBDIRECTORY,
     });
-    const entryFileExtension = getFileExtensionForFormat(moduleFormat, featureFlags);
-    const entryFilename = basename(filename, extension) + entryFileExtension;
     const functionFolder = join(destFolder, basename(filename, extension));
-    const entryFilePath = resolve(functionFolder, entryFilename);
     // Deleting the functions directory in case it exists before creating it.
     await deleteFiles(functionFolder, { force: true });
     await fs.mkdir(functionFolder, { recursive: true });
     // Writing entry file.
-    await fs.writeFile(entryFilePath, entryFile);
+    await fs.writeFile(join(functionFolder, entryFilename), entryContents);
     // Copying source files.
     await pMap(srcFiles, (srcFile) => {
         const destPath = aliases.get(srcFile) || srcFile;
@@ -50,22 +48,30 @@ const createDirectory = async function ({ aliases = new Map(), basePath, destFol
 const createZipArchive = async function ({ aliases, basePath, cache, destFolder, extension, featureFlags, filename, mainFile, moduleFormat, rewrites, srcFiles, }) {
     const destPath = join(destFolder, `${basename(filename, extension)}.zip`);
     const { archive, output } = startZip(destPath);
-    const entryFileExtension = getFileExtensionForFormat(moduleFormat, featureFlags);
-    const entryFilename = basename(filename, extension) + entryFileExtension;
-    const entryFilePath = resolve(basePath, entryFilename);
     // We don't need an entry file if it would end up with the same path as the
     // function's main file.
-    const needsEntryFile = entryFilePath !== mainFile;
+    const needsEntryFile = !isNamedLikeEntryFile(mainFile, { basePath, filename });
     // There is a naming conflict with the entry file if one of the supporting
     // files (i.e. not the main file) has the path that the entry file needs to
     // take.
-    const hasEntryFileConflict = srcFiles.some((srcFile) => srcFile === entryFilePath && srcFile !== mainFile);
+    const hasEntryFileConflict = conflictsWithEntryFile(srcFiles, {
+        basePath,
+        filename,
+        mainFile,
+    });
     // If there is a naming conflict, we move all user files (everything other
     // than the entry file) to its own sub-directory.
     const userNamespace = hasEntryFileConflict ? DEFAULT_USER_SUBDIRECTORY : '';
     if (needsEntryFile) {
-        const entryFile = getEntryFile({ commonPrefix: basePath, mainFile, moduleFormat, userNamespace });
-        addEntryFileToZip(archive, entryFile, basename(entryFilePath));
+        const entryFile = getEntryFile({
+            commonPrefix: basePath,
+            filename,
+            mainFile,
+            moduleFormat,
+            userNamespace,
+            featureFlags,
+        });
+        addEntryFileToZip(archive, entryFile);
     }
     const srcFilesInfos = await Promise.all(srcFiles.map((file) => addStat(cache, file)));
     // We ensure this is not async, so that the archive's checksum is
@@ -90,7 +96,7 @@ export const zipNodeJs = function ({ archiveFormat, ...options }) {
     }
     return createDirectory(options);
 };
-const addEntryFileToZip = function (archive, contents, filename) {
+const addEntryFileToZip = function (archive, { contents, filename }) {
     const contentBuffer = Buffer.from(contents);
     addZipContent(archive, contentBuffer, filename);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/zip-it-and-ship-it",
-  "version": "8.2.0",
+  "version": "8.3.0",
   "description": "Zip it and ship it",
   "main": "./dist/main.js",
   "type": "module",
@@ -97,7 +97,7 @@
     "@types/tmp": "^0.2.3",
     "@types/unixify": "^1.0.0",
     "@types/yargs": "^17.0.4",
-    "@vitest/coverage-c8": "^0.25.0",
+    "@vitest/coverage-c8": "^0.27.0",
     "cpy": "^9.0.0",
     "deepmerge": "^4.2.2",
     "get-stream": "^6.0.0",
@@ -108,7 +108,7 @@
     "throat": "^6.0.1",
     "typescript": "^4.8.4",
     "vite": "^4.0.0",
-    "vitest": "^0.25.0"
+    "vitest": "^0.27.0"
   },
   "engines": {
     "node": "^14.16.0 || >=16.0.0"