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

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/node/in_source_config/index.d.ts

@@ -2,9 +2,11 @@ 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;
 };
@@ -16,8 +18,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,6 +1,7 @@
 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 { createBindingsMethod } from '../parser/bindings.js';
 import { getExports } from '../parser/exports.js';
@@ -40,6 +41,7 @@ export const findISCDeclarations = (source, { functionName, featureFlags, logger
     const isV2API = handlerExports.length === 0 && defaultExport !== undefined;
     if (featureFlags.zisi_functions_api_v2 && isV2API) {
         const config = {
+            routes: getRoutesFromPath(configExport.path, functionName),
             runtimeAPIVersion: 2,
         };
         logger.system('detected v2 function');
@@ -49,7 +51,13 @@ export const findISCDeclarations = (source, { functionName, featureFlags, logger
         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/parser/exports.js

@@ -127,16 +127,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/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,8 @@
+export type Route = {
+    pattern: string;
+} & ({
+    literal: string;
+} | {
+    expression: string;
+});
+export declare const getRoutesFromPath: (path: unknown, functionName: 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) => {
+    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 }];
+    }
+    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 }];
+    }
+    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.16.0",
   "description": "Zip it and ship it",
   "main": "./dist/main.js",
   "type": "module",
@@ -84,10 +84,11 @@
     "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.10",
     "@netlify/eslint-config-node": "7.0.1",
     "@skn0tt/lambda-local": "2.0.3",
     "@types/archiver": "5.3.2",
@@ -100,7 +101,7 @@
     "@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.1",
     "cpy": "9.0.1",
     "deepmerge": "4.3.1",
     "get-stream": "6.0.1",
@@ -109,7 +110,7 @@
     "npm-run-all": "4.1.5",
     "source-map-support": "0.5.21",
     "typescript": "5.1.6",
-    "vitest": "0.33.0"
+    "vitest": "0.34.1"
   },
   "engines": {
     "node": "^14.18.0 || >=16.0.0"