@vercel/build-utils 10.6.1 → 10.6.2

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @vercel/build-utils
 
+## 10.6.2
+
+### Patch Changes
+
+- Add CloudEventTrigger support for Lambda functions ([#13503](https://github.com/vercel/vercel/pull/13503))
+
 ## 10.6.1
 
 ### Patch Changes

package/dist/index.js

@@ -22372,6 +22372,9 @@ async function download(files, basePath, meta) {
 }
 
 // src/lambda.ts
+function isCloudEventQueueTrigger(trigger) {
+  return trigger.type === "com.vercel.queue.v1";
+}
 function getDefaultLambdaArchitecture(architecture) {
   if (architecture) {
     return architecture;
@@ -22402,7 +22405,8 @@ var Lambda = class {
       supportsResponseStreaming,
       experimentalResponseStreaming,
       operationType,
-      framework
+      framework,
+      experimentalTriggers
     } = opts;
     if ("files" in opts) {
       (0, import_assert4.default)(typeof opts.files === "object", '"files" must be an object');
@@ -22470,6 +22474,122 @@ var Lambda = class {
         );
       }
     }
+    if (experimentalTriggers !== void 0) {
+      (0, import_assert4.default)(
+        Array.isArray(experimentalTriggers),
+        '"experimentalTriggers" is not an Array'
+      );
+      for (let i = 0; i < experimentalTriggers.length; i++) {
+        const trigger = experimentalTriggers[i];
+        const prefix = `"experimentalTriggers[${i}]"`;
+        (0, import_assert4.default)(
+          typeof trigger === "object" && trigger !== null,
+          `${prefix} is not an object`
+        );
+        (0, import_assert4.default)(
+          trigger.triggerVersion === 1,
+          `${prefix}.triggerVersion must be 1`
+        );
+        (0, import_assert4.default)(
+          trigger.specversion === "1.0",
+          `${prefix}.specversion must be "1.0"`
+        );
+        (0, import_assert4.default)(
+          typeof trigger.type === "string",
+          `${prefix}.type is not a string`
+        );
+        (0, import_assert4.default)(trigger.type.length > 0, `${prefix}.type cannot be empty`);
+        if (isCloudEventQueueTrigger(trigger)) {
+          (0, import_assert4.default)(
+            typeof trigger.queue === "object" && trigger.queue !== null,
+            `${prefix}.queue is required and must be an object for queue triggers`
+          );
+          const queue = trigger.queue;
+          const queuePrefix = `${prefix}.queue`;
+          (0, import_assert4.default)(
+            typeof queue.topic === "string",
+            `${queuePrefix}.topic is required and must be a string`
+          );
+          (0, import_assert4.default)(
+            queue.topic.length > 0,
+            `${queuePrefix}.topic cannot be empty`
+          );
+          (0, import_assert4.default)(
+            typeof queue.consumer === "string",
+            `${queuePrefix}.consumer is required and must be a string`
+          );
+          (0, import_assert4.default)(
+            queue.consumer.length > 0,
+            `${queuePrefix}.consumer cannot be empty`
+          );
+        }
+        const binding = trigger.httpBinding;
+        const bindingPrefix = `${prefix}.httpBinding`;
+        (0, import_assert4.default)(
+          typeof binding === "object" && binding !== null,
+          `${bindingPrefix} is required and must be an object`
+        );
+        (0, import_assert4.default)(
+          binding.mode === "structured",
+          `${bindingPrefix}.mode must be "structured"`
+        );
+        if (binding.method !== void 0) {
+          const validMethods = ["GET", "POST", "HEAD"];
+          (0, import_assert4.default)(
+            validMethods.includes(binding.method),
+            `${bindingPrefix}.method must be one of: ${validMethods.join(", ")}`
+          );
+        }
+        if (binding.pathname !== void 0) {
+          (0, import_assert4.default)(
+            typeof binding.pathname === "string",
+            `${bindingPrefix}.pathname must be a string`
+          );
+          (0, import_assert4.default)(
+            binding.pathname.length > 0,
+            `${bindingPrefix}.pathname cannot be empty`
+          );
+          (0, import_assert4.default)(
+            binding.pathname.startsWith("/"),
+            `${bindingPrefix}.pathname must start with '/'`
+          );
+        }
+        if (isCloudEventQueueTrigger(trigger)) {
+          const queue = trigger.queue;
+          const queuePrefix = `${prefix}.queue`;
+          if (queue.maxAttempts !== void 0) {
+            (0, import_assert4.default)(
+              typeof queue.maxAttempts === "number",
+              `${queuePrefix}.maxAttempts must be a number`
+            );
+            (0, import_assert4.default)(
+              Number.isInteger(queue.maxAttempts) && queue.maxAttempts >= 0,
+              `${queuePrefix}.maxAttempts must be a non-negative integer`
+            );
+          }
+          if (queue.retryAfterSeconds !== void 0) {
+            (0, import_assert4.default)(
+              typeof queue.retryAfterSeconds === "number",
+              `${queuePrefix}.retryAfterSeconds must be a number`
+            );
+            (0, import_assert4.default)(
+              queue.retryAfterSeconds > 0,
+              `${queuePrefix}.retryAfterSeconds must be a positive number`
+            );
+          }
+          if (queue.initialDelaySeconds !== void 0) {
+            (0, import_assert4.default)(
+              typeof queue.initialDelaySeconds === "number",
+              `${queuePrefix}.initialDelaySeconds must be a number`
+            );
+            (0, import_assert4.default)(
+              queue.initialDelaySeconds >= 0,
+              `${queuePrefix}.initialDelaySeconds must be a non-negative number`
+            );
+          }
+        }
+      }
+    }
     this.type = "Lambda";
     this.operationType = operationType;
     this.files = "files" in opts ? opts.files : void 0;
@@ -22487,6 +22607,7 @@ var Lambda = class {
     this.supportsResponseStreaming = supportsResponseStreaming ?? experimentalResponseStreaming;
     this.framework = framework;
     this.experimentalAllowBundling = "experimentalAllowBundling" in opts ? opts.experimentalAllowBundling : void 0;
+    this.experimentalTriggers = experimentalTriggers;
   }
   async createZip() {
     let { zipBuffer } = this;
@@ -24272,6 +24393,80 @@ function hasProp(obj, key) {
 }
 
 // src/schemas.ts
+var cloudEventTriggerSchema = {
+  type: "object",
+  properties: {
+    triggerVersion: {
+      type: "number",
+      const: 1
+    },
+    specversion: {
+      type: "string",
+      const: "1.0"
+    },
+    type: {
+      type: "string",
+      minLength: 1
+    },
+    httpBinding: {
+      type: "object",
+      properties: {
+        mode: {
+          type: "string",
+          const: "structured"
+        },
+        method: {
+          type: "string",
+          enum: ["GET", "POST", "HEAD"]
+        },
+        pathname: {
+          type: "string",
+          minLength: 1,
+          pattern: "^/"
+        }
+      },
+      required: ["mode"],
+      additionalProperties: false
+    },
+    queue: {
+      type: "object",
+      properties: {
+        topic: {
+          type: "string",
+          minLength: 1
+        },
+        consumer: {
+          type: "string",
+          minLength: 1
+        },
+        maxAttempts: {
+          type: "number",
+          minimum: 0
+        },
+        retryAfterSeconds: {
+          type: "number",
+          exclusiveMinimum: 0
+        },
+        initialDelaySeconds: {
+          type: "number",
+          minimum: 0
+        }
+      },
+      required: ["topic", "consumer"],
+      additionalProperties: false
+    }
+  },
+  required: ["triggerVersion", "specversion", "type", "httpBinding"],
+  additionalProperties: false,
+  if: {
+    properties: {
+      type: { const: "com.vercel.queue.v1" }
+    }
+  },
+  then: {
+    required: ["triggerVersion", "specversion", "type", "httpBinding", "queue"]
+  }
+};
 var functionsSchema = {
   type: "object",
   minProperties: 1,
@@ -24306,6 +24501,10 @@ var functionsSchema = {
         excludeFiles: {
           type: "string",
           maxLength: 256
+        },
+        experimentalTriggers: {
+          type: "array",
+          items: cloudEventTriggerSchema
         }
       }
     }

package/dist/lambda.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="node" />
-import type { Config, Env, Files, FunctionFramework } from './types';
+import type { Config, Env, Files, FunctionFramework, CloudEventTrigger, CloudEventTriggerBase, CloudEventQueueTrigger } from './types';
+export type { CloudEventTrigger, CloudEventTriggerBase, CloudEventQueueTrigger, };
 export type LambdaOptions = LambdaOptionsWithFiles | LambdaOptionsWithZipBuffer;
 export type LambdaArchitecture = 'x86_64' | 'arm64';
 export interface LambdaOptionsBase {
@@ -20,6 +21,22 @@ export interface LambdaOptionsBase {
     experimentalResponseStreaming?: boolean;
     operationType?: string;
     framework?: FunctionFramework;
+    /**
+     * Experimental CloudEvents trigger definitions that this Lambda can receive.
+     * Defines what types of CloudEvents this Lambda can handle as an HTTP endpoint.
+     * Currently supports HTTP protocol binding in structured mode only.
+     * Only supports CloudEvents specification version 1.0.
+     *
+     * The delivery configuration provides HINTS to the system about preferred
+     * execution behavior (concurrency, retries) but these are NOT guarantees.
+     * The system may disregard these hints based on resource constraints.
+     *
+     * IMPORTANT: HTTP request-response semantics remain synchronous regardless
+     * of delivery configuration. Callers receive immediate responses.
+     *
+     * @experimental This feature is experimental and may change.
+     */
+    experimentalTriggers?: CloudEventTrigger[];
 }
 export interface LambdaOptionsWithFiles extends LambdaOptionsBase {
     files: Files;
@@ -64,6 +81,22 @@ export declare class Lambda {
     supportsResponseStreaming?: boolean;
     framework?: FunctionFramework;
     experimentalAllowBundling?: boolean;
+    /**
+     * Experimental CloudEvents trigger definitions that this Lambda can receive.
+     * Defines what types of CloudEvents this Lambda can handle as an HTTP endpoint.
+     * Currently supports HTTP protocol binding in structured mode only.
+     * Only supports CloudEvents specification version 1.0.
+     *
+     * The delivery configuration provides HINTS to the system about preferred
+     * execution behavior (concurrency, retries) but these are NOT guarantees.
+     * The system may disregard these hints based on resource constraints.
+     *
+     * IMPORTANT: HTTP request-response semantics remain synchronous regardless
+     * of delivery configuration. Callers receive immediate responses.
+     *
+     * @experimental This feature is experimental and may change.
+     */
+    experimentalTriggers?: CloudEventTrigger[];
     constructor(opts: LambdaOptions);
     createZip(): Promise<Buffer>;
     /**
@@ -78,4 +111,3 @@ export declare class Lambda {
 export declare function createLambda(opts: LambdaOptions): Promise<Lambda>;
 export declare function createZip(files: Files): Promise<Buffer>;
 export declare function getLambdaOptionsFromFunction({ sourceFile, config, }: GetLambdaOptionsFromFunctionOptions): Promise<Pick<LambdaOptions, 'architecture' | 'memory' | 'maxDuration'>>;
-export {};

package/dist/lambda.js

@@ -41,6 +41,9 @@ var import_minimatch = __toESM(require("minimatch"));
 var import_fs_extra = require("fs-extra");
 var import_download = require("./fs/download");
 var import_stream_to_buffer = __toESM(require("./fs/stream-to-buffer"));
+function isCloudEventQueueTrigger(trigger) {
+  return trigger.type === "com.vercel.queue.v1";
+}
 function getDefaultLambdaArchitecture(architecture) {
   if (architecture) {
     return architecture;
@@ -71,7 +74,8 @@ class Lambda {
       supportsResponseStreaming,
       experimentalResponseStreaming,
       operationType,
-      framework
+      framework,
+      experimentalTriggers
     } = opts;
     if ("files" in opts) {
       (0, import_assert.default)(typeof opts.files === "object", '"files" must be an object');
@@ -139,6 +143,122 @@ class Lambda {
         );
       }
     }
+    if (experimentalTriggers !== void 0) {
+      (0, import_assert.default)(
+        Array.isArray(experimentalTriggers),
+        '"experimentalTriggers" is not an Array'
+      );
+      for (let i = 0; i < experimentalTriggers.length; i++) {
+        const trigger = experimentalTriggers[i];
+        const prefix = `"experimentalTriggers[${i}]"`;
+        (0, import_assert.default)(
+          typeof trigger === "object" && trigger !== null,
+          `${prefix} is not an object`
+        );
+        (0, import_assert.default)(
+          trigger.triggerVersion === 1,
+          `${prefix}.triggerVersion must be 1`
+        );
+        (0, import_assert.default)(
+          trigger.specversion === "1.0",
+          `${prefix}.specversion must be "1.0"`
+        );
+        (0, import_assert.default)(
+          typeof trigger.type === "string",
+          `${prefix}.type is not a string`
+        );
+        (0, import_assert.default)(trigger.type.length > 0, `${prefix}.type cannot be empty`);
+        if (isCloudEventQueueTrigger(trigger)) {
+          (0, import_assert.default)(
+            typeof trigger.queue === "object" && trigger.queue !== null,
+            `${prefix}.queue is required and must be an object for queue triggers`
+          );
+          const queue = trigger.queue;
+          const queuePrefix = `${prefix}.queue`;
+          (0, import_assert.default)(
+            typeof queue.topic === "string",
+            `${queuePrefix}.topic is required and must be a string`
+          );
+          (0, import_assert.default)(
+            queue.topic.length > 0,
+            `${queuePrefix}.topic cannot be empty`
+          );
+          (0, import_assert.default)(
+            typeof queue.consumer === "string",
+            `${queuePrefix}.consumer is required and must be a string`
+          );
+          (0, import_assert.default)(
+            queue.consumer.length > 0,
+            `${queuePrefix}.consumer cannot be empty`
+          );
+        }
+        const binding = trigger.httpBinding;
+        const bindingPrefix = `${prefix}.httpBinding`;
+        (0, import_assert.default)(
+          typeof binding === "object" && binding !== null,
+          `${bindingPrefix} is required and must be an object`
+        );
+        (0, import_assert.default)(
+          binding.mode === "structured",
+          `${bindingPrefix}.mode must be "structured"`
+        );
+        if (binding.method !== void 0) {
+          const validMethods = ["GET", "POST", "HEAD"];
+          (0, import_assert.default)(
+            validMethods.includes(binding.method),
+            `${bindingPrefix}.method must be one of: ${validMethods.join(", ")}`
+          );
+        }
+        if (binding.pathname !== void 0) {
+          (0, import_assert.default)(
+            typeof binding.pathname === "string",
+            `${bindingPrefix}.pathname must be a string`
+          );
+          (0, import_assert.default)(
+            binding.pathname.length > 0,
+            `${bindingPrefix}.pathname cannot be empty`
+          );
+          (0, import_assert.default)(
+            binding.pathname.startsWith("/"),
+            `${bindingPrefix}.pathname must start with '/'`
+          );
+        }
+        if (isCloudEventQueueTrigger(trigger)) {
+          const queue = trigger.queue;
+          const queuePrefix = `${prefix}.queue`;
+          if (queue.maxAttempts !== void 0) {
+            (0, import_assert.default)(
+              typeof queue.maxAttempts === "number",
+              `${queuePrefix}.maxAttempts must be a number`
+            );
+            (0, import_assert.default)(
+              Number.isInteger(queue.maxAttempts) && queue.maxAttempts >= 0,
+              `${queuePrefix}.maxAttempts must be a non-negative integer`
+            );
+          }
+          if (queue.retryAfterSeconds !== void 0) {
+            (0, import_assert.default)(
+              typeof queue.retryAfterSeconds === "number",
+              `${queuePrefix}.retryAfterSeconds must be a number`
+            );
+            (0, import_assert.default)(
+              queue.retryAfterSeconds > 0,
+              `${queuePrefix}.retryAfterSeconds must be a positive number`
+            );
+          }
+          if (queue.initialDelaySeconds !== void 0) {
+            (0, import_assert.default)(
+              typeof queue.initialDelaySeconds === "number",
+              `${queuePrefix}.initialDelaySeconds must be a number`
+            );
+            (0, import_assert.default)(
+              queue.initialDelaySeconds >= 0,
+              `${queuePrefix}.initialDelaySeconds must be a non-negative number`
+            );
+          }
+        }
+      }
+    }
     this.type = "Lambda";
     this.operationType = operationType;
     this.files = "files" in opts ? opts.files : void 0;
@@ -156,6 +276,7 @@ class Lambda {
     this.supportsResponseStreaming = supportsResponseStreaming ?? experimentalResponseStreaming;
     this.framework = framework;
     this.experimentalAllowBundling = "experimentalAllowBundling" in opts ? opts.experimentalAllowBundling : void 0;
+    this.experimentalTriggers = experimentalTriggers;
   }
   async createZip() {
     let { zipBuffer } = this;

package/dist/schemas.d.ts

@@ -33,6 +33,85 @@ export declare const functionsSchema: {
                     type: string;
                     maxLength: number;
                 };
+                experimentalTriggers: {
+                    type: string;
+                    items: {
+                        type: string;
+                        properties: {
+                            triggerVersion: {
+                                type: string;
+                                const: number;
+                            };
+                            specversion: {
+                                type: string;
+                                const: string;
+                            };
+                            type: {
+                                type: string;
+                                minLength: number;
+                            };
+                            httpBinding: {
+                                type: string;
+                                properties: {
+                                    mode: {
+                                        type: string;
+                                        const: string;
+                                    };
+                                    method: {
+                                        type: string;
+                                        enum: string[];
+                                    };
+                                    pathname: {
+                                        type: string;
+                                        minLength: number;
+                                        pattern: string;
+                                    };
+                                };
+                                required: string[];
+                                additionalProperties: boolean;
+                            };
+                            queue: {
+                                type: string;
+                                properties: {
+                                    topic: {
+                                        type: string;
+                                        minLength: number;
+                                    };
+                                    consumer: {
+                                        type: string;
+                                        minLength: number;
+                                    };
+                                    maxAttempts: {
+                                        type: string;
+                                        minimum: number;
+                                    };
+                                    retryAfterSeconds: {
+                                        type: string;
+                                        exclusiveMinimum: number;
+                                    };
+                                    initialDelaySeconds: {
+                                        type: string;
+                                        minimum: number;
+                                    };
+                                };
+                                required: string[];
+                                additionalProperties: boolean;
+                            };
+                        };
+                        required: string[];
+                        additionalProperties: boolean;
+                        if: {
+                            properties: {
+                                type: {
+                                    const: string;
+                                };
+                            };
+                        };
+                        then: {
+                            required: string[];
+                        };
+                    };
+                };
             };
         };
     };

package/dist/schemas.js

@@ -22,6 +22,80 @@ __export(schemas_exports, {
   functionsSchema: () => functionsSchema
 });
 module.exports = __toCommonJS(schemas_exports);
+const cloudEventTriggerSchema = {
+  type: "object",
+  properties: {
+    triggerVersion: {
+      type: "number",
+      const: 1
+    },
+    specversion: {
+      type: "string",
+      const: "1.0"
+    },
+    type: {
+      type: "string",
+      minLength: 1
+    },
+    httpBinding: {
+      type: "object",
+      properties: {
+        mode: {
+          type: "string",
+          const: "structured"
+        },
+        method: {
+          type: "string",
+          enum: ["GET", "POST", "HEAD"]
+        },
+        pathname: {
+          type: "string",
+          minLength: 1,
+          pattern: "^/"
+        }
+      },
+      required: ["mode"],
+      additionalProperties: false
+    },
+    queue: {
+      type: "object",
+      properties: {
+        topic: {
+          type: "string",
+          minLength: 1
+        },
+        consumer: {
+          type: "string",
+          minLength: 1
+        },
+        maxAttempts: {
+          type: "number",
+          minimum: 0
+        },
+        retryAfterSeconds: {
+          type: "number",
+          exclusiveMinimum: 0
+        },
+        initialDelaySeconds: {
+          type: "number",
+          minimum: 0
+        }
+      },
+      required: ["topic", "consumer"],
+      additionalProperties: false
+    }
+  },
+  required: ["triggerVersion", "specversion", "type", "httpBinding"],
+  additionalProperties: false,
+  if: {
+    properties: {
+      type: { const: "com.vercel.queue.v1" }
+    }
+  },
+  then: {
+    required: ["triggerVersion", "specversion", "type", "httpBinding", "queue"]
+  }
+};
 const functionsSchema = {
   type: "object",
   minProperties: 1,
@@ -56,6 +130,10 @@ const functionsSchema = {
         excludeFiles: {
           type: "string",
           maxLength: 256
+        },
+        experimentalTriggers: {
+          type: "array",
+          items: cloudEventTriggerSchema
         }
       }
     }

package/dist/types.d.ts

@@ -322,6 +322,7 @@ export interface BuilderFunctions {
         runtime?: string;
         includeFiles?: string;
         excludeFiles?: string;
+        experimentalTriggers?: CloudEventTrigger[];
     };
 }
 export interface ProjectSettings {
@@ -496,3 +497,63 @@ export interface Chain {
      */
     headers: Record<string, string>;
 }
+/**
+ * Base CloudEvent trigger definition for HTTP protocol binding.
+ * Defines what types of CloudEvents this Lambda can receive as an HTTP endpoint.
+ *
+ * @see https://github.com/cloudevents/spec/blob/main/cloudevents/spec.md
+ * @see https://github.com/cloudevents/spec/blob/main/cloudevents/bindings/http-protocol-binding.md
+ * @see https://github.com/cloudevents/spec/blob/main/subscriptions/spec.md
+ */
+export interface CloudEventTriggerBase<T extends string = string> {
+    /** Vercel trigger specification version - must be 1 (REQUIRED) */
+    triggerVersion: 1;
+    /** CloudEvents specification version - must be "1.0" (REQUIRED) */
+    specversion: '1.0';
+    /** Event type pattern this trigger handles (REQUIRED) */
+    type: T;
+    /** HTTP binding configuration (REQUIRED) */
+    httpBinding: {
+        /** HTTP binding mode - only structured mode is supported (REQUIRED) */
+        mode: 'structured';
+        /** HTTP method for this trigger endpoint (OPTIONAL, default: 'POST') */
+        method?: 'GET' | 'POST' | 'HEAD';
+        /** HTTP pathname for this trigger endpoint (OPTIONAL) */
+        pathname?: string;
+    };
+}
+/**
+ * CloudEvent queue trigger for Vercel's queue system.
+ * Handles "com.vercel.queue.v1" events with queue-specific configuration.
+ */
+export interface CloudEventQueueTrigger extends CloudEventTriggerBase<'com.vercel.queue.v1'> {
+    /**
+     * Queue configuration for this trigger (REQUIRED)
+     */
+    queue: {
+        /** Name of the queue topic to consume from (REQUIRED) */
+        topic: string;
+        /** Name of the consumer group for this trigger (REQUIRED) */
+        consumer: string;
+        /**
+         * Maximum number of retry attempts for failed executions (OPTIONAL)
+         * Behavior when not specified depends on the server's default configuration.
+         */
+        maxAttempts?: number;
+        /**
+         * Delay in seconds before retrying failed executions (OPTIONAL)
+         * Behavior when not specified depends on the server's default configuration.
+         */
+        retryAfterSeconds?: number;
+        /**
+         * Initial delay in seconds before first execution attempt (OPTIONAL)
+         * Must be 0 or greater. Use 0 for no initial delay.
+         * Behavior when not specified depends on the server's default configuration.
+         */
+        initialDelaySeconds?: number;
+    };
+}
+/**
+ * Union type of all supported CloudEvent trigger types.
+ */
+export type CloudEventTrigger = CloudEventTriggerBase | CloudEventQueueTrigger;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/build-utils",
-  "version": "10.6.1",
+  "version": "10.6.2",
   "license": "Apache-2.0",
   "main": "./dist/index.js",
   "types": "./dist/index.d.js",
@@ -27,7 +27,7 @@
     "@types/semver": "6.0.0",
     "@types/yazl": "2.4.2",
     "@vercel/error-utils": "2.0.3",
-    "@vercel/routing-utils": "5.0.6",
+    "@vercel/routing-utils": "5.1.0",
     "aggregate-error": "3.0.1",
     "async-retry": "1.2.3",
     "async-sema": "2.1.4",