@vercel/queue 0.0.0-alpha.33 → 0.0.0-alpha.35

package/bin/local-discover.js

@@ -1,196 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Standalone CLI script to discover queue handlers in development mode
- * This script is self-contained and doesn't import from the main package
- */
-
-const fs = require("fs");
-const path = require("path");
-
-function showHelp() {
-  console.log(`
-@vercel/queue local-init - Initialize queue handlers in local development
-
-USAGE:
-  npx vercel-queue-local-init [options]
-
-OPTIONS:
-  --port <number>        Port number for Next.js dev server (default: 3000)
-  --config <path>        Path to vercel.json file (default: ./vercel.json)
-  --help, -h             Show this help message
-
-EXAMPLES:
-  npx vercel-queue-local-init
-  npx vercel-queue-local-init --port 3001
-  npx vercel-queue-local-init --config ./my-vercel.json
-`);
-}
-
-/**
- * Read vercel.json and extract function endpoints with queue triggers
- */
-function readVercelConfig(configPath = "./vercel.json") {
-  try {
-    const fullPath = path.resolve(configPath);
-    const configContent = fs.readFileSync(fullPath, "utf-8");
-    const config = JSON.parse(configContent);
-
-    const routes = [];
-
-    // Extract routes from functions with queue triggers
-    if (config.functions) {
-      for (const [functionPath, functionConfig] of Object.entries(
-        config.functions,
-      )) {
-        if (
-          functionConfig &&
-          typeof functionConfig === "object" &&
-          "experimentalTriggers" in functionConfig
-        ) {
-          const triggers = functionConfig.experimentalTriggers;
-          if (Array.isArray(triggers)) {
-            // Check if any trigger is a queue trigger
-            const hasQueueTrigger = triggers.some(
-              (trigger) =>
-                trigger &&
-                typeof trigger === "object" &&
-                trigger.type === "queue/v1beta",
-            );
-
-            if (hasQueueTrigger) {
-              // Convert file path to API route
-              // Examples:
-              // app/api/vm/queue/route.ts -> /api/vm/queue
-              // app/(dashboard)/api/queue/route.ts -> /api/queue
-              // app/(auth)/login/route.ts -> /login
-              // src/app/api/queue/route.ts -> /api/queue
-              // src/app/(admin)/settings/route.ts -> /settings
-              // pages/api/queue.ts -> /api/queue
-              // src/pages/api/queue.ts -> /api/queue
-              // app/queue/route.ts -> /queue
-              // src/app/webhooks/route.ts -> /webhooks
-              let apiPath = functionPath;
-
-              // Handle src/ prefix
-              if (apiPath.startsWith("src/")) {
-                apiPath = apiPath.replace("src/", "");
-              }
-
-              // Convert Next.js file paths to HTTP routes
-              if (apiPath.startsWith("app/")) {
-                // App Router: app/api/queue/route.ts -> /api/queue
-                // App Router: app/queue/route.ts -> /queue
-                apiPath = apiPath.replace("app/", "/");
-              } else if (apiPath.startsWith("pages/api/")) {
-                // Pages Router: pages/api/queue.ts -> /api/queue
-                apiPath = apiPath.replace("pages/api/", "/api/");
-              } else if (apiPath.startsWith("pages/")) {
-                // Pages Router: pages/queue.ts -> /queue
-                apiPath = apiPath.replace("pages/", "/");
-              } else {
-                // Fallback: assume it's a root-level route
-                apiPath = "/" + apiPath;
-              }
-
-              // Remove Next.js route groups (folders wrapped in parentheses)
-              // Route groups like (dashboard), (auth), (admin) are used for organization
-              // but don't affect the URL structure
-              apiPath = apiPath.replace(/\/\([^)]+\)/g, "");
-
-              // Remove file extensions and Next.js-specific suffixes
-              apiPath = apiPath.replace(
-                /\/(route|index)\.(ts|js|tsx|jsx)$/,
-                "",
-              );
-              apiPath = apiPath.replace(/\.(ts|js|tsx|jsx)$/, "");
-
-              routes.push(apiPath);
-            }
-          }
-        }
-      }
-    }
-
-    return routes;
-  } catch (error) {
-    // vercel.json might not exist or be malformed
-    return [];
-  }
-}
-
-/**
- * Make OPTIONS requests to trigger Next.js lazy loading
- */
-async function discoverQueueHandlers(options = {}) {
-  const baseUrl = options.baseUrl || "http://localhost:3000";
-  const configPath = options.configPath || "./vercel.json";
-
-  let routes = options.routes || [];
-
-  // Auto-discover from vercel.json
-  if (routes.length === 0) {
-    const configRoutes = readVercelConfig(configPath);
-    if (configRoutes.length > 0) {
-      routes = configRoutes;
-      console.log(
-        `[Dev Mode] Found ${configRoutes.length} queue endpoints in vercel.json`,
-      );
-    } else {
-      console.error("[Dev Mode] No queue endpoints found in vercel.json");
-      process.exit(1);
-    }
-  }
-
-  console.log(
-    "[Dev Mode] Making OPTIONS requests to trigger module loading...",
-  );
-
-  for (const route of routes) {
-    try {
-      // Make an OPTIONS request to trigger module loading without processing
-      const response = await fetch(`${baseUrl}${route}`, {
-        method: "OPTIONS",
-        // Add a header to identify this as a discovery request
-        headers: { "x-queue-discovery": "true" },
-      });
-
-      // Any response means the route exists and module was loaded
-      console.log(`[Dev Mode] ✓ ${route} (${response.status})`);
-    } catch (error) {
-      // Ignore errors - route might not exist or server not running
-      console.log(`[Dev Mode] ✗ ${route} (server may not be running)`);
-    }
-  }
-
-  console.log("[Dev Mode] Module loading complete.");
-}
-
-async function main() {
-  const args = process.argv.slice(2);
-  const options = {};
-
-  // Parse simple command line arguments
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    if (arg === "--help" || arg === "-h") {
-      showHelp();
-      return;
-    } else if (arg === "--port" && args[i + 1]) {
-      options.baseUrl = `http://localhost:${args[i + 1]}`;
-      i++;
-    } else if (arg === "--config" && args[i + 1]) {
-      options.configPath = args[i + 1];
-      i++;
-    }
-  }
-
-  try {
-    await discoverQueueHandlers(options);
-  } catch (error) {
-    console.error("Failed to discover queue handlers:", error.message);
-    process.exit(1);
-  }
-}
-
-main();

package/dist/types-Dw29Fr9y.d.mts

@@ -1,380 +0,0 @@
-/**
- * Serializer/Deserializer interface for message payloads
- */
-interface Transport<T = unknown> {
-    /**
-     * Serialize a value to a buffer or stream for transmission
-     */
-    serialize(value: T): Buffer | ReadableStream<Uint8Array>;
-    /**
-     * Deserialize a readable stream back to the original value
-     */
-    deserialize(stream: ReadableStream<Uint8Array>): Promise<T>;
-    /**
-     * Optional cleanup method for deserialized payloads that may contain resources
-     * Should be called when the payload is no longer needed, especially in error cases
-     * @param payload The deserialized payload to clean up
-     */
-    finalize?(payload: T): Promise<void>;
-    /**
-     * MIME type for this serialization format
-     */
-    contentType: string;
-}
-/**
- * Built-in JSON serializer/deserializer
- * This implementation reads the entire stream into memory for JSON parsing
- */
-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>;
-}
-/**
- * Built-in Buffer serializer/deserializer (reads entire stream into a Buffer)
- */
-declare class BufferTransport implements Transport<Buffer> {
-    readonly contentType = "application/octet-stream";
-    serialize(value: Buffer): Buffer;
-    deserialize(stream: ReadableStream<Uint8Array>): Promise<Buffer>;
-}
-/**
- * Stream serializer/deserializer (pass-through for streaming binary data)
- * This is ideal for large payloads that don't need to be buffered in memory
- *
- * IMPORTANT: When using StreamTransport, you must call finalize(payload) when done
- * processing the message to prevent resource leaks, especially in error cases.
- * ConsumerGroup handles this automatically, but direct Client usage requires manual cleanup.
- *
- * Example usage:
- * ```typescript
- * const transport = new StreamTransport();
- * try {
- *   for await (const message of client.receiveMessages(options, transport)) {
- *     // Process the stream...
- *     const reader = message.payload.getReader();
- *     // ... handle stream data
- *   }
- * } catch (error) {
- *   // Cleanup is handled automatically by ConsumerGroup
- *   // or manually: await transport.finalize(message.payload);
- * }
- */
-declare class StreamTransport implements Transport<ReadableStream<Uint8Array>> {
-    readonly contentType = "application/octet-stream";
-    serialize(value: ReadableStream<Uint8Array>): ReadableStream<Uint8Array>;
-    deserialize(stream: ReadableStream<Uint8Array>): Promise<ReadableStream<Uint8Array>>;
-    finalize(payload: ReadableStream<Uint8Array>): Promise<void>;
-}
-
-/**
- * Vercel Queue Service client types
- */
-
-interface QueueClientOptions {
-    /**
-     * Base URL for the Vercel Queue Service API
-     * Can also be set via VERCEL_QUEUE_BASE_URL environment variable
-     * @default "https://vercel-queue.com"
-     */
-    baseUrl?: string;
-    /**
-     * Base path for API endpoints
-     * Can also be set via VERCEL_QUEUE_BASE_PATH environment variable
-     * @default "/api/v2/messages"
-     */
-    basePath?: string;
-    /**
-     * Authentication token for the Vercel Queue Service API
-     * If not provided, the client will attempt to get a token via OIDC
-     */
-    token?: string;
-    /**
-     * Custom headers to include in all requests
-     */
-    headers?: Record<string, string>;
-}
-/**
- * Shared options for publishing messages
- */
-interface PublishOptions {
-    /**
-     * Unique key to prevent duplicate message submissions
-     * @default random UUID
-     */
-    idempotencyKey?: string;
-    /**
-     * Message retention time in seconds
-     * @default 86400 (24 hours)
-     * @min 60
-     * @max 86400
-     */
-    retentionSeconds?: number;
-    /**
-     * Explicit deployment identifier to include in the `Vqs-Deployment-Id` header
-     * If provided, this takes precedence over any value from the environment
-     */
-    deploymentId?: string;
-}
-interface SendMessageOptions<T = unknown> extends PublishOptions {
-    /**
-     * The queue name to send the message to
-     */
-    queueName: string;
-    /**
-     * The message payload
-     */
-    payload: T;
-}
-interface SendMessageResponse {
-    /**
-     * The generated message ID
-     */
-    messageId: string;
-}
-interface Message<T = unknown> {
-    /**
-     * The message ID
-     */
-    messageId: string;
-    /**
-     * The deserialized message payload
-     * Note: If using streaming transports, ensure proper cleanup by calling transport.finalize(payload)
-     * when done processing, especially in error cases
-     */
-    payload: T;
-    /**
-     * Number of times this message has been delivered
-     */
-    deliveryCount: number;
-    /**
-     * When the message was created
-     */
-    createdAt: Date;
-    /**
-     * MIME type of the message content
-     */
-    contentType: string;
-    /**
-     * Unique ticket for this message delivery (required for delete/patch operations)
-     */
-    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
- */
-interface MessageTimeoutResult {
-    /**
-     * Time in seconds before the message becomes visible again
-     */
-    timeoutSeconds: number;
-}
-/**
- * Result returned by message handlers
- */
-type MessageHandlerResult = void | MessageTimeoutResult;
-/**
- * Message metadata provided to handlers
- */
-interface MessageMetadata {
-    messageId: string;
-    deliveryCount: number;
-    createdAt: Date;
-    topicName: string;
-    consumerGroup: string;
-}
-/**
- * Message handler function type
- */
-type MessageHandler<T = unknown> = (message: T, metadata: MessageMetadata) => Promise<MessageHandlerResult> | MessageHandlerResult;
-/**
- * Options for creating a ConsumerGroup instance
- */
-interface ConsumerGroupOptions<T = unknown> {
-    /**
-     * Serializer/deserializer for the payload
-     * @default JsonTransport instance
-     */
-    transport?: Transport<T>;
-    /**
-     * Time in seconds that messages will be invisible to other consumers
-     * @default 30
-     */
-    visibilityTimeoutSeconds?: number;
-    /**
-     * How often to refresh the visibility timeout during processing (in seconds)
-     * @default 10
-     */
-    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)
- */
-declare class MessageNotFoundError extends Error {
-    constructor(messageId: string);
-}
-/**
- * Error thrown when a message is not available for processing (409)
- * This can happen when the message is in the wrong state, already claimed, etc.
- */
-declare class MessageNotAvailableError extends Error {
-    constructor(messageId: string, reason?: string);
-}
-/**
- * Error thrown when message data is corrupted or can't be parsed
- */
-declare class MessageCorruptedError extends Error {
-    constructor(messageId: string, reason: string);
-}
-/**
- * Error thrown when there are no messages available in the queue (204)
- */
-declare class QueueEmptyError extends Error {
-    constructor(queueName: string, consumerGroup: string);
-}
-/**
- * Error thrown when a message is temporarily locked (423)
- */
-declare class MessageLockedError extends Error {
-    readonly retryAfter?: number;
-    constructor(messageId: string, retryAfter?: number);
-}
-/**
- * Error thrown when authentication fails (401)
- */
-declare class UnauthorizedError extends Error {
-    constructor(message?: string);
-}
-/**
- * Error thrown when access is forbidden (403)
- */
-declare class ForbiddenError extends Error {
-    constructor(message?: string);
-}
-/**
- * Error thrown for bad requests (400)
- */
-declare class BadRequestError extends Error {
-    constructor(message: string);
-}
-/**
- * Error thrown for internal server errors (500)
- */
-declare class InternalServerError extends Error {
-    constructor(message?: string);
-}
-/**
- * Error thrown when batch limit parameter is invalid
- */
-declare class InvalidLimitError extends Error {
-    constructor(limit: number, min?: number, max?: number);
-}
-
-export { BufferTransport as B, type ChangeVisibilityOptions as C, type DeleteMessageOptions as D, ForbiddenError as F, InternalServerError as I, JsonTransport as J, type Message as M, type PublishOptions as P, type QueueClientOptions as Q, type ReceiveMessagesOptions as R, type SendMessageOptions as S, type Transport as T, UnauthorizedError as U, type SendMessageResponse as a, type ReceiveMessageByIdOptions as b, type ReceiveMessageByIdResponse as c, type DeleteMessageResponse as d, type ChangeVisibilityResponse as e, type MessageHandler as f, type ConsumerGroupOptions as g, StreamTransport as h, BadRequestError as i, InvalidLimitError as j, MessageCorruptedError as k, MessageLockedError as l, MessageNotAvailableError as m, MessageNotFoundError as n, QueueEmptyError as o, type MessageHandlerResult as p, type MessageMetadata as q, type MessageTimeoutResult as r };