@vercel/queue 0.0.0-alpha.5 → 0.0.0-alpha.7

package/dist/index.d.ts

@@ -71,36 +71,6 @@ declare class StreamTransport implements Transport<ReadableStream<Uint8Array>> {
  * Vercel Queue Service client types
  */
 
-interface QueueClientOptions {
-    /**
-     * Base URL for the Vercel Queue Service API
-     * @default "https://vqs.vercel.sh"
-     */
-    baseUrl?: string;
-    /**
-     * Vercel function OIDC token
-     * Can be obtained from x-vercel-oidc-token header in Vercel Serverless Functions
-     * If not provided, will automatically attempt to retrieve from Vercel Function environment
-     */
-    token?: string;
-}
-/**
- * Callback configuration for a consumer group
- */
-interface CallbackConfig {
-    /**
-     * Webhook URL to notify when messages are available
-     */
-    url: string;
-    /**
-     * Delay in seconds before sending the first callback
-     */
-    delay?: number;
-    /**
-     * Delay in seconds between retry attempts when the callback fails
-     */
-    frequency?: number;
-}
 /**
  * Shared options for publishing messages
  */
@@ -117,12 +87,6 @@ interface PublishOptions {
      * @max 86400
      */
     retentionSeconds?: number;
-    /**
-     * Callback configuration
-     * - If a single CallbackConfig is provided, it will use the "default" consumer group
-     * - If an object is provided, keys are consumer group names with their respective callback configs
-     */
-    callback?: Record<string, CallbackConfig> | CallbackConfig;
 }
 interface SendMessageOptions<T = unknown> extends PublishOptions {
     /**
@@ -168,80 +132,6 @@ interface Message<T = unknown> {
      */
     ticket: string;
 }
-interface ReceiveMessagesOptions<T = unknown> {
-    /**
-     * The queue name to receive messages from
-     */
-    queueName: string;
-    /**
-     * Consumer group name
-     */
-    consumerGroup: string;
-    /**
-     * Time in seconds that messages will be invisible to other consumers
-     * @default 900 (15 minutes)
-     */
-    visibilityTimeoutSeconds?: number;
-    /**
-     * Maximum number of messages to retrieve
-     * @default 10
-     * @max 10
-     * @note FIFO queues must use limit=1
-     */
-    limit?: number;
-}
-interface DeleteMessageOptions {
-    /**
-     * The queue name the message belongs to
-     */
-    queueName: string;
-    /**
-     * Consumer group name
-     */
-    consumerGroup: string;
-    /**
-     * The message ID to delete
-     */
-    messageId: string;
-    /**
-     * Ticket received from the message
-     */
-    ticket: string;
-}
-interface DeleteMessageResponse {
-    /**
-     * Whether the message was successfully deleted
-     */
-    deleted: boolean;
-}
-interface ChangeVisibilityOptions {
-    /**
-     * The queue name the message belongs to
-     */
-    queueName: string;
-    /**
-     * Consumer group name
-     */
-    consumerGroup: string;
-    /**
-     * The message ID to update
-     */
-    messageId: string;
-    /**
-     * Ticket received from the message
-     */
-    ticket: string;
-    /**
-     * New visibility timeout in seconds
-     */
-    visibilityTimeoutSeconds: number;
-}
-interface ChangeVisibilityResponse {
-    /**
-     * Whether the visibility was successfully updated
-     */
-    updated: boolean;
-}
 /**
  * Result indicating the message should be timed out for retry later
  */
@@ -287,34 +177,6 @@ interface ConsumerGroupOptions<T = unknown> {
      */
     refreshInterval?: number;
 }
-interface ReceiveMessageByIdOptions<T = unknown> {
-    /**
-     * The queue name to receive the message from
-     */
-    queueName: string;
-    /**
-     * Consumer group name
-     */
-    consumerGroup: string;
-    /**
-     * The message ID to retrieve
-     */
-    messageId: string;
-    /**
-     * Time in seconds that the message will be invisible to other consumers
-     * @default 900 (15 minutes)
-     */
-    visibilityTimeoutSeconds?: number;
-    /**
-     * Skip payload content and only return message metadata
-     * When true, the server returns a 204 status with headers containing message metadata
-     * @default false
-     */
-    skipPayload?: boolean;
-}
-interface ReceiveMessageByIdResponse<T = unknown, TSkipPayload extends boolean = false> {
-    message: TSkipPayload extends true ? Message<void> : Message<T>;
-}
 /**
  * Error thrown when a message is not found (404)
  */
@@ -328,12 +190,6 @@ declare class MessageNotFoundError extends Error {
 declare class MessageNotAvailableError extends Error {
     constructor(messageId: string, reason?: string);
 }
-/**
- * Error thrown when there's a FIFO ordering violation (409)
- */
-declare class FifoOrderingViolationError extends Error {
-    constructor(messageId: string, reason: string);
-}
 /**
  * Error thrown when message data is corrupted or can't be parsed
  */
@@ -347,7 +203,7 @@ declare class QueueEmptyError extends Error {
     constructor(queueName: string, consumerGroup: string);
 }
 /**
- * Error thrown when a message is temporarily locked in a FIFO queue (423)
+ * Error thrown when a message is temporarily locked (423)
  */
 declare class MessageLockedError extends Error {
     readonly retryAfter?: number;
@@ -371,12 +227,6 @@ declare class ForbiddenError extends Error {
 declare class BadRequestError extends Error {
     constructor(message: string);
 }
-/**
- * Error thrown when there's a failed dependency (424) - FIFO ordering violation in receive by ID
- */
-declare class FailedDependencyError extends Error {
-    constructor(messageId: string);
-}
 /**
  * Error thrown for internal server errors (500)
  */
@@ -389,127 +239,6 @@ declare class InternalServerError extends Error {
 declare class InvalidLimitError extends Error {
     constructor(limit: number, min?: number, max?: number);
 }
-/**
- * Options extracted from a queue callback request
- */
-interface CallbackMessageOptions {
-    /**
-     * The queue name extracted from Vqs-Queue-Name header
-     */
-    queueName: string;
-    /**
-     * The consumer group extracted from Vqs-Consumer-Group header
-     */
-    consumerGroup: string;
-    /**
-     * The message ID extracted from Vqs-Message-Id header
-     */
-    messageId: string;
-}
-/**
- * Error thrown when queue callback headers are missing or invalid
- */
-declare class InvalidCallbackError extends Error {
-    constructor(message: string);
-}
-
-/**
- * Client for interacting with the Vercel Queue Service API
- */
-declare class QueueClient {
-    private baseUrl;
-    private token;
-    /**
-     * Internal default instance for use by createTopic and other convenience functions
-     * @internal
-     */
-    private static _defaultInstance;
-    /**
-     * Create a new Vercel Queue Service client
-     * @param options Client configuration options (optional - will auto-detect Vercel Function environment)
-     */
-    constructor(options?: QueueClientOptions);
-    /**
-     * Get the default client instance for internal use by convenience functions
-     * @internal
-     */
-    static _getDefaultInstance(): QueueClient;
-    /**
-     * Synchronously get OIDC token from environment
-     * Used internally by constructor - mirrors the logic from getVercelOidcToken but synchronously
-     */
-    private getVercelOidcTokenSync;
-    /**
-     * Send a message to a queue
-     * @param options Send message options
-     * @param transport Serializer/deserializer for the payload
-     * @returns Promise with the message ID
-     * @throws {BadRequestError} When request parameters are invalid
-     * @throws {UnauthorizedError} When authentication fails
-     * @throws {ForbiddenError} When access is denied (environment mismatch)
-     * @throws {InternalServerError} When server encounters an error
-     */
-    sendMessage<T = unknown>(options: SendMessageOptions<T>, transport: Transport<T>): Promise<SendMessageResponse>;
-    /**
-     * Receive messages from a queue
-     * @param options Receive messages options
-     * @param transport Serializer/deserializer for the payload
-     * @returns AsyncGenerator that yields messages as they arrive
-     * @throws {InvalidLimitError} When limit parameter is not between 1 and 10
-     * @throws {QueueEmptyError} When no messages are available (204)
-     * @throws {MessageLockedError} When FIFO queue has locked messages (423)
-     * @throws {BadRequestError} When request parameters are invalid
-     * @throws {UnauthorizedError} When authentication fails
-     * @throws {ForbiddenError} When access is denied (environment mismatch)
-     * @throws {InternalServerError} When server encounters an error
-     */
-    receiveMessages<T = unknown>(options: ReceiveMessagesOptions<T>, transport: Transport<T>): AsyncGenerator<Message<T>, void, unknown>;
-    /**
-     * Receive a specific message by its ID from a queue
-     * @param options Receive message by ID options
-     * @param transport Serializer/deserializer for the payload
-     * @returns Promise with the message or null if not found/available
-     * @throws {MessageNotFoundError} When the message doesn't exist (404)
-     * @throws {MessageLockedError} When the message is temporarily locked (423)
-     * @throws {FailedDependencyError} When FIFO ordering is violated (424)
-     * @throws {MessageNotAvailableError} When message exists but isn't available (409)
-     * @throws {MessageCorruptedError} When message data is corrupted
-     * @throws {BadRequestError} When request parameters are invalid
-     * @throws {UnauthorizedError} When authentication fails
-     * @throws {ForbiddenError} When access is denied (environment mismatch)
-     * @throws {InternalServerError} When server encounters an error
-     */
-    receiveMessageById<T = unknown>(options: ReceiveMessageByIdOptions<T> & {
-        skipPayload: true;
-    }, transport?: Transport<T>): Promise<ReceiveMessageByIdResponse<T, true>>;
-    receiveMessageById<T = unknown>(options: ReceiveMessageByIdOptions<T> & {
-        skipPayload?: false | undefined;
-    }, transport: Transport<T>): Promise<ReceiveMessageByIdResponse<T, false>>;
-    /**
-     * Delete a message (acknowledge processing)
-     * @param options Delete message options
-     * @returns Promise with delete status
-     * @throws {MessageNotFoundError} When the message doesn't exist (404)
-     * @throws {MessageNotAvailableError} When message can't be deleted (409)
-     * @throws {BadRequestError} When ticket is missing or invalid (400)
-     * @throws {UnauthorizedError} When authentication fails
-     * @throws {ForbiddenError} When access is denied (environment mismatch)
-     * @throws {InternalServerError} When server encounters an error
-     */
-    deleteMessage(options: DeleteMessageOptions): Promise<DeleteMessageResponse>;
-    /**
-     * Change the visibility timeout of a message
-     * @param options Change visibility options
-     * @returns Promise with update status
-     * @throws {MessageNotFoundError} When the message doesn't exist (404)
-     * @throws {MessageNotAvailableError} When message can't be updated (409)
-     * @throws {BadRequestError} When ticket is missing or visibility timeout invalid (400)
-     * @throws {UnauthorizedError} When authentication fails
-     * @throws {ForbiddenError} When access is denied (environment mismatch)
-     * @throws {InternalServerError} When server encounters an error
-     */
-    changeVisibility(options: ChangeVisibilityOptions): Promise<ChangeVisibilityResponse>;
-}
 
 /**
  * Options for the consume method
@@ -520,140 +249,7 @@ interface ConsumeOptions {
     /** Whether to skip downloading the payload (only allowed when messageId is provided) */
     skipPayload?: boolean;
 }
-/**
- * A ConsumerGroup represents a named group of consumers that process messages from a topic
- */
-declare class ConsumerGroup<T = unknown> {
-    private client;
-    private topicName;
-    private consumerGroupName;
-    private visibilityTimeout;
-    private refreshInterval;
-    private transport;
-    /**
-     * Create a new ConsumerGroup instance
-     * @param client QueueClient instance to use for API calls
-     * @param topicName Name of the topic to consume from
-     * @param consumerGroupName Name of the consumer group
-     * @param options Optional configuration
-     */
-    constructor(client: QueueClient, topicName: string, consumerGroupName: string, options?: ConsumerGroupOptions<T>);
-    /**
-     * Starts a background loop that periodically extends the visibility timeout for a message.
-     * This prevents the message from becoming visible to other consumers while it's being processed.
-     *
-     * The extension loop runs every `refreshInterval` seconds and updates the message's
-     * visibility timeout to `visibilityTimeout` seconds from the current time.
-     *
-     * @param messageId - The unique identifier of the message to extend visibility for
-     * @param ticket - The receipt ticket that proves ownership of the message
-     * @returns A function that when called will stop the extension loop
-     *
-     * @remarks
-     * - The first extension attempt occurs after `refreshInterval` seconds, not immediately
-     * - If an extension fails, the loop terminates with an error logged to console
-     * - The returned stop function is idempotent - calling it multiple times is safe
-     * - By default, the stop function returns immediately without waiting for in-flight
-     * - Pass `true` to the stop function to wait for any in-flight extension to complete
-     */
-    private startVisibilityExtension;
-    /**
-     * Process a single message with the given handler
-     * @param message The message to process
-     * @param handler Function to process the message
-     */
-    private processMessage;
-    /**
-     * Consume the next available message from the queue
-     * @param handler Function to process the message
-     * @returns Promise that resolves when the message is processed
-     * @throws All the same errors as the underlying client methods
-     */
-    consume(handler: MessageHandler<T>): Promise<void>;
-    /**
-     * Consume a specific message by its ID with full payload
-     * @param handler Function to process the message
-     * @param options Consume options with messageId specified
-     * @returns Promise that resolves when the message is processed
-     * @throws All the same errors as the underlying client methods
-     */
-    consume(handler: MessageHandler<T>, options: {
-        messageId: string;
-        skipPayload?: false | undefined;
-    }): Promise<void>;
-    /**
-     * Consume a specific message by its ID without downloading the payload (metadata only)
-     * @param handler Function to process the message metadata (payload will be void)
-     * @param options Consume options with messageId and skipPayload specified
-     * @returns Promise that resolves when the message is processed
-     * @throws All the same errors as the underlying client methods
-     */
-    consume(handler: MessageHandler<void>, options: {
-        messageId: string;
-        skipPayload: true;
-    }): Promise<void>;
-    /**
-     * Get the consumer group name
-     */
-    get name(): string;
-    /**
-     * Get the topic name this consumer group is subscribed to
-     */
-    get topic(): string;
-}
-
-/**
- * A Topic represents a named channel for publishing messages in a pub/sub pattern
- */
-declare class Topic<T = unknown> {
-    private client;
-    private topicName;
-    private transport;
-    /**
-     * Create a new Topic instance
-     * @param client QueueClient instance to use for API calls
-     * @param topicName Name of the topic to work with
-     * @param transport Optional serializer/deserializer for the payload (defaults to JSON)
-     */
-    constructor(client: QueueClient, topicName: string, transport?: Transport<T>);
-    /**
-     * Publish a message to the topic
-     * @param payload The data to publish
-     * @param options Optional publish options
-     * @returns An object containing the message ID
-     * @throws {BadRequestError} When request parameters are invalid
-     * @throws {UnauthorizedError} When authentication fails
-     * @throws {ForbiddenError} When access is denied (environment mismatch)
-     * @throws {InternalServerError} When server encounters an error
-     */
-    publish(payload: T, options?: PublishOptions): Promise<{
-        messageId: string;
-    }>;
-    /**
-     * Create a consumer group for this topic
-     * @param consumerGroupName Name of the consumer group
-     * @param options Optional configuration for the consumer group
-     * @returns A ConsumerGroup instance
-     */
-    consumerGroup<U = T>(consumerGroupName: string, options?: ConsumerGroupOptions<U>): ConsumerGroup<U>;
-    /**
-     * Get the topic name
-     */
-    get name(): string;
-    /**
-     * Get the transport used by this topic
-     */
-    get serializer(): Transport<T>;
-}
 
-/**
- * Create a new Topic instance using the default QueueClient
- * For custom client configuration, use `new Topic(customClient, topicName, transport)` directly
- * @param topicName Name of the topic
- * @param transport Optional serializer/deserializer for the payload (defaults to JSON)
- * @returns A Topic instance
- */
-declare function createTopic<T = unknown>(topicName: string, transport?: Transport<T>): Topic<T>;
 /**
  * Options for the send function
  */
@@ -722,77 +318,45 @@ declare function receive<T = unknown>(topicName: string, consumerGroup: string,
 }): Promise<void>;
 
 /**
- * Queue Callback utilities for handling incoming webhook payloads
- */
-
-/**
- * Parse a queue callback request and extract the required information for receiveMessageById
- *
- * @param request The incoming Request object from the queue callback
- * @returns CallbackMessageOptions that can be used with receiveMessageById
- * @throws {InvalidCallbackError} When required queue headers are missing or invalid
- *
- * @example
- * ```typescript
- * import { parseCallbackRequest } from '@vercel/queue';
- *
- * // In your webhook handler
- * export async function POST(request: Request) {
- *   try {
- *     const callbackOptions = parseCallbackRequest(request);
- *
- *     // Use with receiveMessageById
- *     const message = await client.receiveMessageById({
- *       ...callbackOptions,
- *       visibilityTimeoutSeconds: 30
- *     }, transport);
- *
- *     // Process the message...
- *   } catch (error) {
- *     if (error instanceof InvalidCallbackError) {
- *       return new Response('Invalid callback', { status: 400 });
- *     }
- *     throw error;
- *   }
- * }
- * ```
- */
-declare function parseCallbackRequest(request: Request): CallbackMessageOptions;
-/**
- * Configuration object with handlers for different topics
- * Each topic can have either:
- * - A single handler function (uses 'default' consumer group)
- * - An object with handlers for specific consumer groups
+ * Configuration object with handlers for different topics and consumer groups
  */
 type CallbackHandlers = {
-    [topicName: string]: MessageHandler | {
+    [topicName: string]: {
         [consumerGroup: string]: MessageHandler;
     };
 };
 /**
- * Simplified queue callback handler for NextJS route handlers
+ * Simplified queue callback handler for Next.js route handlers
+ *
+ * Automatically extracts queue information from Vercel-provided headers
+ * and routes to the appropriate handler based on topic and consumer group.
  *
- * @param handlers Object with topic-specific handlers
- * @returns A NextJS route handler function
+ * @param handlers Object with topic-specific handlers organized by consumer groups
+ * @returns A Next.js route handler function
  *
  * @example
  * ```typescript
- * // Topic handler (uses 'default' consumer group)
+ * // Single topic with multiple consumer groups
  * export const POST = handleCallback({
- *   "new-users": (message, metadata) => {
- *     console.log(`New user event:`, message, metadata);
+ *   "image-processing": {
+ *     "compress": (message, metadata) => console.log("Compressing image", message),
+ *     "resize": (message, metadata) => console.log("Resizing image", message),
  *   }
  * });
  *
- * // Consumer group specific handlers
+ * // Multiple topics with consumer groups
  * export const POST = handleCallback({
- *   "image-processing": {
- *     "compress": (message, metadata) => console.log("Compressing image", message),
- *     "resize": (message, metadata) => console.log("Resizing image", message),
+ *   "user-events": {
+ *     "welcome": (user, metadata) => console.log("Welcoming user", user),
+ *     "analytics": (user, metadata) => console.log("Tracking user", user),
+ *   },
+ *   "order-events": {
+ *     "fulfillment": (order, metadata) => console.log("Fulfilling order", order),
+ *     "notifications": (order, metadata) => console.log("Notifying order", order),
  *   }
  * });
  * ```
  */
 declare function handleCallback(handlers: CallbackHandlers): (request: Request) => Promise<Response>;
 
-export { BadRequestError, BufferTransport, type CallbackConfig, type CallbackMessageOptions, type ChangeVisibilityOptions, type ChangeVisibilityResponse, type ConsumeOptions, ConsumerGroup, type ConsumerGroupOptions, type DeleteMessageOptions, type DeleteMessageResponse, FailedDependencyError, FifoOrderingViolationError, ForbiddenError, InternalServerError, InvalidCallbackError, InvalidLimitError, JsonTransport, type Message, MessageCorruptedError, type MessageHandler, type MessageHandlerResult, MessageLockedError, type MessageMetadata, MessageNotAvailableError, MessageNotFoundError, type MessageTimeoutResult, type PublishOptions, QueueClient, type QueueClientOptions, QueueEmptyError, type ReceiveMessageByIdOptions, type ReceiveMessageByIdResponse, type ReceiveMessagesOptions, type ReceiveOptions, type SendMessageOptions, type SendMessageResponse, type SendOptions, StreamTransport, Topic, type Transport, UnauthorizedError, createTopic, handleCallback, parseCallbackRequest, receive, send };
+export { BadRequestError, BufferTransport, ForbiddenError, InternalServerError, InvalidLimitError, JsonTransport, type Message, MessageCorruptedError, type MessageHandler, type MessageHandlerResult, MessageLockedError, type MessageMetadata, MessageNotAvailableError, MessageNotFoundError, type MessageTimeoutResult, type PublishOptions, QueueEmptyError, type ReceiveOptions, type SendMessageOptions, type SendMessageResponse, type SendOptions, StreamTransport, type Transport, UnauthorizedError, handleCallback, receive, send };