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

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) {
@@ -969,19 +961,38 @@ async function receive(topicName, consumerGroup, handler, options) {
 }
 
 // src/callback.ts
-function parseCallbackRequest(request) {
-  const queueName = request.headers.get("Vqs-Queue-Name");
-  const consumerGroup = request.headers.get("Vqs-Consumer-Group");
-  const messageId = request.headers.get("Vqs-Message-Id");
-  if (!queueName || !consumerGroup || !messageId) {
-    const missingHeaders = [];
-    if (!queueName) missingHeaders.push("Vqs-Queue-Name");
-    if (!consumerGroup) missingHeaders.push("Vqs-Consumer-Group");
-    if (!messageId) missingHeaders.push("Vqs-Message-Id");
+async function parseCallbackRequest(request) {
+  const contentType = request.headers.get("content-type");
+  if (!contentType || !contentType.includes("application/cloudevents+json")) {
+    throw new Error(
+      "Invalid content type: expected 'application/cloudevents+json'"
+    );
+  }
+  let cloudEvent;
+  try {
+    cloudEvent = await request.json();
+  } catch (error) {
+    throw new Error("Failed to parse CloudEvent from request body");
+  }
+  if (!cloudEvent.type || !cloudEvent.source || !cloudEvent.id || typeof cloudEvent.data !== "object" || cloudEvent.data == null) {
+    throw new Error("Invalid CloudEvent: missing required fields");
+  }
+  if (cloudEvent.type !== "com.vercel.queue.v1beta") {
+    throw new Error(
+      `Invalid CloudEvent type: expected 'com.vercel.queue.v1beta', got '${cloudEvent.type}'`
+    );
+  }
+  const missingFields = [];
+  if (!("queueName" in cloudEvent.data)) missingFields.push("queueName");
+  if (!("consumerGroup" in cloudEvent.data))
+    missingFields.push("consumerGroup");
+  if (!("messageId" in cloudEvent.data)) missingFields.push("messageId");
+  if (missingFields.length > 0) {
     throw new Error(
-      `Missing required queue headers: ${missingHeaders.join(", ")}`
+      `Missing required CloudEvent data fields: ${missingFields.join(", ")}`
     );
   }
+  const { messageId, queueName, consumerGroup } = cloudEvent.data;
   return {
     queueName,
     consumerGroup,
@@ -991,7 +1002,7 @@ function parseCallbackRequest(request) {
 function handleCallback(handlers) {
   return async (request) => {
     try {
-      const { queueName, consumerGroup, messageId } = parseCallbackRequest(request);
+      const { queueName, consumerGroup, messageId } = await parseCallbackRequest(request);
       const topicHandler = handlers[queueName];
       if (!topicHandler) {
         const availableTopics = Object.keys(handlers).join(", ");
@@ -1021,7 +1032,7 @@ function handleCallback(handlers) {
       return Response.json({ status: "success" });
     } catch (error) {
       console.error("Queue callback error:", error);
-      if (error instanceof Error && error.message.includes("Missing required queue headers")) {
+      if (error instanceof Error && (error.message.includes("Missing required CloudEvent data fields") || error.message.includes("Invalid CloudEvent") || error.message.includes("Invalid CloudEvent type") || error.message.includes("Invalid content type") || error.message.includes("Failed to parse CloudEvent"))) {
         return Response.json({ error: error.message }, { status: 400 });
       }
       return Response.json(
@@ -1035,7 +1046,6 @@ function handleCallback(handlers) {
 0 && (module.exports = {
   BadRequestError,
   BufferTransport,
-  ConsumerGroup,
   ForbiddenError,
   InternalServerError,
   InvalidLimitError,
@@ -1044,14 +1054,10 @@ function handleCallback(handlers) {
   MessageLockedError,
   MessageNotAvailableError,
   MessageNotFoundError,
-  QueueClient,
   QueueEmptyError,
   StreamTransport,
-  Topic,
   UnauthorizedError,
-  createTopic,
   handleCallback,
-  parseCallbackRequest,
   receive,
   send
 });