@netlify/zip-it-and-ship-it 9.2.0 → 9.3.0

package/dist/feature_flags.d.ts

@@ -1,4 +1,23 @@
-export declare const defaultFlags: Record<string, boolean>;
-export type FeatureFlag = keyof typeof defaultFlags;
-export type FeatureFlags = Record<FeatureFlag, boolean>;
-export declare const getFlags: (input?: Record<string, boolean>, flags?: Record<string, boolean>) => FeatureFlags;
+export declare const defaultFlags: {
+    readonly buildRustSource: boolean;
+    readonly parseWithEsbuild: false;
+    readonly traceWithNft: false;
+    readonly functions_inherit_build_nodejs_version: false;
+    readonly zisi_pure_esm: false;
+    readonly zisi_pure_esm_mjs: false;
+    readonly zisi_output_cjs_extension: false;
+    readonly zisi_functions_api_v2: false;
+    readonly zisi_unique_entry_file: false;
+};
+export type FeatureFlags = Partial<Record<keyof typeof defaultFlags, boolean>>;
+export declare const getFlags: (input?: Record<string, boolean>, flags?: {
+    readonly buildRustSource: boolean;
+    readonly parseWithEsbuild: false;
+    readonly traceWithNft: false;
+    readonly functions_inherit_build_nodejs_version: false;
+    readonly zisi_pure_esm: false;
+    readonly zisi_pure_esm_mjs: false;
+    readonly zisi_output_cjs_extension: false;
+    readonly zisi_functions_api_v2: false;
+    readonly zisi_unique_entry_file: false;
+}) => FeatureFlags;

package/dist/feature_flags.js

@@ -6,6 +6,8 @@ export const defaultFlags = {
     parseWithEsbuild: false,
     // Use NFT as the default bundler.
     traceWithNft: false,
+    // Should Lambda functions inherit the build Node.js version
+    functions_inherit_build_nodejs_version: false,
     // Output pure (i.e. untranspiled) ESM files when the function file has ESM
     // syntax and the parent `package.json` file has `{"type": "module"}`.
     zisi_pure_esm: false,
@@ -14,10 +16,10 @@ export const defaultFlags = {
     zisi_pure_esm_mjs: false,
     // Output CJS file extension.
     zisi_output_cjs_extension: false,
-    // Do not allow ___netlify-entry-point as function or file name.
-    zisi_disallow_new_entry_name: false,
     // Inject the compatibility layer required for the v2 runtime API to work.
     zisi_functions_api_v2: false,
+    // Create unique entry file instead of a file that is based on the function name.
+    zisi_unique_entry_file: false,
 };
 // List of supported flags and their default value.
 export const getFlags = (input = {}, flags = defaultFlags) => Object.entries(flags).reduce((result, [key, defaultValue]) => ({

package/dist/main.d.ts

@@ -27,13 +27,13 @@ interface ListFunctionsOptions {
     parseISC?: boolean;
 }
 export declare const listFunctions: (relativeSrcFolders: string | string[], { featureFlags: inputFeatureFlags, config, configFileDirectories, parseISC, }?: {
-    featureFlags?: FeatureFlags | undefined;
+    featureFlags?: Partial<Record<"buildRustSource" | "parseWithEsbuild" | "traceWithNft" | "functions_inherit_build_nodejs_version" | "zisi_pure_esm" | "zisi_pure_esm_mjs" | "zisi_output_cjs_extension" | "zisi_functions_api_v2" | "zisi_unique_entry_file", boolean>> | undefined;
     config?: Config | undefined;
     configFileDirectories?: string[] | undefined;
     parseISC?: boolean | undefined;
 }) => Promise<ListedFunction[]>;
 export declare const listFunction: (path: string, { featureFlags: inputFeatureFlags, config, configFileDirectories, parseISC, }?: {
-    featureFlags?: FeatureFlags | undefined;
+    featureFlags?: Partial<Record<"buildRustSource" | "parseWithEsbuild" | "traceWithNft" | "functions_inherit_build_nodejs_version" | "zisi_pure_esm" | "zisi_pure_esm_mjs" | "zisi_output_cjs_extension" | "zisi_functions_api_v2" | "zisi_unique_entry_file", boolean>> | undefined;
     config?: Config | undefined;
     configFileDirectories?: string[] | undefined;
     parseISC?: boolean | undefined;

package/dist/manifest.d.ts

@@ -1,4 +1,5 @@
-import { FunctionResult } from './utils/format_result.js';
+import type { FeatureFlags } from './feature_flags.js';
+import type { FunctionResult } from './utils/format_result.js';
 interface ManifestFunction {
     mainFile: string;
     name: string;
@@ -19,7 +20,8 @@ export interface Manifest {
     timestamp: number;
     version: number;
 }
-export declare const createManifest: ({ functions, path }: {
+export declare const createManifest: ({ featureFlags, functions, path, }: {
+    featureFlags: FeatureFlags;
     functions: FunctionResult[];
     path: string;
 }) => Promise<void>;

package/dist/manifest.js

@@ -2,8 +2,8 @@ import { promises as fs } from 'fs';
 import { resolve } from 'path';
 import { arch, platform } from 'process';
 const MANIFEST_VERSION = 1;
-export const createManifest = async ({ functions, path }) => {
-    const formattedFunctions = functions.map(formatFunctionForManifest);
+export const createManifest = async ({ featureFlags, functions, path, }) => {
+    const formattedFunctions = functions.map((func) => formatFunctionForManifest(func, featureFlags));
     const payload = {
         functions: formattedFunctions,
         system: { arch, platform },
@@ -12,13 +12,13 @@ export const createManifest = async ({ functions, path }) => {
     };
     await fs.writeFile(path, JSON.stringify(payload));
 };
-const formatFunctionForManifest = ({ bundler, displayName, generator, mainFile, name, path, runtime, runtimeVersion, schedule, }) => ({
+const formatFunctionForManifest = ({ bundler, displayName, generator, mainFile, name, path, runtime, runtimeVersion, schedule }, featureFlags) => ({
     bundler,
     displayName,
     generator,
     mainFile,
     name,
-    runtimeVersion,
+    runtimeVersion: featureFlags.functions_inherit_build_nodejs_version ? runtimeVersion : undefined,
     path: resolve(path),
     runtime,
     schedule,

package/dist/runtimes/index.d.ts

@@ -11,7 +11,7 @@ export declare const getFunctionsFromPaths: (paths: string[], { cache, config, c
     config?: Config | undefined;
     configFileDirectories?: string[] | undefined;
     dedupe?: boolean | undefined;
-    featureFlags?: FeatureFlags | undefined;
+    featureFlags?: Partial<Record<"buildRustSource" | "parseWithEsbuild" | "traceWithNft" | "functions_inherit_build_nodejs_version" | "zisi_pure_esm" | "zisi_pure_esm_mjs" | "zisi_output_cjs_extension" | "zisi_functions_api_v2" | "zisi_unique_entry_file", boolean>> | undefined;
 }) => Promise<FunctionMap>;
 /**
  * Gets a list of functions found in a list of paths.
@@ -20,6 +20,6 @@ export declare const getFunctionFromPath: (path: string, { cache, config, config
     cache: RuntimeCache;
     config?: Config | undefined;
     configFileDirectories?: string[] | undefined;
-    featureFlags?: FeatureFlags | undefined;
+    featureFlags?: Partial<Record<"buildRustSource" | "parseWithEsbuild" | "traceWithNft" | "functions_inherit_build_nodejs_version" | "zisi_pure_esm" | "zisi_pure_esm_mjs" | "zisi_output_cjs_extension" | "zisi_functions_api_v2" | "zisi_unique_entry_file", boolean>> | undefined;
 }) => Promise<FunctionSource | undefined>;
 export {};

package/dist/runtimes/index.js

@@ -20,7 +20,7 @@ const findFunctionsInRuntime = async function ({ cache, dedupe = false, featureF
     const key = dedupe ? 'name' : 'srcPath';
     // Augmenting the function objects with additional information.
     const augmentedFunctions = functions.map((func) => {
-        if (featureFlags.zisi_disallow_new_entry_name && func.name === ENTRY_FILE_NAME) {
+        if (func.name === ENTRY_FILE_NAME) {
             throw new FunctionBundlingUserError(`'${ENTRY_FILE_NAME}' is a reserved word and cannot be used as a function name.`, {
                 functionName: func.name,
                 runtime: runtime.name,

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

@@ -31,7 +31,8 @@ const ESBUILD_EXTENSIONS = new Set(['.mjs', '.ts', '.tsx', '.cts', '.mts']);
 // We use ZISI as the default bundler, except for certain extensions, for which
 // esbuild is the only option.
 const getDefaultBundler = async ({ extension, featureFlags, mainFile, }) => {
-    if (extension === MODULE_FILE_EXTENSION.MJS && featureFlags.zisi_pure_esm_mjs) {
+    if ((extension === MODULE_FILE_EXTENSION.MJS && featureFlags.zisi_pure_esm_mjs) ||
+        featureFlags.zisi_functions_api_v2) {
         return NODE_BUNDLER.NFT;
     }
     if (ESBUILD_EXTENSIONS.has(extension)) {

package/dist/runtimes/node/bundlers/types.d.ts

@@ -1,6 +1,6 @@
 import type { Message } from '@netlify/esbuild';
 import type { FunctionConfig } from '../../../config.js';
-import type { FeatureFlag, FeatureFlags } from '../../../feature_flags.js';
+import type { FeatureFlags } from '../../../feature_flags.js';
 import type { FunctionSource } from '../../../function.js';
 import { ObjectValues } from '../../../types/utils.js';
 import type { RuntimeCache } from '../../../utils/cache.js';
@@ -20,7 +20,7 @@ export type BundleFunction = (args: {
     basePath?: string;
     cache: RuntimeCache;
     config: FunctionConfig;
-    featureFlags: Record<FeatureFlag, boolean>;
+    featureFlags: FeatureFlags;
     pluginsModulesPath?: string;
     repositoryRoot?: string;
 } & FunctionSource) => Promise<{

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

@@ -1,13 +1,14 @@
 import type { FeatureFlags } from '../../../feature_flags.js';
 import { ModuleFormat } from './module_format.js';
 export declare const ENTRY_FILE_NAME = "___netlify-entry-point";
-export declare const BOOTSTRAP_FILE_NAME = "___netlify-bootstrap.js";
+export declare const BOOTSTRAP_FILE_NAME = "___netlify-bootstrap.mjs";
 export interface EntryFile {
     contents: string;
     filename: string;
 }
-export declare const isNamedLikeEntryFile: (file: string, { basePath, filename, }: {
+export declare const isNamedLikeEntryFile: (file: string, { basePath, featureFlags, filename, }: {
     basePath: string;
+    featureFlags: FeatureFlags;
     filename: string;
 }) => boolean;
 export declare const conflictsWithEntryFile: (srcFiles: string[], { basePath, extension, featureFlags, filename, mainFile, }: {

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

@@ -4,7 +4,7 @@ import { RUNTIME } from '../../runtime.js';
 import { getFileExtensionForFormat, MODULE_FILE_EXTENSION, MODULE_FORMAT, } from './module_format.js';
 import { normalizeFilePath } from './normalize_path.js';
 export const ENTRY_FILE_NAME = '___netlify-entry-point';
-export const BOOTSTRAP_FILE_NAME = '___netlify-bootstrap.js';
+export const BOOTSTRAP_FILE_NAME = '___netlify-bootstrap.mjs';
 const getEntryFileContents = (mainPath, moduleFormat, featureFlags) => {
     const importPath = `.${mainPath.startsWith('/') ? mainPath : `/${mainPath}`}`;
     if (featureFlags.zisi_functions_api_v2) {
@@ -12,7 +12,11 @@ const getEntryFileContents = (mainPath, moduleFormat, featureFlags) => {
             `import func from '${importPath}'`,
             `import { getLambdaHandler } from './${BOOTSTRAP_FILE_NAME}'`,
             `export const handler = getLambdaHandler(func)`,
-        ].join(';\n');
+        ].join(';');
+    }
+    if (featureFlags.zisi_unique_entry_file) {
+        // we use dynamic import because we do not know if the user code is cjs or esm
+        return [`const { handler } = await import('${importPath}')`, 'export { handler }'].join(';');
     }
     if (moduleFormat === MODULE_FORMAT.COMMONJS) {
         return `module.exports = require('${importPath}')`;
@@ -26,8 +30,8 @@ const POSSIBLE_LAMBDA_ENTRY_EXTENSIONS = [
     MODULE_FILE_EXTENSION.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 });
+export const isNamedLikeEntryFile = (file, { basePath, featureFlags, filename, }) => POSSIBLE_LAMBDA_ENTRY_EXTENSIONS.some((extension) => {
+    const entryFilename = getEntryFileName({ extension, featureFlags, filename });
     const entryFilePath = resolve(basePath, entryFilename);
     return entryFilePath === file;
 });
@@ -35,13 +39,18 @@ export const isNamedLikeEntryFile = (file, { basePath, filename, }) => POSSIBLE_
 export const conflictsWithEntryFile = (srcFiles, { basePath, extension, featureFlags, filename, mainFile, }) => {
     let hasConflict = false;
     srcFiles.forEach((srcFile) => {
-        if (featureFlags.zisi_disallow_new_entry_name && srcFile.includes(ENTRY_FILE_NAME)) {
+        if (srcFile.includes(ENTRY_FILE_NAME)) {
             throw new FunctionBundlingUserError(`'${ENTRY_FILE_NAME}' is a reserved word and cannot be used as a file or directory name.`, {
                 functionName: basename(filename, extension),
                 runtime: RUNTIME.JAVASCRIPT,
             });
         }
-        if (!hasConflict && isNamedLikeEntryFile(srcFile, { basePath, filename }) && srcFile !== mainFile) {
+        // If we're generating a unique entry file, we know we don't have a conflict
+        // at this point.
+        if (featureFlags.zisi_unique_entry_file || featureFlags.zisi_functions_api_v2) {
+            return;
+        }
+        if (!hasConflict && isNamedLikeEntryFile(srcFile, { basePath, featureFlags, filename }) && srcFile !== mainFile) {
             hasConflict = true;
         }
     });
@@ -50,11 +59,16 @@ export const conflictsWithEntryFile = (srcFiles, { basePath, extension, featureF
 // 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}`;
+const getEntryFileName = ({ extension, featureFlags, filename, }) => {
+    if (featureFlags.zisi_unique_entry_file || featureFlags.zisi_functions_api_v2) {
+        return `${ENTRY_FILE_NAME}.mjs`;
+    }
+    return `${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 entryFilename = getEntryFileName({ extension, featureFlags, filename });
     const contents = getEntryFileContents(mainPath, moduleFormat, featureFlags);
     return {
         contents,

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

@@ -61,7 +61,10 @@ const createZipArchive = async function ({ aliases = new Map(), basePath, cache,
     });
     // We don't need an entry file if it would end up with the same path as the
     // function's main file. Unless we have a file conflict and need to move everything into a subfolder
-    const needsEntryFile = hasEntryFileConflict || !isNamedLikeEntryFile(mainFile, { basePath, filename });
+    const needsEntryFile = featureFlags.zisi_unique_entry_file ||
+        featureFlags.zisi_functions_api_v2 ||
+        hasEntryFileConflict ||
+        !isNamedLikeEntryFile(mainFile, { basePath, featureFlags, filename });
     // 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 : '';

package/dist/zip.js

@@ -80,7 +80,7 @@ export const zipFunctions = async function (relativeSrcFolders, destFolder, { ar
         return formatZipResult(resultWithSize);
     }));
     if (manifest !== undefined) {
-        await createManifest({ functions: formattedResults, path: resolve(manifest) });
+        await createManifest({ featureFlags, functions: formattedResults, path: resolve(manifest) });
     }
     return formattedResults;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/zip-it-and-ship-it",
-  "version": "9.2.0",
+  "version": "9.3.0",
   "description": "Zip it and ship it",
   "main": "./dist/main.js",
   "type": "module",
@@ -57,7 +57,7 @@
     "@babel/parser": "7.16.8",
     "@netlify/binary-info": "^1.0.0",
     "@netlify/esbuild": "0.14.39",
-    "@netlify/serverless-functions-api": "^1.2.0",
+    "@netlify/serverless-functions-api": "^1.3.0",
     "@vercel/nft": "^0.22.0",
     "archiver": "^5.3.0",
     "common-path-prefix": "^3.0.0",
@@ -100,7 +100,7 @@
     "@types/tmp": "^0.2.3",
     "@types/unixify": "^1.0.0",
     "@types/yargs": "^17.0.4",
-    "@vitest/coverage-c8": "^0.30.0",
+    "@vitest/coverage-c8": "^0.31.0",
     "cpy": "^9.0.0",
     "deepmerge": "^4.2.2",
     "get-stream": "^6.0.0",
@@ -112,7 +112,7 @@
     "throat": "^6.0.1",
     "typescript": "^5.0.0",
     "vite": "^4.0.0",
-    "vitest": "^0.30.0"
+    "vitest": "^0.31.0"
   },
   "engines": {
     "node": "^14.18.0 || >=16.0.0"