@netlify/zip-it-and-ship-it 14.6.0 → 14.7.0

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

@@ -11,7 +11,7 @@ import { FunctionBundlingUserError } from '../../../utils/error.js';
 import { getRoutes } from '../../../utils/routes.js';
 import { RUNTIME } from '../../runtime.js';
 import { createBindingsMethod } from '../parser/bindings.js';
-import { traverseNodes } from '../parser/exports.js';
+import { parseObject, traverseNodes } from '../parser/exports.js';
 import { getImports } from '../parser/imports.js';
 import { safelyParseSource, safelyReadSource } from '../parser/index.js';
 import { eventHandlers } from '@netlify/serverless-functions-api';
@@ -59,20 +59,39 @@ export const inSourceConfig = functionConfigShape
     path: ['vcpu'],
 });
 /**
- * Extracts event subscription slugs from the default export expression,
- * if it's an object whose property names match known event handlers.
+ * Resolves the default export expression to an ObjectExpression if possible,
+ * following identifier bindings when needed.
  */
-const getEventSubscriptions = (expression, getAllBindings) => {
-    let objectExpression;
-    if (expression?.type === 'ObjectExpression') {
-        objectExpression = expression;
+const resolveObjectExpression = (expression, getAllBindings) => {
+    // Unwrap TS type assertions so `{...} satisfies T` and `{...} as T` are
+    // treated the same as the bare object literal.
+    const unwrapped = expression?.type === 'TSSatisfiesExpression' ||
+        expression?.type === 'TSAsExpression' ||
+        expression?.type === 'TSTypeAssertion'
+        ? expression.expression
+        : expression;
+    if (unwrapped?.type === 'ObjectExpression') {
+        return unwrapped;
     }
-    else if (expression?.type === 'Identifier') {
-        const binding = getAllBindings().get(expression.name);
+    if (unwrapped?.type === 'Identifier') {
+        let binding = getAllBindings().get(unwrapped.name);
+        if (binding?.type === 'TSSatisfiesExpression' ||
+            binding?.type === 'TSAsExpression' ||
+            binding?.type === 'TSTypeAssertion') {
+            binding = binding.expression;
+        }
         if (binding?.type === 'ObjectExpression') {
-            objectExpression = binding;
+            return binding;
         }
     }
+    return undefined;
+};
+/**
+ * Extracts event subscription slugs from the default export expression,
+ * if it's an object whose property names match known event handlers.
+ */
+const getEventSubscriptions = (expression, getAllBindings) => {
+    const objectExpression = resolveObjectExpression(expression, getAllBindings);
     if (!objectExpression) {
         return [];
     }
@@ -89,6 +108,34 @@ const getEventSubscriptions = (expression, getAllBindings) => {
     }
     return events;
 };
+/**
+ * Extracts a `config` property from the default export object expression,
+ * returning it as a plain object. This supports patterns like:
+ *
+ * ```js
+ * export default {
+ *   fetch() { ... },
+ *   config: { path: "/hello" }
+ * }
+ * ```
+ */
+const getConfigFromDefaultExport = (expression, getAllBindings) => {
+    const objectExpression = resolveObjectExpression(expression, getAllBindings);
+    if (!objectExpression) {
+        return undefined;
+    }
+    for (const property of objectExpression.properties) {
+        if (property.type !== 'ObjectProperty' || property.value.type !== 'ObjectExpression') {
+            continue;
+        }
+        const isConfigKey = (property.key.type === 'Identifier' && property.key.name === 'config') ||
+            (property.key.type === 'StringLiteral' && property.key.value === 'config');
+        if (isConfigKey) {
+            return parseObject(property.value);
+        }
+    }
+    return undefined;
+};
 const validateScheduleFunction = (functionFound, scheduleFound, functionName) => {
     if (!functionFound) {
         throw new FunctionBundlingUserError("The `schedule` helper was imported but we couldn't find any usages. If you meant to schedule a function, please check that `schedule` is invoked and `handler` correctly exported.", { functionName, runtime: RUNTIME.JAVASCRIPT });
@@ -139,7 +186,12 @@ export const parseSource = (source, { functionName }) => {
         if (eventSubscriptions.length > 0) {
             result.eventSubscriptions = eventSubscriptions;
         }
-        const { data, error, success } = inSourceConfig.safeParse(configExport);
+        // A named `export const config` always wins (even if empty); we fall back
+        // to the `config` property of the default export object only when no
+        // named export exists.
+        const inlineConfig = getConfigFromDefaultExport(defaultExportExpression, getAllBindings);
+        const mergedConfigExport = configExport ?? inlineConfig ?? {};
+        const { data, error, success } = inSourceConfig.safeParse(mergedConfigExport);
         if (success) {
             result.config = data;
             result.excludedRoutes = getRoutes(functionName, data.excludedPath);

package/dist/runtimes/node/index.js

@@ -104,13 +104,20 @@ const zipFunction = async function ({ archiveFormat, basePath, branch, cache, co
     });
     await cleanupFunction?.();
     // Getting the invocation mode from ISC, in case the function is using the
-    // `stream` helper.
+    // `stream` helper or set `background: true` in the in-source config.
     let { invocationMode } = staticAnalysisResult;
     // If this is a background function (filename suffix), set the right
     // `invocationMode` value.
     if (name.endsWith('-background')) {
         invocationMode = INVOCATION_MODE.Background;
     }
+    // `background: true` in the merged config (e.g. via `[functions.<name>]` in
+    // `netlify.toml`) also marks the function as background. The in-source
+    // config has already been folded into `mergedConfig` by this point, so this
+    // check covers both TOML-only and in-source declarations.
+    if (mergedConfig?.background === true) {
+        invocationMode = INVOCATION_MODE.Background;
+    }
     // V2 functions default to streamed invocation unless they were already
     // marked as background (via filename suffix or `config.background: true`).
     if (runtimeAPIVersion === 2 && invocationMode !== INVOCATION_MODE.Background) {

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

@@ -1,4 +1,4 @@
-import type { Declaration, Expression, Statement } from '@babel/types';
+import type { Declaration, Expression, ObjectExpression, Statement } from '@babel/types';
 import type { ISCExport } from '../in_source_config/index.js';
 import type { BindingMethod } from './bindings.js';
 /**
@@ -11,9 +11,15 @@ import type { BindingMethod } from './bindings.js';
  *    declarations are found, this is ESM; if not, this is CJS
  */
 export declare const traverseNodes: (nodes: Statement[], getAllBindings: BindingMethod) => {
-    configExport: Record<string, unknown>;
+    configExport: Record<string, unknown> | undefined;
     handlerExports: ISCExport[];
     hasDefaultExport: boolean;
     defaultExportExpression: Expression | Declaration | undefined;
     inputModuleFormat: "cjs";
 };
+/**
+ * Takes an object expression node and returns the object resulting from the
+ * subtree. Only values supported by the `parsePrimitive` method are returned,
+ * and any others will be ignored and excluded from the resulting object.
+ */
+export declare const parseObject: (node: ObjectExpression) => Record<string, unknown>;

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

@@ -11,7 +11,7 @@ import { isESMImportExport, isModuleExports } from './helpers.js';
  */
 export const traverseNodes = (nodes, getAllBindings) => {
     const handlerExports = [];
-    let configExport = {};
+    let configExport;
     let hasDefaultExport = false;
     let defaultExportExpression;
     let inputModuleFormat = MODULE_FORMAT.COMMONJS;
@@ -142,7 +142,7 @@ const parseConfigESMExport = (node) => {
  * subtree. Only values supported by the `parsePrimitive` method are returned,
  * and any others will be ignored and excluded from the resulting object.
  */
-const parseObject = (node) => node.properties.reduce((acc, property) => {
+export const parseObject = (node) => node.properties.reduce((acc, property) => {
     if (property.type === 'ObjectProperty' && property.key.type === 'Identifier') {
         return {
             ...acc,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/zip-it-and-ship-it",
-  "version": "14.6.0",
+  "version": "14.7.0",
   "description": "Zip it and ship it",
   "main": "./dist/main.js",
   "type": "module",
@@ -100,5 +100,5 @@
   "engines": {
     "node": ">=18.14.0"
   },
-  "gitHead": "b41ec05a2415f75122ef97422bf6d0ba3cd3ed63"
+  "gitHead": "0e2b212c4ffae1e07159374df9991584e5b4bb0b"
 }