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

package/dist/index.mjs

@@ -1,116 +1,6 @@
 // src/client.ts
 import { parseMultipartStream } from "mixpart";
 
-// src/local.ts
-import { spawn } from "child_process";
-function isLocalhostWithPort(url) {
-  try {
-    const parsedUrl = new URL(url);
-    const isLocalhost = parsedUrl.hostname === "localhost";
-    const port = parsedUrl.port ? parseInt(parsedUrl.port, 10) : 0;
-    return { isLocalhost, port };
-  } catch {
-    return { isLocalhost: false };
-  }
-}
-function isSupportedPlatform() {
-  const platform = process.platform;
-  return platform === "darwin" || platform === "linux";
-}
-function processDevelopmentCallbacks(callbacks) {
-  const isDevelopment = process.env.NODE_ENV === "development";
-  if (!isDevelopment) {
-    return [];
-  }
-  if (!isSupportedPlatform()) {
-    const hasLocalhostCallbacks = Object.values(callbacks).some((config) => {
-      const { isLocalhost } = isLocalhostWithPort(config.url);
-      return isLocalhost;
-    });
-    if (hasLocalhostCallbacks) {
-      console.warn(
-        `Queue Development Mode: Localhost callbacks are not supported on ${process.platform}. Localhost callback handling requires bash, nc, and curl which are available on macOS and Linux only. Consider using a production callback URL or developing on a supported platform.`
-      );
-    }
-    return [];
-  }
-  const localhostCallbacks = [];
-  Object.entries(callbacks).forEach(([group, config]) => {
-    const { isLocalhost, port } = isLocalhostWithPort(config.url);
-    if (isLocalhost && port && port > 0) {
-      localhostCallbacks.push({ group, config, port });
-    } else {
-      console.warn(
-        `Queue Development Mode: Skipping non-localhost callback for group "${group}": ${config.url}. Only localhost callbacks with explicit ports are supported in development.`
-      );
-    }
-  });
-  return localhostCallbacks;
-}
-function fireLocalhostCallbacks(localhostCallbacks, queueName, responseData) {
-  localhostCallbacks.forEach(({ group, config, port }) => {
-    const callbackHeaders = new Headers();
-    callbackHeaders.set("Vqs-Message-Id", responseData.messageId);
-    callbackHeaders.set("Vqs-Queue-Name", queueName);
-    callbackHeaders.set("Vqs-Consumer-Group", group);
-    fireAndForgetWaitForHttpReady(
-      config.url,
-      port,
-      config.delay || 0,
-      3,
-      // Default retry frequency
-      callbackHeaders
-    );
-  });
-}
-function fireAndForgetWaitForHttpReady(url, port, initialDelaySeconds = 0, retryFrequencySeconds = 3, headers) {
-  if (!isSupportedPlatform()) {
-    console.warn(
-      `Queue: fireAndForgetWaitForHttpReady is not supported on ${process.platform}. This function requires bash, nc, and curl which are available on macOS and Linux only.`
-    );
-    return;
-  }
-  let headerArgs = "";
-  if (headers) {
-    const headerArray = [];
-    headers.forEach((value, key) => {
-      headerArray.push(`-H '${key}: ${value}'`);
-    });
-    headerArgs = headerArray.join(" ");
-  }
-  const bashScript = `
-    # Wait for any initial boot time
-    sleep ${initialDelaySeconds}
-
-    missed=0
-    while true; do
-      # 1) Check if TCP port is listening
-      if nc -z localhost ${port} 2>/dev/null; then
-        missed=0
-        # 2) If port is open, try HTTP POST check
-        if curl -sSL --fail -o /dev/null -X POST ${headerArgs} "${url}"; then
-          # Success: port is up AND HTTP returned 2xx (following redirects)
-          exit 0
-        fi
-      else
-        # Port was closed\u2014increment miss counter
-        ((missed+=1))
-        # If closed twice in a row, give up immediately
-        if [ "$missed" -ge 2 ]; then
-          exit 1
-        fi
-      fi
-      # Wait before next cycle
-      sleep ${retryFrequencySeconds}
-    done
-  `;
-  const childProcess = spawn("bash", ["-c", bashScript], {
-    stdio: "ignore",
-    detached: true
-  });
-  childProcess.unref();
-}
-
 // src/types.ts
 var MessageNotFoundError = class extends Error {
   constructor(messageId) {
@@ -126,12 +16,6 @@ var MessageNotAvailableError = class extends Error {
     this.name = "MessageNotAvailableError";
   }
 };
-var FifoOrderingViolationError = class extends Error {
-  constructor(messageId, reason) {
-    super(`FIFO ordering violation for message ${messageId}: ${reason}`);
-    this.name = "FifoOrderingViolationError";
-  }
-};
 var MessageCorruptedError = class extends Error {
   constructor(messageId, reason) {
     super(`Message ${messageId} is corrupted: ${reason}`);
@@ -173,14 +57,6 @@ var BadRequestError = class extends Error {
     this.name = "BadRequestError";
   }
 };
-var FailedDependencyError = class extends Error {
-  constructor(messageId) {
-    super(
-      `Failed dependency: FIFO ordering violation for message ${messageId}`
-    );
-    this.name = "FailedDependencyError";
-  }
-};
 var InternalServerError = class extends Error {
   constructor(message = "Unexpected server error") {
     super(message);
@@ -193,12 +69,6 @@ var InvalidLimitError = class extends Error {
     this.name = "InvalidLimitError";
   }
 };
-var InvalidCallbackError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "InvalidCallbackError";
-  }
-};
 
 // src/client.ts
 async function consumeStream(stream) {
@@ -295,7 +165,7 @@ var QueueClient = class _QueueClient {
    * @throws {InternalServerError} When server encounters an error
    */
   async sendMessage(options, transport) {
-    const { queueName, payload, idempotencyKey, retentionSeconds, callback } = options;
+    const { queueName, payload, idempotencyKey, retentionSeconds } = options;
     const headers = new Headers({
       Authorization: `Bearer ${this.token}`,
       "Vqs-Queue-Name": queueName,
@@ -310,34 +180,6 @@ var QueueClient = class _QueueClient {
     if (retentionSeconds !== void 0) {
       headers.set("Vqs-Retention-Seconds", retentionSeconds.toString());
     }
-    let normalizedCallbacks;
-    if (callback) {
-      if ("url" in callback && typeof callback.url === "string") {
-        normalizedCallbacks = { default: callback };
-      } else {
-        normalizedCallbacks = callback;
-      }
-    }
-    let localhostCallbacks = [];
-    if (normalizedCallbacks) {
-      const isDevelopment = process.env.NODE_ENV === "development";
-      if (isDevelopment) {
-        localhostCallbacks = processDevelopmentCallbacks(normalizedCallbacks);
-      } else {
-        const endpoints = Object.entries(normalizedCallbacks).map(
-          ([group, config]) => `${group}=${Buffer.from(config.url).toString("base64")}`
-        ).join(",");
-        headers.set("Vqs-Callback-Url", endpoints);
-        const delays = Object.entries(normalizedCallbacks).filter(([, config]) => config.delay !== void 0).map(([group, config]) => `${group}=${config.delay}`).join(",");
-        if (delays) {
-          headers.set("Vqs-Callback-Delay", delays);
-        }
-        const frequencies = Object.entries(normalizedCallbacks).filter(([, config]) => config.frequency !== void 0).map(([group, config]) => `${group}=${config.frequency}`).join(",");
-        if (frequencies) {
-          headers.set("Vqs-Callback-Frequency", frequencies);
-        }
-      }
-    }
     const body = transport.serialize(payload);
     const response = await fetch(`${this.baseUrl}/api/v2/messages`, {
       method: "POST",
@@ -368,9 +210,6 @@ var QueueClient = class _QueueClient {
       );
     }
     const responseData = await response.json();
-    if (localhostCallbacks.length > 0) {
-      fireLocalhostCallbacks(localhostCallbacks, queueName, responseData);
-    }
     return responseData;
   }
   /**
@@ -380,7 +219,7 @@ var QueueClient = class _QueueClient {
    * @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 {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)
@@ -431,7 +270,7 @@ var QueueClient = class _QueueClient {
           const parsed = parseInt(retryAfterHeader, 10);
           retryAfter = isNaN(parsed) ? void 0 : parsed;
         }
-        throw new MessageLockedError("next message in FIFO queue", retryAfter);
+        throw new MessageLockedError("next message", retryAfter);
       }
       if (response.status >= 500) {
         throw new InternalServerError(
@@ -517,9 +356,6 @@ var QueueClient = class _QueueClient {
         }
         throw new MessageLockedError(messageId, retryAfter);
       }
-      if (response.status === 424) {
-        throw new FailedDependencyError(messageId);
-      }
       if (response.status === 409) {
         throw new MessageNotAvailableError(messageId);
       }
@@ -715,24 +551,20 @@ var JsonTransport = class {
   }
   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 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 JSON.parse(Buffer.from(buffer).toString("utf8"));
+    const buffer = Buffer.concat(chunks, totalLength);
+    return JSON.parse(buffer.toString("utf8"));
   }
 };
 var BufferTransport = class {
@@ -1014,8 +846,7 @@ var Topic = class {
         queueName: this.topicName,
         payload,
         idempotencyKey: options?.idempotencyKey,
-        retentionSeconds: options?.retentionSeconds,
-        callback: options?.callback
+        retentionSeconds: options?.retentionSeconds
       },
       this.transport
     );
@@ -1066,8 +897,7 @@ async function send(topicName, payload, options) {
       queueName: topicName,
       payload,
       idempotencyKey: options?.idempotencyKey,
-      retentionSeconds: options?.retentionSeconds,
-      callback: options?.callback
+      retentionSeconds: options?.retentionSeconds
     },
     transport
   );
@@ -1094,23 +924,22 @@ async function receive(topicName, consumerGroup, handler, options) {
 
 // src/callback.ts
 function parseCallbackRequest(request) {
-  const headers = request.headers;
-  const messageId = headers.get("Vqs-Message-Id");
-  const queueName = headers.get("Vqs-Queue-Name");
-  const consumerGroup = headers.get("Vqs-Consumer-Group");
-  const missingHeaders = [];
-  if (!messageId) missingHeaders.push("Vqs-Message-Id");
-  if (!queueName) missingHeaders.push("Vqs-Queue-Name");
-  if (!consumerGroup) missingHeaders.push("Vqs-Consumer-Group");
-  if (missingHeaders.length > 0) {
-    throw new InvalidCallbackError(
-      `Missing required queue callback headers: ${missingHeaders.join(", ")}`
+  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");
+    throw new Error(
+      `Missing required queue headers: ${missingHeaders.join(", ")}`
     );
   }
   return {
-    messageId,
     queueName,
-    consumerGroup
+    consumerGroup,
+    messageId
   };
 }
 function handleCallback(handlers) {
@@ -1119,41 +948,38 @@ function handleCallback(handlers) {
       const { queueName, consumerGroup, messageId } = parseCallbackRequest(request);
       const topicHandler = handlers[queueName];
       if (!topicHandler) {
-        throw new Error(`No handler found for topic: ${queueName}`);
+        const availableTopics = Object.keys(handlers).join(", ");
+        return Response.json(
+          {
+            error: `No handler found for topic: ${queueName}`,
+            availableTopics
+          },
+          { status: 404 }
+        );
       }
-      let actualHandler;
-      if (typeof topicHandler === "function") {
-        if (consumerGroup !== "default") {
-          throw new Error(
-            `Topic "${queueName}" has a single handler but received consumer group "${consumerGroup}". Expected "default".`
-          );
-        }
-        actualHandler = topicHandler;
-      } else {
-        const consumerGroupHandler = topicHandler[consumerGroup];
-        if (!consumerGroupHandler) {
-          const availableGroups = Object.keys(topicHandler).join(", ");
-          throw new Error(
-            `No handler found for consumer group "${consumerGroup}" in topic "${queueName}". Available groups: ${availableGroups}`
-          );
-        }
-        actualHandler = consumerGroupHandler;
+      const consumerGroupHandler = topicHandler[consumerGroup];
+      if (!consumerGroupHandler) {
+        const availableGroups = Object.keys(topicHandler).join(", ");
+        return Response.json(
+          {
+            error: `No handler found for consumer group "${consumerGroup}" in topic "${queueName}".`,
+            availableGroups
+          },
+          { status: 404 }
+        );
       }
       const client = new QueueClient();
       const topic = new Topic(client, queueName);
       const cg = topic.consumerGroup(consumerGroup);
-      await cg.consume(actualHandler, { messageId });
+      await cg.consume(consumerGroupHandler, { messageId });
       return Response.json({ status: "success" });
     } catch (error) {
-      console.error("Callback error:", error);
-      if (error instanceof InvalidCallbackError) {
-        return Response.json(
-          { error: "Invalid callback request" },
-          { status: 400 }
-        );
+      console.error("Queue callback error:", error);
+      if (error instanceof Error && error.message.includes("Missing required queue headers")) {
+        return Response.json({ error: error.message }, { status: 400 });
       }
       return Response.json(
-        { error: "Failed to process callback" },
+        { error: "Failed to process queue message" },
         { status: 500 }
       );
     }
@@ -1163,11 +989,8 @@ export {
   BadRequestError,
   BufferTransport,
   ConsumerGroup,
-  FailedDependencyError,
-  FifoOrderingViolationError,
   ForbiddenError,
   InternalServerError,
-  InvalidCallbackError,
   InvalidLimitError,
   JsonTransport,
   MessageCorruptedError,