@netlify/zip-it-and-ship-it 9.5.0 → 9.6.0

package/dist/feature_flags.d.ts

@@ -8,6 +8,7 @@ export declare const defaultFlags: {
     readonly zisi_output_cjs_extension: false;
     readonly zisi_functions_api_v2: false;
     readonly zisi_unique_entry_file: false;
+    readonly zisi_use_latest_babel_version: false;
 };
 export type FeatureFlags = Partial<Record<keyof typeof defaultFlags, boolean>>;
 export declare const getFlags: (input?: Record<string, boolean>, flags?: {
@@ -20,4 +21,5 @@ export declare const getFlags: (input?: Record<string, boolean>, flags?: {
     readonly zisi_output_cjs_extension: false;
     readonly zisi_functions_api_v2: false;
     readonly zisi_unique_entry_file: false;
+    readonly zisi_use_latest_babel_version: false;
 }) => FeatureFlags;

package/dist/feature_flags.js

@@ -20,6 +20,8 @@ export const defaultFlags = {
     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,
+    // Uses the latest babel parser version
+    zisi_use_latest_babel_version: 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?: 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;
+    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" | "zisi_use_latest_babel_version", 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?: 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;
+    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" | "zisi_use_latest_babel_version", boolean>> | undefined;
     config?: Config | undefined;
     configFileDirectories?: string[] | undefined;
     parseISC?: boolean | undefined;

package/dist/main.js

@@ -10,13 +10,13 @@ export { ARCHIVE_FORMAT } from './archive.js';
 export { NODE_BUNDLER } from './runtimes/node/bundlers/types.js';
 export { RUNTIME } from './runtimes/runtime.js';
 export { MODULE_FORMAT } from './runtimes/node/utils/module_format.js';
-const augmentWithISC = async (func) => {
+const augmentWithISC = async (func, featureFlags) => {
     // ISC is currently only supported in JavaScript and TypeScript functions
     // and only supports scheduled functions.
     if (func.runtime.name !== RUNTIME.JAVASCRIPT) {
         return func;
     }
-    const inSourceConfig = await findISCDeclarationsInPath(func.mainFile, func.name);
+    const inSourceConfig = await findISCDeclarationsInPath(func.mainFile, func.name, featureFlags);
     return { ...func, inSourceConfig };
 };
 // List all Netlify Functions main entry files for a specific directory
@@ -27,7 +27,9 @@ export const listFunctions = async function (relativeSrcFolders, { featureFlags:
     const cache = new RuntimeCache();
     const functionsMap = await getFunctionsFromPaths(paths, { cache, config, configFileDirectories, featureFlags });
     const functions = [...functionsMap.values()];
-    const augmentedFunctions = parseISC ? await Promise.all(functions.map(augmentWithISC)) : functions;
+    const augmentedFunctions = parseISC
+        ? await Promise.all(functions.map((func) => augmentWithISC(func, featureFlags)))
+        : functions;
     return augmentedFunctions.map(getListedFunction);
 };
 // Finds a function at a specific path.
@@ -38,7 +40,7 @@ export const listFunction = async function (path, { featureFlags: inputFeatureFl
     if (!func) {
         return;
     }
-    const augmentedFunction = parseISC ? await augmentWithISC(func) : func;
+    const augmentedFunction = parseISC ? await augmentWithISC(func, featureFlags) : func;
     return getListedFunction(augmentedFunction);
 };
 // List all Netlify Functions files for a specific directory
@@ -49,7 +51,9 @@ export const listFunctionsFiles = async function (relativeSrcFolders, { basePath
     const cache = new RuntimeCache();
     const functionsMap = await getFunctionsFromPaths(paths, { cache, config, configFileDirectories, featureFlags });
     const functions = [...functionsMap.values()];
-    const augmentedFunctions = parseISC ? await Promise.all(functions.map(augmentWithISC)) : functions;
+    const augmentedFunctions = parseISC
+        ? await Promise.all(functions.map((func) => augmentWithISC(func, featureFlags)))
+        : functions;
     const listedFunctionsFiles = await Promise.all(augmentedFunctions.map((func) => getListedFunctionFiles(func, { basePath, featureFlags })));
     return listedFunctionsFiles.flat();
 };
@@ -65,7 +69,11 @@ const getListedFunction = function ({ runtime, name, mainFile, extension, config
     };
 };
 const getListedFunctionFiles = async function (func, options) {
-    const srcFiles = await getSrcFiles({ ...func, ...options });
+    const srcFiles = await getSrcFiles({
+        ...func,
+        ...options,
+        runtimeAPIVersion: func.inSourceConfig?.runtimeAPIVersion ?? 1,
+    });
     return srcFiles.map((srcFile) => ({ ...getListedFunction(func), srcFile, extension: extname(srcFile) }));
 };
 const getSrcFiles = async function ({ extension, runtime, srcPath, ...args }) {

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?: 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;
+    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" | "zisi_use_latest_babel_version", 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?: 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;
+    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" | "zisi_use_latest_babel_version", boolean>> | undefined;
 }) => Promise<FunctionSource | undefined>;
 export {};

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

@@ -43,6 +43,7 @@ export const bundleJsFile = async function ({ additionalModulePaths, basePath, c
             moduleNames: nodeModulesWithDynamicImports,
             processImports: config.processDynamicNodeImports !== false,
             srcDir,
+            featureFlags,
         }),
     ];
     // The version of ECMAScript to use as the build target. This will determine

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

@@ -1,8 +1,10 @@
 import type { Plugin } from '@netlify/esbuild';
-export declare const getDynamicImportsPlugin: ({ basePath, includedPaths, moduleNames, processImports, srcDir, }: {
+import type { FeatureFlags } from '../../../../feature_flags.js';
+export declare const getDynamicImportsPlugin: ({ basePath, includedPaths, moduleNames, processImports, srcDir, featureFlags, }: {
     basePath?: string | undefined;
     includedPaths: Set<string>;
     moduleNames: Set<string>;
     processImports: boolean;
     srcDir: string;
+    featureFlags: FeatureFlags;
 }) => Plugin;

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

@@ -10,7 +10,7 @@ import { readPackageJson } from '../../utils/package_json.js';
 // issues. Secondly, it parses the dynamic expressions and tries to include in
 // the bundle all the files that are possibly needed to make the import work at
 // runtime. This is not always possible, but we do our best.
-export const getDynamicImportsPlugin = ({ basePath, includedPaths, moduleNames, processImports, srcDir, }) => ({
+export const getDynamicImportsPlugin = ({ basePath, includedPaths, moduleNames, processImports, srcDir, featureFlags, }) => ({
     name: 'dynamic-imports',
     setup(build) {
         const cache = new Map();
@@ -21,7 +21,7 @@ export const getDynamicImportsPlugin = ({ basePath, includedPaths, moduleNames,
             // Also don't parse the expression if we're not interested in processing
             // the dynamic import expressions.
             if (basePath && processImports) {
-                const { includedPathsGlob, type: expressionType } = parseExpression({ basePath, expression, resolveDir }) || {};
+                const { includedPathsGlob, type: expressionType } = parseExpression({ basePath, expression, resolveDir, featureFlags }) || {};
                 if (includedPathsGlob) {
                     // The parser has found a glob of paths that should be included in the
                     // bundle to make this import work, so we add it to `includedPaths`.

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

@@ -2,9 +2,10 @@ import { FunctionConfig } from '../../../config.js';
 import { FeatureFlags } from '../../../feature_flags.js';
 import { NodeBundler, NodeBundlerName } from './types.js';
 export declare const getBundler: (name: NodeBundlerName) => NodeBundler;
-export declare const getBundlerName: ({ config: { nodeBundler }, extension, featureFlags, mainFile, }: {
+export declare const getBundlerName: ({ config: { nodeBundler }, extension, featureFlags, mainFile, runtimeAPIVersion, }: {
     config: FunctionConfig;
     extension: string;
     featureFlags: FeatureFlags;
     mainFile: string;
+    runtimeAPIVersion: number;
 }) => Promise<NodeBundlerName>;

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

@@ -21,18 +21,17 @@ export const getBundler = (name) => {
             throw new Error(`Unsupported Node bundler: ${name}`);
     }
 };
-export const getBundlerName = async ({ config: { nodeBundler }, extension, featureFlags, mainFile, }) => {
+export const getBundlerName = async ({ config: { nodeBundler }, extension, featureFlags, mainFile, runtimeAPIVersion, }) => {
     if (nodeBundler) {
         return nodeBundler;
     }
-    return await getDefaultBundler({ extension, featureFlags, mainFile });
+    return await getDefaultBundler({ extension, featureFlags, mainFile, runtimeAPIVersion });
 };
 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) ||
-        featureFlags.zisi_functions_api_v2) {
+const getDefaultBundler = async ({ extension, featureFlags, mainFile, runtimeAPIVersion, }) => {
+    if ((extension === MODULE_FILE_EXTENSION.MJS && featureFlags.zisi_pure_esm_mjs) || runtimeAPIVersion === 2) {
         return NODE_BUNDLER.NFT;
     }
     if (ESBUILD_EXTENSIONS.has(extension)) {

package/dist/runtimes/node/bundlers/nft/es_modules.d.ts

@@ -3,7 +3,7 @@ import type { FunctionConfig } from '../../../../config.js';
 import { FeatureFlags } from '../../../../feature_flags.js';
 import type { RuntimeCache } from '../../../../utils/cache.js';
 import { ModuleFormat } from '../../utils/module_format.js';
-export declare const processESM: ({ basePath, cache, config, esmPaths, featureFlags, mainFile, reasons, name, }: {
+export declare const processESM: ({ basePath, cache, config, esmPaths, featureFlags, mainFile, reasons, name, runtimeAPIVersion, }: {
     basePath: string | undefined;
     cache: RuntimeCache;
     config: FunctionConfig;
@@ -12,6 +12,7 @@ export declare const processESM: ({ basePath, cache, config, esmPaths, featureFl
     mainFile: string;
     reasons: NodeFileTraceReasons;
     name: string;
+    runtimeAPIVersion: number;
 }) => Promise<{
     rewrites?: Map<string, string> | undefined;
     moduleFormat: ModuleFormat;

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

@@ -29,19 +29,18 @@ const patchESMPackage = async (path, cache) => {
     };
     return JSON.stringify(patchedPackageJson);
 };
-export const processESM = async ({ basePath, cache, config, esmPaths, featureFlags, mainFile, reasons, name, }) => {
+export const processESM = async ({ basePath, cache, config, esmPaths, featureFlags, mainFile, reasons, name, runtimeAPIVersion, }) => {
     const extension = extname(mainFile);
     // If this is a .mjs file and we want to output pure ESM files, we don't need
     // to transpile anything.
-    if (extension === MODULE_FILE_EXTENSION.MJS &&
-        (featureFlags.zisi_pure_esm_mjs || featureFlags.zisi_functions_api_v2)) {
+    if (extension === MODULE_FILE_EXTENSION.MJS && (featureFlags.zisi_pure_esm_mjs || runtimeAPIVersion === 2)) {
         return {
             moduleFormat: MODULE_FORMAT.ESM,
         };
     }
     const entrypointIsESM = isEntrypointESM({ basePath, esmPaths, mainFile });
     if (!entrypointIsESM) {
-        if (featureFlags.zisi_functions_api_v2) {
+        if (runtimeAPIVersion === 2) {
             throw new FunctionBundlingUserError(`The function '${name}' must use the ES module syntax. To learn more, visit https://ntl.fyi/esm.`, {
                 functionName: name,
                 runtime: RUNTIME.JAVASCRIPT,
@@ -54,14 +53,12 @@ export const processESM = async ({ basePath, cache, config, esmPaths, featureFla
     }
     const packageJson = await getPackageJsonIfAvailable(dirname(mainFile));
     const nodeSupport = getNodeSupportMatrix(config.nodeVersion);
-    if ((featureFlags.zisi_pure_esm || featureFlags.zisi_functions_api_v2) &&
-        packageJson.type === 'module' &&
-        nodeSupport.esm) {
+    if ((featureFlags.zisi_pure_esm || runtimeAPIVersion === 2) && packageJson.type === 'module' && nodeSupport.esm) {
         return {
             moduleFormat: MODULE_FORMAT.ESM,
         };
     }
-    if (featureFlags.zisi_functions_api_v2) {
+    if (runtimeAPIVersion === 2) {
         throw new FunctionBundlingUserError(`The function '${name}' must use the ES module syntax. To learn more, visit https://ntl.fyi/esm.`, {
             functionName: name,
             runtime: RUNTIME.JAVASCRIPT,

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

@@ -9,7 +9,7 @@ import { processESM } from './es_modules.js';
 // Paths that will be excluded from the tracing process.
 const ignore = ['node_modules/aws-sdk/**'];
 const appearsToBeModuleName = (name) => !name.startsWith('.');
-const bundle = async ({ basePath, cache, config, featureFlags, mainFile, name, pluginsModulesPath, repositoryRoot = basePath, }) => {
+const bundle = async ({ basePath, cache, config, featureFlags, mainFile, name, pluginsModulesPath, repositoryRoot = basePath, runtimeAPIVersion, }) => {
     const { includedFiles = [], includedFilesBasePath } = config;
     const { excludePatterns, paths: includedFilePaths } = await getPathsOfIncludedFiles(includedFiles, includedFilesBasePath || basePath);
     const { moduleFormat, paths: dependencyPaths, rewrites, } = await traceFilesAndTranspile({
@@ -20,6 +20,7 @@ const bundle = async ({ basePath, cache, config, featureFlags, mainFile, name, p
         mainFile,
         pluginsModulesPath,
         name,
+        runtimeAPIVersion,
     });
     const includedPaths = filterExcludedPaths(includedFilePaths, excludePatterns);
     const filteredIncludedPaths = [...filterExcludedPaths(dependencyPaths, excludePatterns), ...includedPaths];
@@ -40,7 +41,7 @@ const ignoreFunction = (path) => {
     const shouldIgnore = ignore.some((expression) => minimatch(path, expression));
     return shouldIgnore;
 };
-const traceFilesAndTranspile = async function ({ basePath, cache, config, featureFlags, mainFile, pluginsModulesPath, name, }) {
+const traceFilesAndTranspile = async function ({ basePath, cache, config, featureFlags, mainFile, pluginsModulesPath, name, runtimeAPIVersion, }) {
     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: 2048,
@@ -85,6 +86,7 @@ const traceFilesAndTranspile = async function ({ basePath, cache, config, featur
         mainFile,
         reasons,
         name,
+        runtimeAPIVersion,
     });
     return {
         moduleFormat,

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

@@ -23,6 +23,7 @@ export type BundleFunction = (args: {
     featureFlags: FeatureFlags;
     pluginsModulesPath?: string;
     repositoryRoot?: string;
+    runtimeAPIVersion: number;
 } & FunctionSource) => Promise<{
     aliases?: Map<string, string>;
     rewrites?: Map<string, string>;

package/dist/runtimes/node/in_source_config/index.d.ts

@@ -1,11 +1,14 @@
 import type { ArgumentPlaceholder, Expression, SpreadElement, JSXNamespacedName } from '@babel/types';
+import type { FeatureFlags } from '../../../feature_flags.js';
 import { InvocationMode } from '../../../function.js';
 export declare const IN_SOURCE_CONFIG_MODULE = "@netlify/functions";
 export type ISCValues = {
     invocationMode?: InvocationMode;
+    runtimeAPIVersion?: number;
     schedule?: string;
 };
-export declare const findISCDeclarationsInPath: (sourcePath: string, functionName: string) => Promise<ISCValues>;
+export declare const findISCDeclarationsInPath: (sourcePath: string, functionName: string, featureFlags: FeatureFlags) => Promise<ISCValues>;
+export declare const findISCDeclarations: (source: string, functionName: string, featureFlags: FeatureFlags) => ISCValues;
 export type ISCHandlerArg = ArgumentPlaceholder | Expression | SpreadElement | JSXNamespacedName;
 export interface ISCExport {
     local: string;

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

@@ -3,9 +3,9 @@ import { FunctionBundlingUserError } from '../../../utils/error.js';
 import { nonNullable } from '../../../utils/non_nullable.js';
 import { RUNTIME } from '../../runtime.js';
 import { createBindingsMethod } from '../parser/bindings.js';
-import { getMainExport } from '../parser/exports.js';
+import { getExports } from '../parser/exports.js';
 import { getImports } from '../parser/imports.js';
-import { safelyParseFile } from '../parser/index.js';
+import { safelyParseSource, safelyReadSource } from '../parser/index.js';
 import { parse as parseSchedule } from './properties/schedule.js';
 export const IN_SOURCE_CONFIG_MODULE = '@netlify/functions';
 const validateScheduleFunction = (functionFound, scheduleFound, functionName) => {
@@ -19,8 +19,15 @@ const validateScheduleFunction = (functionFound, scheduleFound, functionName) =>
 // Parses a JS/TS file and looks for in-source config declarations. It returns
 // an array of all declarations found, with `property` indicating the name of
 // the property and `data` its value.
-export const findISCDeclarationsInPath = async (sourcePath, functionName) => {
-    const ast = await safelyParseFile(sourcePath);
+export const findISCDeclarationsInPath = async (sourcePath, functionName, featureFlags) => {
+    const source = await safelyReadSource(sourcePath);
+    if (source === null) {
+        return {};
+    }
+    return findISCDeclarations(source, functionName, featureFlags);
+};
+export const findISCDeclarations = (source, functionName, featureFlags) => {
+    const ast = safelyParseSource(source, featureFlags);
     if (ast === null) {
         return {};
     }
@@ -29,8 +36,18 @@ export const findISCDeclarationsInPath = async (sourcePath, functionName) => {
     let scheduledFunctionFound = false;
     let scheduleFound = false;
     const getAllBindings = createBindingsMethod(ast.body);
-    const mainExports = getMainExport(ast.body, getAllBindings);
-    const iscExports = mainExports
+    const { configExport, defaultExport, handlerExports } = getExports(ast.body, getAllBindings);
+    const isV2API = handlerExports.length === 0 && defaultExport !== undefined;
+    if (featureFlags.zisi_functions_api_v2 && isV2API) {
+        const config = {
+            runtimeAPIVersion: 2,
+        };
+        if (typeof configExport.schedule === 'string') {
+            config.schedule = configExport.schedule;
+        }
+        return config;
+    }
+    const iscExports = handlerExports
         .map(({ args, local: exportName }) => {
         const matchingImport = imports.find(({ local: importName }) => importName === exportName);
         if (matchingImport === undefined) {

package/dist/runtimes/node/index.js

@@ -12,34 +12,38 @@ import { createAliases as createPluginsModulesPathAliases, getPluginsModulesPath
 import { zipNodeJs } from './utils/zip.js';
 // A proxy for the `getSrcFiles` that calls `getSrcFiles` on the bundler
 const getSrcFilesWithBundler = async (parameters) => {
-    const { config, extension, featureFlags, mainFile, srcDir } = parameters;
+    const { config, extension, featureFlags, mainFile, runtimeAPIVersion, srcDir } = parameters;
     const pluginsModulesPath = await getPluginsModulesPath(srcDir);
     const bundlerName = await getBundlerName({
         config,
         extension,
         featureFlags,
         mainFile,
+        runtimeAPIVersion,
     });
     const bundler = getBundler(bundlerName);
     const result = await bundler.getSrcFiles({ ...parameters, pluginsModulesPath });
     return result.srcFiles;
 };
 const zipFunction = async function ({ archiveFormat, basePath, cache, config = {}, destFolder, extension, featureFlags, filename, mainFile, name, repositoryRoot, runtime, srcDir, srcPath, stat, isInternal, }) {
+    // If the file is a zip, we assume the function is bundled and ready to go.
+    // We simply copy it to the destination path with no further processing.
+    if (extension === '.zip') {
+        const destPath = join(destFolder, filename);
+        await copyFile(srcPath, destPath);
+        return { config, path: destPath };
+    }
+    const inSourceConfig = await findISCDeclarationsInPath(mainFile, name, featureFlags);
+    const runtimeAPIVersion = inSourceConfig.runtimeAPIVersion === 2 ? 2 : 1;
     const pluginsModulesPath = await getPluginsModulesPath(srcDir);
     const bundlerName = await getBundlerName({
         config,
         extension,
         featureFlags,
         mainFile,
+        runtimeAPIVersion,
     });
     const bundler = getBundler(bundlerName);
-    // If the file is a zip, we assume the function is bundled and ready to go.
-    // We simply copy it to the destination path with no further processing.
-    if (extension === '.zip') {
-        const destPath = join(destFolder, filename);
-        await copyFile(srcPath, destPath);
-        return { config, path: destPath };
-    }
     const { aliases = new Map(), cleanupFunction, basePath: finalBasePath, bundlerWarnings, includedFiles, inputs, mainFile: finalMainFile = mainFile, moduleFormat, nativeNodeModules, nodeModulesWithDynamicImports, rewrites, srcFiles, } = await bundler.bundle({
         basePath,
         cache,
@@ -52,11 +56,11 @@ const zipFunction = async function ({ archiveFormat, basePath, cache, config = {
         pluginsModulesPath,
         repositoryRoot,
         runtime,
+        runtimeAPIVersion,
         srcDir,
         srcPath,
         stat,
     });
-    const inSourceConfig = await findISCDeclarationsInPath(mainFile, name);
     createPluginsModulesPathAliases(srcFiles, pluginsModulesPath, aliases, finalBasePath);
     const zipPath = await zipNodeJs({
         aliases,
@@ -70,6 +74,7 @@ const zipFunction = async function ({ archiveFormat, basePath, cache, config = {
         mainFile: finalMainFile,
         moduleFormat,
         rewrites,
+        runtimeAPIVersion,
         srcFiles,
     });
     await cleanupFunction?.();
@@ -77,7 +82,7 @@ const zipFunction = async function ({ archiveFormat, basePath, cache, config = {
     // `stream` helper.
     let { invocationMode } = inSourceConfig;
     // If we're using the V2 API, force the invocation to "stream".
-    if (featureFlags.zisi_functions_api_v2) {
+    if (runtimeAPIVersion === 2) {
         invocationMode = INVOCATION_MODE.Stream;
     }
     return {

package/dist/runtimes/node/parser/exports.d.ts

@@ -1,4 +1,8 @@
-import type { Statement } from '@babel/types';
+import type { ExportDefaultDeclaration, Statement } from '@babel/types';
 import type { ISCExport } from '../in_source_config/index.js';
 import type { BindingMethod } from './bindings.js';
-export declare const getMainExport: (nodes: Statement[], getAllBindings: BindingMethod) => ISCExport[];
+export declare const getExports: (nodes: Statement[], getAllBindings: BindingMethod) => {
+    configExport: Record<string, unknown>;
+    defaultExport: ExportDefaultDeclaration | undefined;
+    handlerExports: ISCExport[];
+};

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

@@ -1,21 +1,33 @@
 import { isModuleExports } from './helpers.js';
-// Finds the main handler export in an AST.
-export const getMainExport = (nodes, getAllBindings) => {
-    let handlerExport = [];
-    nodes.find((node) => {
+// Finds and returns the following types of exports in an AST:
+// 1. Named `handler` function exports
+// 2. Default function export
+// 3. Named `config` object export
+export const getExports = (nodes, getAllBindings) => {
+    const handlerExports = [];
+    let configExport = {};
+    let defaultExport;
+    nodes.forEach((node) => {
         const esmExports = getMainExportFromESM(node, getAllBindings);
         if (esmExports.length !== 0) {
-            handlerExport = esmExports;
-            return true;
+            handlerExports.push(...esmExports);
+            return;
         }
         const cjsExports = getMainExportFromCJS(node);
         if (cjsExports.length !== 0) {
-            handlerExport = cjsExports;
-            return true;
+            handlerExports.push(...cjsExports);
+            return;
+        }
+        if (isDefaultExport(node)) {
+            defaultExport = node;
+            return;
+        }
+        const config = parseConfigExport(node);
+        if (config !== undefined) {
+            configExport = config;
         }
-        return false;
     });
-    return handlerExport;
+    return { configExport, defaultExport, handlerExports };
 };
 // Finds the main handler export in a CJS AST.
 const getMainExportFromCJS = (node) => {
@@ -58,6 +70,50 @@ const isHandlerExport = (node) => {
         ((exported.type === 'Identifier' && exported.name === 'handler') ||
             (exported.type === 'StringLiteral' && exported.value === 'handler')));
 };
+// Returns whether a given node is a default export declaration.
+const isDefaultExport = (node) => node.type === 'ExportDefaultDeclaration';
+// Finds a `config` named export that maps to an object variable declaration,
+// like:
+//
+// export const config = { prop1: "value 1" }
+const parseConfigExport = (node) => {
+    if (node.type === 'ExportNamedDeclaration' &&
+        node.declaration?.type === 'VariableDeclaration' &&
+        node.declaration.declarations[0].type === 'VariableDeclarator' &&
+        node.declaration.declarations[0].id.type === 'Identifier' &&
+        node.declaration.declarations[0].id.name === 'config' &&
+        node.declaration.declarations[0].init?.type === 'ObjectExpression') {
+        return parseObject(node.declaration.declarations[0].init);
+    }
+};
+// Takes an object expression node and returns the object resulting from the
+// subtree. The following types are accepted as values, and any others will
+// be ignored and excluded from the resulting object:
+//
+// - boolean
+// - number
+// - object
+// - string
+const parseObject = (node) => node.properties.reduce((acc, property) => {
+    if (property.type !== 'ObjectProperty' || property.key.type !== 'Identifier') {
+        return acc;
+    }
+    if (property.value.type === 'BooleanLiteral' ||
+        property.value.type === 'NumericLiteral' ||
+        property.value.type === 'StringLiteral') {
+        return {
+            ...acc,
+            [property.key.name]: property.value.value,
+        };
+    }
+    if (property.value.type === 'ObjectExpression') {
+        return {
+            ...acc,
+            [property.key.name]: parseObject(property.value),
+        };
+    }
+    return acc;
+}, {});
 // Tries to resolve the export from a binding (variable)
 // for example `let handler; handler = () => {}; export { handler }` would
 // resolve correctly to the handler function

package/dist/runtimes/node/parser/index.d.ts

@@ -1,9 +1,12 @@
-export declare const parseExpression: ({ basePath, expression: rawExpression, resolveDir, }: {
+import type { FeatureFlags } from '../../../feature_flags.js';
+export declare const parseExpression: ({ basePath, expression: rawExpression, resolveDir, featureFlags, }: {
     basePath: string;
     expression: string;
     resolveDir: string;
+    featureFlags: FeatureFlags;
 }) => {
     includedPathsGlob: string | null | undefined;
     type: string;
 } | undefined;
-export declare const safelyParseFile: (path: string) => Promise<import("@babel/types").Program | null>;
+export declare const safelyParseSource: (source: string, featureFlags: FeatureFlags) => import("@babel/types").Program | null;
+export declare const safelyReadSource: (path: string) => Promise<string | null>;

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

@@ -1,6 +1,7 @@
 import { promises as fs } from 'fs';
 import { join, relative, resolve } from 'path';
-import { parse } from '@babel/parser';
+import { parse as parseOld } from '@babel/parser';
+import { parse as parseLatest } from '@babel/parser_latest';
 import { nonNullable } from '../../../utils/non_nullable.js';
 const GLOB_WILDCARD = '**';
 // Transforms an array of glob nodes into a glob string including an absolute
@@ -44,10 +45,12 @@ const getWildcardFromASTNode = (node) => {
             throw new Error('Expression member not supported');
     }
 };
+const getParser = (featureFlags) => (featureFlags.zisi_use_latest_babel_version ? parseOld : parseLatest);
 // Tries to parse an expression, returning an object with:
 // - `includedPathsGlob`: A glob with the files to be included in the bundle
 // - `type`: The expression type (e.g. "require", "import")
-export const parseExpression = ({ basePath, expression: rawExpression, resolveDir, }) => {
+export const parseExpression = ({ basePath, expression: rawExpression, resolveDir, featureFlags, }) => {
+    const parse = getParser(featureFlags);
     const { program } = parse(rawExpression, {
         sourceType: 'module',
     });
@@ -71,10 +74,10 @@ export const parseExpression = ({ basePath, expression: rawExpression, resolveDi
         }
     }
 };
-// Parses a JS/TS file and returns the resulting AST.
-const parseFile = async (path) => {
-    const code = await fs.readFile(path, 'utf8');
-    const ast = parse(code, {
+// Parses a JS/TS source and returns the resulting AST.
+const parseSource = (source, featureFlags) => {
+    const parse = getParser(featureFlags);
+    const ast = parse(source, {
         plugins: ['typescript'],
         sourceType: 'module',
         // disable tokens, ranges and comments for performance and we do not use them
@@ -84,14 +87,25 @@ const parseFile = async (path) => {
     });
     return ast.program;
 };
+// Parses a JS/TS source and returns the resulting AST. If there is a parsing
+// error, it will get swallowed and `null` will be returned.
+export const safelyParseSource = (source, featureFlags) => {
+    try {
+        return parseSource(source, featureFlags);
+    }
+    catch {
+        return null;
+    }
+};
 // Attempts to parse a JS/TS file at the given path, returning its AST if
 // successful, or `null` if not.
-export const safelyParseFile = async (path) => {
+export const safelyReadSource = async (path) => {
     if (!path) {
         return null;
     }
     try {
-        return await parseFile(path);
+        const source = await fs.readFile(path, 'utf8');
+        return source;
     }
     catch {
         return null;

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

@@ -6,23 +6,26 @@ export interface EntryFile {
     contents: string;
     filename: string;
 }
-export declare const isNamedLikeEntryFile: (file: string, { basePath, featureFlags, filename, }: {
+export declare const isNamedLikeEntryFile: (file: string, { basePath, featureFlags, filename, runtimeAPIVersion, }: {
     basePath: string;
     featureFlags: FeatureFlags;
     filename: string;
+    runtimeAPIVersion: number;
 }) => boolean;
-export declare const conflictsWithEntryFile: (srcFiles: string[], { basePath, extension, featureFlags, filename, mainFile, }: {
+export declare const conflictsWithEntryFile: (srcFiles: string[], { basePath, extension, featureFlags, filename, mainFile, runtimeAPIVersion, }: {
     basePath: string;
     extension: string;
     featureFlags: FeatureFlags;
     filename: string;
     mainFile: string;
+    runtimeAPIVersion: number;
 }) => boolean;
-export declare const getEntryFile: ({ commonPrefix, featureFlags, filename, mainFile, moduleFormat, userNamespace, }: {
+export declare const getEntryFile: ({ commonPrefix, featureFlags, filename, mainFile, moduleFormat, userNamespace, runtimeAPIVersion, }: {
     commonPrefix: string;
     featureFlags: FeatureFlags;
     filename: string;
     mainFile: string;
     moduleFormat: ModuleFormat;
     userNamespace: string;
+    runtimeAPIVersion: number;
 }) => EntryFile;

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

@@ -5,9 +5,9 @@ import { getFileExtensionForFormat, MODULE_FILE_EXTENSION, MODULE_FORMAT, } from
 import { normalizeFilePath } from './normalize_path.js';
 export const ENTRY_FILE_NAME = '___netlify-entry-point';
 export const BOOTSTRAP_FILE_NAME = '___netlify-bootstrap.mjs';
-const getEntryFileContents = (mainPath, moduleFormat, featureFlags) => {
+const getEntryFileContents = (mainPath, moduleFormat, featureFlags, runtimeAPIVersion) => {
     const importPath = `.${mainPath.startsWith('/') ? mainPath : `/${mainPath}`}`;
-    if (featureFlags.zisi_functions_api_v2) {
+    if (runtimeAPIVersion === 2) {
         return [
             `import * as func from '${importPath}'`,
             `import { getLambdaHandler } from './${BOOTSTRAP_FILE_NAME}'`,
@@ -30,13 +30,13 @@ 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, featureFlags, filename, }) => POSSIBLE_LAMBDA_ENTRY_EXTENSIONS.some((extension) => {
-    const entryFilename = getEntryFileName({ extension, featureFlags, filename });
+export const isNamedLikeEntryFile = (file, { basePath, featureFlags, filename, runtimeAPIVersion, }) => POSSIBLE_LAMBDA_ENTRY_EXTENSIONS.some((extension) => {
+    const entryFilename = getEntryFileName({ extension, featureFlags, filename, runtimeAPIVersion });
     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, extension, featureFlags, filename, mainFile, }) => {
+export const conflictsWithEntryFile = (srcFiles, { basePath, extension, featureFlags, filename, mainFile, runtimeAPIVersion, }) => {
     let hasConflict = false;
     srcFiles.forEach((srcFile) => {
         if (srcFile.includes(ENTRY_FILE_NAME)) {
@@ -47,10 +47,12 @@ export const conflictsWithEntryFile = (srcFiles, { basePath, extension, featureF
         }
         // 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) {
+        if (featureFlags.zisi_unique_entry_file || runtimeAPIVersion === 2) {
             return;
         }
-        if (!hasConflict && isNamedLikeEntryFile(srcFile, { basePath, featureFlags, filename }) && srcFile !== mainFile) {
+        if (!hasConflict &&
+            isNamedLikeEntryFile(srcFile, { basePath, featureFlags, filename, runtimeAPIVersion }) &&
+            srcFile !== mainFile) {
             hasConflict = true;
         }
     });
@@ -59,17 +61,17 @@ 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, featureFlags, filename, }) => {
-    if (featureFlags.zisi_unique_entry_file || featureFlags.zisi_functions_api_v2) {
+const getEntryFileName = ({ extension, featureFlags, filename, runtimeAPIVersion, }) => {
+    if (featureFlags.zisi_unique_entry_file || runtimeAPIVersion === 2) {
         return `${ENTRY_FILE_NAME}.mjs`;
     }
     return `${basename(filename, extname(filename))}${extension}`;
 };
-export const getEntryFile = ({ commonPrefix, featureFlags, filename, mainFile, moduleFormat, userNamespace, }) => {
+export const getEntryFile = ({ commonPrefix, featureFlags, filename, mainFile, moduleFormat, userNamespace, runtimeAPIVersion, }) => {
     const mainPath = normalizeFilePath({ commonPrefix, path: mainFile, userNamespace });
     const extension = getFileExtensionForFormat(moduleFormat, featureFlags);
-    const entryFilename = getEntryFileName({ extension, featureFlags, filename });
-    const contents = getEntryFileContents(mainPath, moduleFormat, featureFlags);
+    const entryFilename = getEntryFileName({ extension, featureFlags, filename, runtimeAPIVersion });
+    const contents = getEntryFileContents(mainPath, moduleFormat, featureFlags, runtimeAPIVersion);
     return {
         contents,
         filename: entryFilename,

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

@@ -13,6 +13,7 @@ interface ZipNodeParameters {
     mainFile: string;
     moduleFormat: ModuleFormat;
     rewrites?: Map<string, string>;
+    runtimeAPIVersion: number;
     srcFiles: string[];
 }
 export declare const zipNodeJs: ({ archiveFormat, ...options }: ZipNodeParameters & {

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

@@ -14,7 +14,7 @@ const COPY_FILE_CONCURRENCY = os.cpus().length === 0 ? 2 : os.cpus().length * 2;
 // Sub-directory to place all user-defined files  (i.e. everything other than
 // 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 createDirectory = async function ({ aliases = new Map(), basePath, destFolder, extension, featureFlags, filename, mainFile, moduleFormat, rewrites = new Map(), runtimeAPIVersion, srcFiles, }) {
     const { contents: entryContents, filename: entryFilename } = getEntryFile({
         commonPrefix: basePath,
         featureFlags,
@@ -22,6 +22,7 @@ const createDirectory = async function ({ aliases = new Map(), basePath, destFol
         mainFile,
         moduleFormat,
         userNamespace: DEFAULT_USER_SUBDIRECTORY,
+        runtimeAPIVersion,
     });
     const functionFolder = join(destFolder, basename(filename, extension));
     // Deleting the functions directory in case it exists before creating it.
@@ -45,7 +46,7 @@ const createDirectory = async function ({ aliases = new Map(), basePath, destFol
     }, { concurrency: COPY_FILE_CONCURRENCY });
     return functionFolder;
 };
-const createZipArchive = async function ({ aliases = new Map(), basePath, cache, destFolder, extension, featureFlags, filename, mainFile, moduleFormat, rewrites, srcFiles, }) {
+const createZipArchive = async function ({ aliases = new Map(), basePath, cache, destFolder, extension, featureFlags, filename, mainFile, moduleFormat, rewrites, runtimeAPIVersion, srcFiles, }) {
     const destPath = join(destFolder, `${basename(filename, extension)}.zip`);
     const { archive, output } = startZip(destPath);
     // There is a naming conflict with the entry file if one of the supporting
@@ -57,13 +58,14 @@ const createZipArchive = async function ({ aliases = new Map(), basePath, cache,
         featureFlags,
         filename,
         mainFile,
+        runtimeAPIVersion,
     });
     // 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 = featureFlags.zisi_unique_entry_file ||
-        featureFlags.zisi_functions_api_v2 ||
+        runtimeAPIVersion === 2 ||
         hasEntryFileConflict ||
-        !isNamedLikeEntryFile(mainFile, { basePath, featureFlags, filename });
+        !isNamedLikeEntryFile(mainFile, { basePath, featureFlags, filename, runtimeAPIVersion });
     // 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 : '';
@@ -75,10 +77,11 @@ const createZipArchive = async function ({ aliases = new Map(), basePath, cache,
             moduleFormat,
             userNamespace,
             featureFlags,
+            runtimeAPIVersion,
         });
         addEntryFileToZip(archive, entryFile);
     }
-    if (featureFlags.zisi_functions_api_v2) {
+    if (runtimeAPIVersion === 2) {
         // This is the path to the file that contains all the code for the v2
         // functions API. We add it to the list of source files and create an
         // alias so that it's written as `BOOTSTRAP_FILE_NAME` in the ZIP.

package/dist/runtimes/runtime.d.ts

@@ -27,6 +27,7 @@ export type GetSrcFilesFunction = (args: {
     config: FunctionConfig;
     featureFlags: FeatureFlags;
     repositoryRoot?: string;
+    runtimeAPIVersion: number;
 } & FunctionSource) => Promise<string[]>;
 export interface ZipFunctionResult {
     bundler?: NodeBundlerName;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/zip-it-and-ship-it",
-  "version": "9.5.0",
+  "version": "9.6.0",
   "description": "Zip it and ship it",
   "main": "./dist/main.js",
   "type": "module",
@@ -54,6 +54,7 @@
     "url": "https://github.com/netlify/zip-it-and-ship-it/issues"
   },
   "dependencies": {
+    "@babel/parser_latest": "npm:@babel/parser@7.21.8",
     "@babel/parser": "7.16.8",
     "@netlify/binary-info": "^1.0.0",
     "@netlify/esbuild": "0.14.39",
@@ -88,6 +89,7 @@
   "devDependencies": {
     "@babel/types": "^7.15.6",
     "@netlify/eslint-config-node": "^7.0.1",
+    "@skn0tt/lambda-local": "^2.0.3",
     "@types/archiver": "^5.1.1",
     "@types/glob": "^8.1.0",
     "@types/is-ci": "^3.0.0",
@@ -104,7 +106,6 @@
     "get-stream": "^6.0.0",
     "husky": "^8.0.0",
     "is-ci": "^3.0.1",
-    "lambda-local": "^2.0.3",
     "npm-run-all": "^4.1.5",
     "source-map-support": "^0.5.21",
     "typescript": "^5.0.0",