@vercel/queue 0.0.0-alpha.11 → 0.0.0-alpha.13

package/dist/index.d.mts

@@ -27,6 +27,12 @@ interface Transport<T = unknown> {
  */
 declare class JsonTransport<T = unknown> implements Transport<T> {
     readonly contentType = "application/json";
+    readonly replacer?: Parameters<typeof JSON.parse>[1];
+    readonly reviver?: Parameters<typeof JSON.parse>[1];
+    constructor(options?: {
+        replacer?: Parameters<typeof JSON.parse>[1];
+        reviver?: Parameters<typeof JSON.parse>[1];
+    });
     serialize(value: T): Buffer;
     deserialize(stream: ReadableStream<Uint8Array>): Promise<T>;
 }
@@ -152,6 +158,8 @@ interface MessageMetadata {
     messageId: string;
     deliveryCount: number;
     createdAt: Date;
+    topicName: string;
+    consumerGroup: string;
 }
 /**
  * Message handler function type
@@ -325,6 +333,42 @@ type CallbackHandlers = {
         [consumerGroup: string]: MessageHandler;
     };
 };
+/**
+ * Parsed callback request information
+ */
+type ParsedCallbackRequest = {
+    queueName: string;
+    consumerGroup: string;
+    messageId: string;
+};
+/**
+ * Parse and validate callback request using CloudEvent specification
+ *
+ * Extracts queue information from CloudEvent format and validates
+ * that all required fields are present.
+ *
+ * @param request The incoming webhook request
+ * @returns Parsed queue information
+ * @throws Error if required fields are missing
+ *
+ * @example
+ * ```typescript
+ * // In Next.js API route
+ * export async function POST(request: Request) {
+ *   try {
+ *     const { queueName, consumerGroup, messageId } = parseCallback(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 parseCallback(request: Request): Promise<ParsedCallbackRequest>;
 /**
  * Simplified queue callback handler for Next.js route handlers
  *
@@ -359,4 +403,4 @@ type CallbackHandlers = {
  */
 declare function handleCallback(handlers: CallbackHandlers): (request: Request) => Promise<Response>;
 
-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 };
+export { BadRequestError, BufferTransport, ForbiddenError, InternalServerError, InvalidLimitError, JsonTransport, type Message, MessageCorruptedError, type MessageHandler, type MessageHandlerResult, MessageLockedError, type MessageMetadata, MessageNotAvailableError, MessageNotFoundError, type MessageTimeoutResult, type ParsedCallbackRequest, type PublishOptions, QueueEmptyError, type ReceiveOptions, type SendMessageOptions, type SendMessageResponse, type SendOptions, StreamTransport, type Transport, UnauthorizedError, handleCallback, parseCallback, receive, send };

package/dist/index.d.ts

@@ -27,6 +27,12 @@ interface Transport<T = unknown> {
  */
 declare class JsonTransport<T = unknown> implements Transport<T> {
     readonly contentType = "application/json";
+    readonly replacer?: Parameters<typeof JSON.parse>[1];
+    readonly reviver?: Parameters<typeof JSON.parse>[1];
+    constructor(options?: {
+        replacer?: Parameters<typeof JSON.parse>[1];
+        reviver?: Parameters<typeof JSON.parse>[1];
+    });
     serialize(value: T): Buffer;
     deserialize(stream: ReadableStream<Uint8Array>): Promise<T>;
 }
@@ -152,6 +158,8 @@ interface MessageMetadata {
     messageId: string;
     deliveryCount: number;
     createdAt: Date;
+    topicName: string;
+    consumerGroup: string;
 }
 /**
  * Message handler function type
@@ -325,6 +333,42 @@ type CallbackHandlers = {
         [consumerGroup: string]: MessageHandler;
     };
 };
+/**
+ * Parsed callback request information
+ */
+type ParsedCallbackRequest = {
+    queueName: string;
+    consumerGroup: string;
+    messageId: string;
+};
+/**
+ * Parse and validate callback request using CloudEvent specification
+ *
+ * Extracts queue information from CloudEvent format and validates
+ * that all required fields are present.
+ *
+ * @param request The incoming webhook request
+ * @returns Parsed queue information
+ * @throws Error if required fields are missing
+ *
+ * @example
+ * ```typescript
+ * // In Next.js API route
+ * export async function POST(request: Request) {
+ *   try {
+ *     const { queueName, consumerGroup, messageId } = parseCallback(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 parseCallback(request: Request): Promise<ParsedCallbackRequest>;
 /**
  * Simplified queue callback handler for Next.js route handlers
  *
@@ -359,4 +403,4 @@ type CallbackHandlers = {
  */
 declare function handleCallback(handlers: CallbackHandlers): (request: Request) => Promise<Response>;
 
-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 };
+export { BadRequestError, BufferTransport, ForbiddenError, InternalServerError, InvalidLimitError, JsonTransport, type Message, MessageCorruptedError, type MessageHandler, type MessageHandlerResult, MessageLockedError, type MessageMetadata, MessageNotAvailableError, MessageNotFoundError, type MessageTimeoutResult, type ParsedCallbackRequest, type PublishOptions, QueueEmptyError, type ReceiveOptions, type SendMessageOptions, type SendMessageResponse, type SendOptions, StreamTransport, type Transport, UnauthorizedError, handleCallback, parseCallback, receive, send };

package/dist/index.js

@@ -34,33 +34,43 @@ __export(index_exports, {
   StreamTransport: () => StreamTransport,
   UnauthorizedError: () => UnauthorizedError,
   handleCallback: () => handleCallback,
+  parseCallback: () => parseCallback,
   receive: () => receive,
   send: () => send
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/transports.ts
+async function streamToBuffer(stream) {
+  let totalLength = 0;
+  const reader = stream.getReader();
+  const chunks = [];
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      chunks.push(value);
+      totalLength += value.length;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return Buffer.concat(chunks, totalLength);
+}
 var JsonTransport = class {
   contentType = "application/json";
+  replacer;
+  reviver;
+  constructor(options = {}) {
+    this.replacer = options.replacer;
+    this.reviver = options.reviver;
+  }
   serialize(value) {
-    return Buffer.from(JSON.stringify(value), "utf8");
+    return Buffer.from(JSON.stringify(value, this.replacer), "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"));
+    const buffer = await streamToBuffer(stream);
+    return JSON.parse(buffer.toString("utf8"), this.reviver);
   }
 };
 var BufferTransport = class {
@@ -69,25 +79,7 @@ var BufferTransport = class {
     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);
+    return await streamToBuffer(stream);
   }
 };
 var StreamTransport = class {
@@ -237,8 +229,8 @@ var QueueClient = class {
    * @param options Client configuration options (optional - will auto-detect Vercel Function environment)
    */
   constructor(options = {}) {
-    this.baseUrl = options.baseUrl || "https://api.vercel.com";
-    this.basePath = options.basePath || "/v1/queues/messages";
+    this.baseUrl = options.baseUrl || "https://vercel-queue.com";
+    this.basePath = options.basePath || "/api/v2/messages";
     if (options.token) {
       this.token = options.token;
     } else {
@@ -742,7 +734,9 @@ var ConsumerGroup = class {
       const result = await handler(message.payload, {
         messageId: message.messageId,
         deliveryCount: message.deliveryCount,
-        createdAt: message.createdAt
+        createdAt: message.createdAt,
+        topicName: this.topicName,
+        consumerGroup: this.consumerGroupName
       });
       await stopExtension();
       if (result && "timeoutSeconds" in result) {
@@ -945,7 +939,37 @@ async function receive(topicName, consumerGroup, handler, options) {
 }
 
 // src/callback.ts
-async function parseCallbackRequest(request) {
+function validateWildcardPattern(pattern) {
+  const firstIndex = pattern.indexOf("*");
+  const lastIndex = pattern.lastIndexOf("*");
+  if (firstIndex !== lastIndex) {
+    return false;
+  }
+  if (firstIndex === -1) {
+    return false;
+  }
+  if (firstIndex !== pattern.length - 1) {
+    return false;
+  }
+  return true;
+}
+function matchesWildcardPattern(topicName, pattern) {
+  const prefix = pattern.slice(0, -1);
+  return topicName.startsWith(prefix);
+}
+function findTopicHandler(queueName, handlers) {
+  const exactHandler = handlers[queueName];
+  if (exactHandler) {
+    return exactHandler;
+  }
+  for (const pattern in handlers) {
+    if (pattern.includes("*") && matchesWildcardPattern(queueName, pattern)) {
+      return handlers[pattern];
+    }
+  }
+  return null;
+}
+async function parseCallback(request) {
   const contentType = request.headers.get("content-type");
   if (!contentType || !contentType.includes("application/cloudevents+json")) {
     throw new Error(
@@ -984,10 +1008,19 @@ async function parseCallbackRequest(request) {
   };
 }
 function handleCallback(handlers) {
+  for (const topicPattern in handlers) {
+    if (topicPattern.includes("*")) {
+      if (!validateWildcardPattern(topicPattern)) {
+        throw new Error(
+          `Invalid wildcard pattern "${topicPattern}": * may only appear once and must be at the end of the topic name`
+        );
+      }
+    }
+  }
   return async (request) => {
     try {
-      const { queueName, consumerGroup, messageId } = await parseCallbackRequest(request);
-      const topicHandler = handlers[queueName];
+      const { queueName, consumerGroup, messageId } = await parseCallback(request);
+      const topicHandler = findTopicHandler(queueName, handlers);
       if (!topicHandler) {
         const availableTopics = Object.keys(handlers).join(", ");
         return Response.json(
@@ -1042,6 +1075,7 @@ function handleCallback(handlers) {
   StreamTransport,
   UnauthorizedError,
   handleCallback,
+  parseCallback,
   receive,
   send
 });