@netlify/zip-it-and-ship-it 9.15.1 → 9.17.0

package/README.md

@@ -278,11 +278,6 @@ Additionally, the following properties also exist for Node.js functions:
   }
   ```
 
-- `nodeModulesWithDynamicImports`: `Array<string>`
-
-  A list of Node modules that reference other files with a dynamic expression (e.g. `require(someFunction())` as opposed
-  to `require('./some-file')`). This is an array containing the module names.
-
 - `runtimeAPIVersion` `number | undefined`
 
   When a function with the new API will be detected this is set to `2`. Otherwise it is set to `1`. `undefined` is only

package/dist/config.d.ts

@@ -9,7 +9,6 @@ interface FunctionConfig {
     nodeBundler?: NodeBundlerName;
     nodeSourcemap?: boolean;
     nodeVersion?: string;
-    processDynamicNodeImports?: boolean;
     rustTargetDirectory?: string;
     schedule?: string;
     zipGo?: boolean;

package/dist/feature_flags.d.ts

@@ -3,7 +3,6 @@ export declare const defaultFlags: {
     readonly parseWithEsbuild: false;
     readonly traceWithNft: false;
     readonly functions_inherit_build_nodejs_version: false;
-    readonly zisi_log_dynamic_imports: false;
     readonly zisi_pure_esm: false;
     readonly zisi_pure_esm_mjs: false;
     readonly zisi_output_cjs_extension: false;
@@ -16,7 +15,6 @@ export declare const getFlags: (input?: Record<string, boolean>, flags?: {
     readonly parseWithEsbuild: false;
     readonly traceWithNft: false;
     readonly functions_inherit_build_nodejs_version: false;
-    readonly zisi_log_dynamic_imports: false;
     readonly zisi_pure_esm: false;
     readonly zisi_pure_esm_mjs: false;
     readonly zisi_output_cjs_extension: false;

package/dist/feature_flags.js

@@ -8,9 +8,6 @@ export const defaultFlags = {
     traceWithNft: false,
     // Should Lambda functions inherit the build Node.js version
     functions_inherit_build_nodejs_version: false,
-    // Emit a system log for every path that has been included in the bundle due
-    // to the parsing of a dynamic import.
-    zisi_log_dynamic_imports: 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,

package/dist/main.d.ts

@@ -28,13 +28,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_log_dynamic_imports" | "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", 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_log_dynamic_imports" | "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", boolean>> | undefined;
     config?: Config | undefined;
     configFileDirectories?: string[] | undefined;
     parseISC?: boolean | undefined;

package/dist/manifest.d.ts

@@ -1,11 +1,13 @@
 import type { FeatureFlags } from './feature_flags.js';
 import type { InvocationMode } from './function.js';
 import type { FunctionResult } from './utils/format_result.js';
+import type { Route } from './utils/routes.js';
 interface ManifestFunction {
     invocationMode?: InvocationMode;
     mainFile: string;
     name: string;
     path: string;
+    routes?: Route[];
     runtime: string;
     runtimeVersion?: string;
     schedule?: string;

package/dist/manifest.js

@@ -12,16 +12,22 @@ export const createManifest = async ({ featureFlags, functions, path, }) => {
     };
     await fs.writeFile(path, JSON.stringify(payload));
 };
-const formatFunctionForManifest = ({ bundler, displayName, generator, invocationMode, mainFile, name, path, runtime, runtimeVersion, schedule, }, featureFlags) => ({
-    bundler,
-    displayName,
-    generator,
-    invocationMode,
-    mainFile,
-    name,
-    runtimeVersion: featureFlags.functions_inherit_build_nodejs_version ? runtimeVersion : undefined,
-    path: resolve(path),
-    runtime,
-    schedule,
-});
+const formatFunctionForManifest = ({ bundler, displayName, generator, invocationMode, mainFile, name, path, routes, runtime, runtimeVersion, schedule, }, featureFlags) => {
+    const manifestFunction = {
+        bundler,
+        displayName,
+        generator,
+        invocationMode,
+        mainFile,
+        name,
+        runtimeVersion: featureFlags.functions_inherit_build_nodejs_version ? runtimeVersion : undefined,
+        path: resolve(path),
+        runtime,
+        schedule,
+    };
+    if (routes?.length !== 0) {
+        manifestFunction.routes = routes;
+    }
+    return manifestFunction;
+};
 //# sourceMappingURL=manifest.js.map

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

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

@@ -1,15 +1,12 @@
 import type { FunctionConfig } from '../../../../config.js';
 import { FeatureFlags } from '../../../../feature_flags.js';
-import { Logger } from '../../../../utils/logger.js';
 export declare const ESBUILD_LOG_LIMIT = 10;
-export declare const bundleJsFile: ({ additionalModulePaths, basePath, config, externalModules, featureFlags, ignoredModules, logger, mainFile, name, srcDir, srcFile, runtimeAPIVersion, }: {
+export declare const bundleJsFile: ({ additionalModulePaths, config, externalModules, featureFlags, ignoredModules, mainFile, name, srcDir, srcFile, runtimeAPIVersion, }: {
     additionalModulePaths?: string[] | undefined;
-    basePath?: string | undefined;
     config: FunctionConfig;
     externalModules: string[];
     featureFlags: FeatureFlags;
     ignoredModules: string[];
-    logger: Logger;
     mainFile: string;
     name: string;
     srcDir: string;
@@ -22,7 +19,6 @@ export declare const bundleJsFile: ({ additionalModulePaths, basePath, config, e
     inputs: string[];
     moduleFormat: import("../../utils/module_format.js").ModuleFormat;
     nativeNodeModules: {};
-    nodeModulesWithDynamicImports: string[];
     outputExtension: import("../../utils/module_format.js").ModuleFileExtension;
-    warnings: import("@netlify/esbuild").Message[];
+    warnings: import("esbuild").Message[];
 }>;

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

@@ -1,5 +1,6 @@
+import { readFile, writeFile } from 'fs/promises';
 import { basename, dirname, extname, resolve, join } from 'path';
-import { build } from '@netlify/esbuild';
+import { build } from 'esbuild';
 import { tmpName } from 'tmp-promise';
 import { FunctionBundlingUserError } from '../../../../utils/error.js';
 import { getPathWithExtension, safeUnlink } from '../../../../utils/fs.js';
@@ -7,7 +8,6 @@ import { RUNTIME } from '../../../runtime.js';
 import { getFileExtensionForFormat, MODULE_FORMAT } from '../../utils/module_format.js';
 import { NODE_BUNDLER } from '../types.js';
 import { getBundlerTarget, getModuleFormat } from './bundler_target.js';
-import { getDynamicImportsPlugin } from './plugin_dynamic_imports.js';
 import { getNativeModulesPlugin } from './plugin_native_modules.js';
 import { getNodeBuiltinPlugin } from './plugin_node_builtin.js';
 // Maximum number of log messages that an esbuild instance will produce. This
@@ -17,35 +17,33 @@ export const ESBUILD_LOG_LIMIT = 10;
 // When resolving imports with no extension (e.g. require('./foo')), these are
 // the extensions that esbuild will look for, in this order.
 const RESOLVE_EXTENSIONS = ['.js', '.jsx', '.mjs', '.cjs', '.ts', '.tsx', '.mts', '.cts', '.json'];
-export const bundleJsFile = async function ({ additionalModulePaths, basePath, config, externalModules = [], featureFlags, ignoredModules = [], logger, mainFile, name, srcDir, srcFile, runtimeAPIVersion, }) {
+/**
+ * Our own `includedFiles` syntax is slightly different from what esbuild expects as `externals`.
+ *
+ * Turns !node_modules/test/** into ./node_modules/test/*
+ */
+const includedFilesToEsbuildExternals = (includedFiles) => includedFiles
+    // only keep negated patterns
+    .filter((pattern) => pattern.startsWith('!'))
+    // remove the !
+    .map((pattern) => pattern.slice(1))
+    // esbuild expects a relative path for local files
+    .map((pattern) => `./${pattern}`)
+    // esbuild doesn't like **
+    .map((pattern) => pattern.replace(/\*\*/g, '*'));
+export const bundleJsFile = async function ({ additionalModulePaths, config, externalModules = [], featureFlags, ignoredModules = [], mainFile, name, srcDir, srcFile, runtimeAPIVersion, }) {
     // We use a temporary directory as the destination for esbuild files to avoid
     // any naming conflicts with files generated by other functions.
     const targetDirectory = await tmpName();
+    // files matching negated patterns, like `!lang/en.*`, should be excluded from the bundle
+    const excludedFiles = includedFilesToEsbuildExternals(config.includedFiles ?? []);
     // De-duping external and ignored modules.
-    const external = [...new Set([...externalModules, ...ignoredModules])];
+    const external = [...new Set([...externalModules, ...ignoredModules, ...excludedFiles])];
     // To be populated by the native modules plugin with the names, versions and
     // paths of any Node modules with native dependencies.
     const nativeNodeModules = {};
-    // To be populated by the dynamic imports plugin with the names of the Node
-    // modules that include imports with dynamic expressions.
-    const nodeModulesWithDynamicImports = new Set();
-    // To be populated by the dynamic imports plugin with any paths (in a glob
-    // format) to be included in the bundle in order to make a dynamic import
-    // work at runtime.
-    const dynamicImportsIncludedPaths = new Set();
     // The list of esbuild plugins to enable for this build.
-    const plugins = [
-        getNodeBuiltinPlugin(),
-        getNativeModulesPlugin(nativeNodeModules),
-        getDynamicImportsPlugin({
-            basePath,
-            includedPaths: dynamicImportsIncludedPaths,
-            logger: featureFlags.zisi_log_dynamic_imports ? logger : undefined,
-            moduleNames: nodeModulesWithDynamicImports,
-            processImports: config.processDynamicNodeImports !== false,
-            srcDir,
-        }),
-    ];
+    const plugins = [getNodeBuiltinPlugin(), getNativeModulesPlugin(nativeNodeModules)];
     // The version of ECMAScript to use as the build target. This will determine
     // whether certain features are transpiled down or left untransformed.
     const nodeTarget = getBundlerTarget(config.nodeVersion);
@@ -101,9 +99,31 @@ let require=___nfyCreateRequire(import.meta.url);
             srcFile,
             outputExtension,
         });
+        // workaround for https://github.com/evanw/esbuild/issues/3328
+        await Promise.all(Object.keys(metafile.outputs)
+            .filter((filename) => filename.endsWith('.js'))
+            .map(async (filename) => {
+            const content = await readFile(filename, { encoding: 'utf-8' });
+            const updated = content.replace(`
+var __glob = (map) => (path) => {
+  var fn = map[path];
+  if (fn)
+    return fn();
+  throw new Error("Module not found in bundle: " + path);
+};
+      `.trim(), `
+var __glob = (map) => (path) => {
+  var fn = map[path] || map[path + '.js'] || map[path + '.json'] || map[path + '/index.js'] || map[path + '/index.json'];
+  if (fn)
+    return fn();
+  throw new Error("Module not found in bundle: " + path);
+};
+            `.trim());
+            await writeFile(filename, updated, { encoding: 'utf-8' });
+        }));
         const inputs = Object.keys(metafile.inputs).map((path) => resolve(path));
         const cleanTempFiles = getCleanupFunction([...bundlePaths.keys()]);
-        const additionalPaths = [...dynamicImportsIncludedPaths, ...includedFilesFromModuleDetection];
+        const additionalPaths = includedFilesFromModuleDetection;
         return {
             additionalPaths,
             bundlePaths,
@@ -111,7 +131,6 @@ let require=___nfyCreateRequire(import.meta.url);
             inputs,
             moduleFormat,
             nativeNodeModules,
-            nodeModulesWithDynamicImports: [...nodeModulesWithDynamicImports],
             outputExtension,
             warnings,
         };

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

@@ -26,16 +26,14 @@ const getExternalAndIgnoredModules = async ({ config, srcDir }) => {
     const ignoredModules = [...ignoredModulesFromConfig, ...ignoredModulesFromSpecialCases];
     return { externalModules, ignoredModules };
 };
-const bundle = async ({ basePath, config = {}, extension, featureFlags, filename, logger, mainFile, name, pluginsModulesPath, repositoryRoot, runtime, srcDir, srcPath, stat, runtimeAPIVersion, }) => {
+const bundle = async ({ basePath, config = {}, extension, featureFlags, filename, mainFile, name, pluginsModulesPath, repositoryRoot, runtime, srcDir, srcPath, stat, runtimeAPIVersion, }) => {
     const { externalModules, ignoredModules } = await getExternalAndIgnoredModules({ config, srcDir });
-    const { additionalPaths, bundlePaths, cleanTempFiles, inputs, moduleFormat, nativeNodeModules = {}, nodeModulesWithDynamicImports, outputExtension, warnings, } = await bundleJsFile({
+    const { additionalPaths, bundlePaths, cleanTempFiles, inputs, moduleFormat, nativeNodeModules = {}, outputExtension, warnings, } = await bundleJsFile({
         additionalModulePaths: pluginsModulesPath ? [pluginsModulesPath] : [],
-        basePath,
         config,
         externalModules,
         featureFlags,
         ignoredModules,
-        logger,
         mainFile,
         name,
         srcDir,
@@ -83,7 +81,6 @@ const bundle = async ({ basePath, config = {}, extension, featureFlags, filename
         mainFile: normalizedMainFile,
         moduleFormat,
         nativeNodeModules,
-        nodeModulesWithDynamicImports,
         srcFiles: [...supportingSrcFiles, ...bundlePaths.keys()],
     };
 };

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

@@ -1,3 +1,3 @@
-import type { Plugin } from '@netlify/esbuild';
+import type { Plugin } from 'esbuild';
 import type { NativeNodeModules } from '../types.js';
 export declare const getNativeModulesPlugin: (externalizedModules: NativeNodeModules) => Plugin;

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

@@ -1,2 +1,2 @@
-import type { Plugin } from '@netlify/esbuild';
+import type { Plugin } from 'esbuild';
 export declare const getNodeBuiltinPlugin: () => Plugin;

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

@@ -1,4 +1,4 @@
-import { build } from '@netlify/esbuild';
+import { build } from 'esbuild';
 import { FunctionBundlingUserError } from '../../../../utils/error.js';
 import { RUNTIME } from '../../../runtime.js';
 import { getBundlerTarget } from '../esbuild/bundler_target.js';

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

@@ -1,4 +1,4 @@
-import type { Message } from '@netlify/esbuild';
+import type { Message } from 'esbuild';
 import type { FunctionConfig } from '../../../config.js';
 import type { FeatureFlags } from '../../../feature_flags.js';
 import type { FunctionSource } from '../../../function.js';
@@ -37,7 +37,6 @@ export type BundleFunction = (args: {
     mainFile: string;
     moduleFormat: ModuleFormat;
     nativeNodeModules?: NativeNodeModules;
-    nodeModulesWithDynamicImports?: string[];
     srcFiles: string[];
 }>;
 export type GetSrcFilesFunction = (args: {

package/dist/runtimes/node/bundlers/zisi/list_imports.js

@@ -1,4 +1,4 @@
-import * as esbuild from '@netlify/esbuild';
+import * as esbuild from 'esbuild';
 import isBuiltinModule from 'is-builtin-module';
 import precinct from 'precinct';
 import { tmpName } from 'tmp-promise';

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

@@ -2,11 +2,14 @@ import type { ArgumentPlaceholder, Expression, SpreadElement, JSXNamespacedName
 import type { FeatureFlags } from '../../../feature_flags.js';
 import { InvocationMode } from '../../../function.js';
 import { Logger } from '../../../utils/logger.js';
+import { Route } from '../../../utils/routes.js';
 export declare const IN_SOURCE_CONFIG_MODULE = "@netlify/functions";
 export type ISCValues = {
     invocationMode?: InvocationMode;
+    routes?: Route[];
     runtimeAPIVersion?: number;
     schedule?: string;
+    methods?: string[];
 };
 interface FindISCDeclarationsOptions {
     functionName: string;
@@ -16,8 +19,13 @@ interface FindISCDeclarationsOptions {
 export declare const findISCDeclarationsInPath: (sourcePath: string, { functionName, featureFlags, logger }: FindISCDeclarationsOptions) => Promise<ISCValues>;
 export declare const findISCDeclarations: (source: string, { functionName, featureFlags, logger }: FindISCDeclarationsOptions) => ISCValues;
 export type ISCHandlerArg = ArgumentPlaceholder | Expression | SpreadElement | JSXNamespacedName;
-export interface ISCExport {
-    local: string;
+export type ISCExportWithCallExpression = {
+    type: 'call-expression';
     args: ISCHandlerArg[];
-}
+    local: string;
+};
+export type ISCExportOther = {
+    type: 'other';
+};
+export type ISCExport = ISCExportWithCallExpression | ISCExportOther;
 export {};

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

@@ -1,7 +1,9 @@
 import { INVOCATION_MODE } from '../../../function.js';
 import { FunctionBundlingUserError } from '../../../utils/error.js';
 import { nonNullable } from '../../../utils/non_nullable.js';
+import { getRoutesFromPath } from '../../../utils/routes.js';
 import { RUNTIME } from '../../runtime.js';
+import { NODE_BUNDLER } from '../bundlers/types.js';
 import { createBindingsMethod } from '../parser/bindings.js';
 import { getExports } from '../parser/exports.js';
 import { getImports } from '../parser/imports.js';
@@ -26,6 +28,23 @@ export const findISCDeclarationsInPath = async (sourcePath, { functionName, feat
     }
     return findISCDeclarations(source, { functionName, featureFlags, logger });
 };
+/**
+ * Normalizes method names into arrays of uppercase strings.
+ * (e.g. "get" becomes ["GET"])
+ */
+const normalizeMethods = (input, name) => {
+    const methods = Array.isArray(input) ? input : [input];
+    return methods.map((method) => {
+        if (typeof method !== 'string') {
+            throw new FunctionBundlingUserError(`Could not parse method declaration of function '${name}'. Expecting HTTP Method, got ${method}`, {
+                functionName: name,
+                runtime: RUNTIME.JAVASCRIPT,
+                bundler: NODE_BUNDLER.ESBUILD,
+            });
+        }
+        return method.toUpperCase();
+    });
+};
 export const findISCDeclarations = (source, { functionName, featureFlags, logger }) => {
     const ast = safelyParseSource(source);
     if (ast === null) {
@@ -46,10 +65,20 @@ export const findISCDeclarations = (source, { functionName, featureFlags, logger
         if (typeof configExport.schedule === 'string') {
             config.schedule = configExport.schedule;
         }
+        if (configExport.method !== undefined) {
+            config.methods = normalizeMethods(configExport.method, functionName);
+        }
+        config.routes = getRoutesFromPath(configExport.path, functionName, config.methods ?? []);
         return config;
     }
     const iscExports = handlerExports
-        .map(({ args, local: exportName }) => {
+        .map((node) => {
+        // We're only interested in exports with call expressions, since that's
+        // the pattern we use for the wrapper functions.
+        if (node.type !== 'call-expression') {
+            return null;
+        }
+        const { args, local: exportName } = node;
         const matchingImport = imports.find(({ local: importName }) => importName === exportName);
         if (matchingImport === undefined) {
             return null;

package/dist/runtimes/node/index.js

@@ -44,7 +44,7 @@ const zipFunction = async function ({ archiveFormat, basePath, cache, config = {
         runtimeAPIVersion,
     });
     const bundler = getBundler(bundlerName);
-    const { aliases = new Map(), cleanupFunction, basePath: finalBasePath, bundlerWarnings, includedFiles, inputs, mainFile: finalMainFile = mainFile, moduleFormat, nativeNodeModules, nodeModulesWithDynamicImports, rewrites = new Map(), srcFiles, } = await bundler.bundle({
+    const { aliases = new Map(), cleanupFunction, basePath: finalBasePath, bundlerWarnings, includedFiles, inputs, mainFile: finalMainFile = mainFile, moduleFormat, nativeNodeModules, rewrites = new Map(), srcFiles, } = await bundler.bundle({
         basePath,
         cache,
         config,
@@ -100,7 +100,6 @@ const zipFunction = async function ({ archiveFormat, basePath, cache, config = {
         inSourceConfig,
         invocationMode,
         nativeNodeModules,
-        nodeModulesWithDynamicImports,
         path: zipPath.path,
         runtimeVersion: runtimeAPIVersion === 2 ? getNodeRuntimeForV2(config.nodeVersion) : getNodeRuntime(config.nodeVersion),
     };

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

@@ -94,6 +94,7 @@ const parseConfigExport = (node) => {
 // - number
 // - object
 // - string
+// - array of strings
 const parseObject = (node) => node.properties.reduce((acc, property) => {
     if (property.type !== 'ObjectProperty' || property.key.type !== 'Identifier') {
         return acc;
@@ -106,6 +107,12 @@ const parseObject = (node) => node.properties.reduce((acc, property) => {
             [property.key.name]: property.value.value,
         };
     }
+    if (property.value.type === 'ArrayExpression') {
+        return {
+            ...acc,
+            [property.key.name]: property.value.elements.flatMap((element) => element?.type === 'StringLiteral' ? [element.value] : []),
+        };
+    }
     if (property.value.type === 'ObjectExpression') {
         return {
             ...acc,
@@ -127,16 +134,20 @@ const getExportsFromBindings = (specifiers, getAllBindings) => {
     return exports;
 };
 const getExportsFromExpression = (node) => {
-    // We're only interested in expressions representing function calls, because
-    // the ISC patterns we implement at the moment are all helper functions.
-    if (node?.type !== 'CallExpression') {
-        return [];
-    }
-    const { arguments: args, callee } = node;
-    if (callee.type !== 'Identifier') {
-        return [];
+    switch (node?.type) {
+        case 'CallExpression': {
+            const { arguments: args, callee } = node;
+            if (callee.type !== 'Identifier') {
+                return [];
+            }
+            return [{ args, local: callee.name, type: 'call-expression' }];
+        }
+        default: {
+            if (node !== undefined) {
+                return [{ type: 'other' }];
+            }
+            return [];
+        }
     }
-    const exports = [{ local: callee.name, args }];
-    return exports;
 };
 //# sourceMappingURL=exports.js.map

package/dist/runtimes/runtime.d.ts

@@ -42,7 +42,6 @@ export interface ZipFunctionResult {
     inSourceConfig?: ISCValues;
     invocationMode?: InvocationMode;
     nativeNodeModules?: object;
-    nodeModulesWithDynamicImports?: string[];
     path: string;
     runtimeVersion?: string;
     entryFilename: string;

package/dist/utils/format_result.d.ts

@@ -1,6 +1,8 @@
 import { FunctionArchive } from '../function.js';
 import { RuntimeName } from '../runtimes/runtime.js';
+import type { Route } from './routes.js';
 export type FunctionResult = Omit<FunctionArchive, 'runtime'> & {
+    routes?: Route[];
     runtime: RuntimeName;
     schedule?: string;
     runtimeAPIVersion?: number;

package/dist/utils/format_result.js

@@ -4,6 +4,7 @@ export const formatZipResult = (archive) => {
     const functionResult = {
         ...archive,
         inSourceConfig: undefined,
+        routes: archive.inSourceConfig?.routes,
         runtime: archive.runtime.name,
         schedule: archive.inSourceConfig?.schedule ?? archive?.config?.schedule,
         runtimeAPIVersion: archive.inSourceConfig?.runtimeAPIVersion,

package/dist/utils/routes.d.ts

@@ -0,0 +1,9 @@
+export type Route = {
+    pattern: string;
+    methods: string[];
+} & ({
+    literal: string;
+} | {
+    expression: string;
+});
+export declare const getRoutesFromPath: (path: unknown, functionName: string, methods: string[]) => Route[];

package/dist/utils/routes.js

@@ -0,0 +1,49 @@
+import { RUNTIME } from '../runtimes/runtime.js';
+import { FunctionBundlingUserError } from './error.js';
+import { ExtendedURLPattern } from './urlpattern.js';
+// Based on https://developer.mozilla.org/en-US/docs/Web/API/URL_Pattern_API.
+const isExpression = (part) => part.includes('*') || part.startsWith(':') || part.includes('{') || part.includes('[') || part.includes('(');
+// Detects whether a path can be represented as a literal or whether it needs
+// a regular expression.
+const isPathLiteral = (path) => {
+    const parts = path.split('/');
+    return parts.every((part) => !isExpression(part));
+};
+export const getRoutesFromPath = (path, functionName, methods) => {
+    if (!path) {
+        return [];
+    }
+    if (typeof path !== 'string') {
+        throw new FunctionBundlingUserError(`'path' property must be a string, found '${typeof path}'`, {
+            functionName,
+            runtime: RUNTIME.JAVASCRIPT,
+        });
+    }
+    if (!path.startsWith('/')) {
+        throw new FunctionBundlingUserError(`'path' property must start with a '/'`, {
+            functionName,
+            runtime: RUNTIME.JAVASCRIPT,
+        });
+    }
+    if (isPathLiteral(path)) {
+        return [{ pattern: path, literal: path, methods }];
+    }
+    try {
+        const pattern = new ExtendedURLPattern({ pathname: path });
+        // Removing the `^` and `$` delimiters because we'll need to modify what's
+        // between them.
+        const regex = pattern.regexp.pathname.source.slice(1, -1);
+        // Wrapping the expression source with `^` and `$`. Also, adding an optional
+        // trailing slash, so that a declaration of `path: "/foo"` matches requests
+        // for both `/foo` and `/foo/`.
+        const normalizedRegex = `^${regex}\\/?$`;
+        return [{ pattern: path, expression: normalizedRegex, methods }];
+    }
+    catch {
+        throw new FunctionBundlingUserError(`'${path}' is not a valid path according to the URLPattern specification`, {
+            functionName,
+            runtime: RUNTIME.JAVASCRIPT,
+        });
+    }
+};
+//# sourceMappingURL=routes.js.map

package/dist/utils/urlpattern.d.ts

@@ -0,0 +1,4 @@
+import { URLPattern } from 'urlpattern-polyfill';
+export declare class ExtendedURLPattern extends URLPattern {
+    regexp: Record<string, RegExp>;
+}

package/dist/utils/urlpattern.js

@@ -0,0 +1,4 @@
+import { URLPattern } from 'urlpattern-polyfill';
+export class ExtendedURLPattern extends URLPattern {
+}
+//# sourceMappingURL=urlpattern.js.map

package/dist/zip.d.ts

@@ -20,6 +20,7 @@ export type ZipFunctionsOptions = ZipFunctionOptions & {
     internalSrcFolder?: string;
 };
 export declare const zipFunctions: (relativeSrcFolders: string | string[], destFolder: string, { archiveFormat, basePath, config, configFileDirectories, featureFlags: inputFeatureFlags, manifest, parallelLimit, repositoryRoot, systemLog, debug, internalSrcFolder, }?: ZipFunctionsOptions) => Promise<(Omit<import("./function.js").FunctionArchive, "runtime"> & {
+    routes?: import("./utils/routes.js").Route[] | undefined;
     runtime: import("./main.js").RuntimeName;
     schedule?: string | undefined;
     runtimeAPIVersion?: number | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/zip-it-and-ship-it",
-  "version": "9.15.1",
+  "version": "9.17.0",
   "description": "Zip it and ship it",
   "main": "./dist/main.js",
   "type": "module",
@@ -56,13 +56,13 @@
   "dependencies": {
     "@babel/parser": "^7.22.5",
     "@netlify/binary-info": "^1.0.0",
-    "@netlify/esbuild": "0.14.39-1",
-    "@netlify/serverless-functions-api": "^1.6.0",
+    "@netlify/serverless-functions-api": "^1.7.3",
     "@vercel/nft": "^0.23.0",
     "archiver": "^5.3.0",
     "common-path-prefix": "^3.0.0",
     "cp-file": "^10.0.0",
     "es-module-lexer": "^1.0.0",
+    "esbuild": "0.19.2",
     "execa": "^6.0.0",
     "filter-obj": "^5.0.0",
     "find-up": "^6.0.0",
@@ -84,23 +84,26 @@
     "tmp-promise": "^3.0.2",
     "toml": "^3.0.0",
     "unixify": "^1.0.0",
+    "urlpattern-polyfill": "8.0.2",
     "yargs": "^17.0.0"
   },
   "devDependencies": {
-    "@babel/types": "7.22.5",
+    "@babel/types": "7.22.11",
     "@netlify/eslint-config-node": "7.0.1",
     "@skn0tt/lambda-local": "2.0.3",
     "@types/archiver": "5.3.2",
     "@types/glob": "8.1.0",
     "@types/is-ci": "3.0.0",
-    "@types/node": "14.18.54",
+    "@types/node": "14.18.56",
     "@types/normalize-path": "3.0.0",
     "@types/resolve": "1.20.2",
     "@types/semver": "7.5.0",
     "@types/tmp": "0.2.3",
     "@types/unixify": "1.0.0",
     "@types/yargs": "17.0.24",
-    "@vitest/coverage-v8": "0.33.0",
+    "@vitest/coverage-v8": "0.34.3",
+    "browserslist": "4.21.10",
+    "cardinal": "2.1.1",
     "cpy": "9.0.1",
     "deepmerge": "4.3.1",
     "get-stream": "6.0.1",
@@ -108,8 +111,8 @@
     "is-ci": "3.0.1",
     "npm-run-all": "4.1.5",
     "source-map-support": "0.5.21",
-    "typescript": "5.1.6",
-    "vitest": "0.33.0"
+    "typescript": "5.2.2",
+    "vitest": "0.34.3"
   },
   "engines": {
     "node": "^14.18.0 || >=16.0.0"

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

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

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

@@ -1,95 +0,0 @@
-import { basename, join, relative } from 'path';
-import { findUp, findUpStop, pathExists } from 'find-up';
-import normalizePath from 'normalize-path';
-import { parseExpression } from '../../parser/index.js';
-import { readPackageJson } from '../../utils/package_json.js';
-// This plugin intercepts module imports using dynamic expressions and does a
-// couple of things with them. First of all, it figures out whether the call
-// is being made from within a Node module, and if so it adds the name of the
-// module to `moduleNames`, so that we can warn the user of potential runtime
-// 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, logger, moduleNames, processImports, srcDir, }) => ({
-    name: 'dynamic-imports',
-    setup(build) {
-        const cache = new Map();
-        build.onDynamicImport({ filter: /.*/ }, async (args) => {
-            const { expression, resolveDir } = args;
-            // Don't attempt to parse the expression if the base path isn't defined,
-            // since we won't be able to generate the globs for the included paths.
-            // 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 }) || {};
-                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`.
-                    includedPaths.add(includedPathsGlob);
-                    logger?.system(`Functions bundling processed dynamic import with expression: ${expression}`);
-                    // Create the shim that will handle the import at runtime.
-                    const contents = getShimContents({ expressionType, resolveDir, srcDir });
-                    // This is the only branch where we actually solve a dynamic import.
-                    // eslint-disable-next-line max-depth
-                    if (contents) {
-                        return {
-                            contents,
-                        };
-                    }
-                }
-            }
-            // If we're here, it means we weren't able to solve the dynamic import.
-            // We add it to the list of modules with dynamic imports, which allows
-            // consumers like Netlify Build or CLI to advise users on how to proceed.
-            await registerModuleWithDynamicImports({ cache, moduleNames, resolveDir, srcDir });
-        });
-    },
-});
-const getPackageName = async ({ resolveDir, srcDir }) => {
-    const packageJsonPath = await findUp(async (directory) => {
-        // We stop traversing if we're about to leave the boundaries of the
-        // function directory or any node_modules directory.
-        if (directory === srcDir || basename(directory) === 'node_modules') {
-            return findUpStop;
-        }
-        const path = join(directory, 'package.json');
-        const hasPackageJson = await pathExists(path);
-        return hasPackageJson ? path : undefined;
-    }, { cwd: resolveDir });
-    if (packageJsonPath !== undefined) {
-        const { name } = await readPackageJson(packageJsonPath);
-        return name;
-    }
-};
-const getPackageNameCached = ({ cache, resolveDir, srcDir, }) => {
-    let result = cache.get(resolveDir);
-    if (result === undefined) {
-        result = getPackageName({ resolveDir, srcDir });
-        cache.set(resolveDir, result);
-    }
-    return result;
-};
-const getShimContents = ({ expressionType, resolveDir, srcDir, }) => {
-    // The shim needs to modify the path of the import, since originally it was
-    // relative to wherever the importer sat in the file tree (i.e. anywhere in
-    // the user space or inside `node_modules`), but at runtime paths must be
-    // relative to the main bundle file, since esbuild will flatten everything
-    // into a single file.
-    const relativeResolveDir = relative(srcDir, resolveDir);
-    const requireArg = relativeResolveDir ? `\`./${normalizePath(relativeResolveDir)}/$\{args}\`` : 'args';
-    if (expressionType === 'require') {
-        return `module.exports = args => require(${requireArg})`;
-    }
-};
-const registerModuleWithDynamicImports = async ({ cache, moduleNames, resolveDir, srcDir, }) => {
-    try {
-        const packageName = await getPackageNameCached({ cache, resolveDir, srcDir });
-        if (packageName !== undefined) {
-            moduleNames.add(packageName);
-        }
-    }
-    catch {
-        // no-op
-    }
-};
-//# sourceMappingURL=plugin_dynamic_imports.js.map