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

package/dist/index.d.ts

@@ -71,19 +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;
-}
 /**
  * Shared options for publishing messages
  */
@@ -145,79 +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
-     */
-    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
  */
@@ -263,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)
  */
@@ -354,103 +240,6 @@ declare class InvalidLimitError extends Error {
     constructor(limit: number, min?: number, max?: number);
 }
 
-/**
- * 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 messages are temporarily locked (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 {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
  */
@@ -460,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
  */
@@ -661,10 +317,6 @@ declare function receive<T = unknown>(topicName: string, consumerGroup: string,
     skipPayload: true;
 }): Promise<void>;
 
-/**
- * Queue Callback utilities for handling incoming webhook payloads from Vercel triggers
- */
-
 /**
  * Configuration object with handlers for different topics and consumer groups
  */
@@ -673,42 +325,6 @@ type CallbackHandlers = {
         [consumerGroup: string]: MessageHandler;
     };
 };
-/**
- * Parsed callback request information
- */
-type ParsedCallbackRequest = {
-    queueName: string;
-    consumerGroup: string;
-    messageId: string;
-};
-/**
- * Parse and validate callback request headers
- *
- * Extracts queue information from Vercel-provided headers and validates
- * that all required headers are present.
- *
- * @param request The incoming webhook request
- * @returns Parsed queue information
- * @throws Error if required headers are missing
- *
- * @example
- * ```typescript
- * // In Next.js API route
- * export async function POST(request: Request) {
- *   try {
- *     const { queueName, consumerGroup, messageId } = parseCallbackRequest(request);
- *
- *     // Use the parsed information...
- *     await myWorkflow.handleWebhook(queueName, consumerGroup, messageId);
- *
- *     return Response.json({ status: "success" });
- *   } catch (error) {
- *     return Response.json({ error: error.message }, { status: 400 });
- *   }
- * }
- * ```
- */
-declare function parseCallbackRequest(request: Request): ParsedCallbackRequest;
 /**
  * Simplified queue callback handler for Next.js route handlers
  *
@@ -743,4 +359,4 @@ declare function parseCallbackRequest(request: Request): ParsedCallbackRequest;
  */
 declare function handleCallback(handlers: CallbackHandlers): (request: Request) => Promise<Response>;
 
-export { BadRequestError, BufferTransport, type ChangeVisibilityOptions, type ChangeVisibilityResponse, type ConsumeOptions, ConsumerGroup, type ConsumerGroupOptions, type DeleteMessageOptions, type DeleteMessageResponse, ForbiddenError, InternalServerError, InvalidLimitError, JsonTransport, type Message, MessageCorruptedError, type MessageHandler, type MessageHandlerResult, MessageLockedError, type MessageMetadata, MessageNotAvailableError, MessageNotFoundError, type MessageTimeoutResult, type ParsedCallbackRequest, 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 };

package/dist/index.js

@@ -22,7 +22,6 @@ var index_exports = {};
 __export(index_exports, {
   BadRequestError: () => BadRequestError,
   BufferTransport: () => BufferTransport,
-  ConsumerGroup: () => ConsumerGroup,
   ForbiddenError: () => ForbiddenError,
   InternalServerError: () => InternalServerError,
   InvalidLimitError: () => InvalidLimitError,
@@ -31,19 +30,87 @@ __export(index_exports, {
   MessageLockedError: () => MessageLockedError,
   MessageNotAvailableError: () => MessageNotAvailableError,
   MessageNotFoundError: () => MessageNotFoundError,
-  QueueClient: () => QueueClient,
   QueueEmptyError: () => QueueEmptyError,
   StreamTransport: () => StreamTransport,
-  Topic: () => Topic,
   UnauthorizedError: () => UnauthorizedError,
-  createTopic: () => createTopic,
   handleCallback: () => handleCallback,
-  parseCallbackRequest: () => parseCallbackRequest,
   receive: () => receive,
   send: () => send
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/transports.ts
+var JsonTransport = class {
+  contentType = "application/json";
+  serialize(value) {
+    return Buffer.from(JSON.stringify(value), "utf8");
+  }
+  async deserialize(stream) {
+    const reader = stream.getReader();
+    let totalLength = 0;
+    const chunks = [];
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        chunks.push(value);
+        totalLength += value.length;
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    const buffer = Buffer.concat(chunks, totalLength);
+    return JSON.parse(buffer.toString("utf8"));
+  }
+};
+var BufferTransport = class {
+  contentType = "application/octet-stream";
+  serialize(value) {
+    return value;
+  }
+  async deserialize(stream) {
+    const reader = stream.getReader();
+    const chunks = [];
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        chunks.push(value);
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+    const buffer = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+      buffer.set(chunk, offset);
+      offset += chunk.length;
+    }
+    return Buffer.from(buffer);
+  }
+};
+var StreamTransport = class {
+  contentType = "application/octet-stream";
+  serialize(value) {
+    return value;
+  }
+  async deserialize(stream) {
+    return stream;
+  }
+  async finalize(payload) {
+    const reader = payload.getReader();
+    try {
+      while (true) {
+        const { done } = await reader.read();
+        if (done) break;
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+};
+
 // src/client.ts
 var import_mixpart = require("mixpart");
 
@@ -153,7 +220,7 @@ var QueueClient = class _QueueClient {
   baseUrl;
   token;
   /**
-   * Internal default instance for use by createTopic and other convenience functions
+   * Internal default instance for use by convenience functions
    * @internal
    */
   static _defaultInstance = null;
@@ -589,78 +656,6 @@ var QueueClient = class _QueueClient {
   }
 };
 
-// src/transports.ts
-var JsonTransport = class {
-  contentType = "application/json";
-  serialize(value) {
-    return Buffer.from(JSON.stringify(value), "utf8");
-  }
-  async deserialize(stream) {
-    const reader = stream.getReader();
-    let totalLength = 0;
-    const chunks = [];
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        chunks.push(value);
-        totalLength += value.length;
-      }
-    } finally {
-      reader.releaseLock();
-    }
-    const buffer = Buffer.concat(chunks, totalLength);
-    return JSON.parse(buffer.toString("utf8"));
-  }
-};
-var BufferTransport = class {
-  contentType = "application/octet-stream";
-  serialize(value) {
-    return value;
-  }
-  async deserialize(stream) {
-    const reader = stream.getReader();
-    const chunks = [];
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        chunks.push(value);
-      }
-    } finally {
-      reader.releaseLock();
-    }
-    const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
-    const buffer = new Uint8Array(totalLength);
-    let offset = 0;
-    for (const chunk of chunks) {
-      buffer.set(chunk, offset);
-      offset += chunk.length;
-    }
-    return Buffer.from(buffer);
-  }
-};
-var StreamTransport = class {
-  contentType = "application/octet-stream";
-  serialize(value) {
-    return value;
-  }
-  async deserialize(stream) {
-    return stream;
-  }
-  async finalize(payload) {
-    const reader = payload.getReader();
-    try {
-      while (true) {
-        const { done } = await reader.read();
-        if (done) break;
-      }
-    } finally {
-      reader.releaseLock();
-    }
-  }
-};
-
 // src/consumer-group.ts
 var ConsumerGroup = class {
   client;
@@ -931,10 +926,6 @@ var Topic = class {
 };
 
 // src/factory.ts
-function createTopic(topicName, transport) {
-  const client = QueueClient._getDefaultInstance();
-  return new Topic(client, topicName, transport);
-}
 async function send(topicName, payload, options) {
   const transport = options?.transport || new JsonTransport();
   const client = QueueClient._getDefaultInstance();
@@ -951,7 +942,8 @@ async function send(topicName, payload, options) {
 }
 async function receive(topicName, consumerGroup, handler, options) {
   const transport = options?.transport || new JsonTransport();
-  const topic = createTopic(topicName, transport);
+  const client = QueueClient._getDefaultInstance();
+  const topic = new Topic(client, topicName, transport);
   const { messageId, skipPayload, ...consumerGroupOptions } = options || {};
   const consumer = topic.consumerGroup(consumerGroup, consumerGroupOptions);
   if (messageId) {
@@ -1035,7 +1027,6 @@ function handleCallback(handlers) {
 0 && (module.exports = {
   BadRequestError,
   BufferTransport,
-  ConsumerGroup,
   ForbiddenError,
   InternalServerError,
   InvalidLimitError,
@@ -1044,14 +1035,10 @@ function handleCallback(handlers) {
   MessageLockedError,
   MessageNotAvailableError,
   MessageNotFoundError,
-  QueueClient,
   QueueEmptyError,
   StreamTransport,
-  Topic,
   UnauthorizedError,
-  createTopic,
   handleCallback,
-  parseCallbackRequest,
   receive,
   send
 });