import { send } from "@vercel/queue";

// Send a message to a topic
await send("my-topic", {
  message: "Hello world",
});

// With additional options
await send(
  "my-topic",
  {
    message: "Hello world",
  },
  {
    idempotencyKey: "unique-key", // Optional: prevent duplicate messages
    retentionSeconds: 3600, // Optional: override retention time (defaults to 24 hours)
    delaySeconds: 60, // Optional: delay message delivery by N seconds
  },
);

// app/api/send-message/route.ts
import { send } from "@vercel/queue";

export async function POST(request: Request) {
  const body = await request.json();

  const { messageId } = await send("my-topic", {
    message: body.message,
  });

  return Response.json({ messageId });
}

// app/api/queue/my-topic/route.ts
import { handleCallback } from "@vercel/queue/web";

export const POST = handleCallback(async (message, metadata) => {
  // metadata includes: { messageId, deliveryCount, createdAt, topicName, consumerGroup }
  console.log("Processing message:", message);

  // If this throws an error, the message will be automatically retried
  await processMessage(message);
});

import { Hono } from "hono";
import { handleCallback } from "@vercel/queue/web";

const app = new Hono();

app.post(
  "/api/queue",
  handleCallback(async (message, metadata) => {
    console.log("Processing:", message);
  }),
);

export default app;

// app/api/queue/orders/fulfillment/route.ts
import { handleCallback } from "@vercel/queue/web";

export const POST = handleCallback(async (order, metadata) => {
  await processOrder(order);
});

// app/api/queue/orders/analytics/route.ts
import { handleCallback } from "@vercel/queue/web";

export const POST = handleCallback(async (order, metadata) => {
  await trackOrder(order);
});

// pages/api/queue/my-topic.ts
import { handleCallback } from "@vercel/queue/nextjs/pages";

export default handleCallback(async (message, metadata) => {
  console.log("Processing message:", message);
  await processMessage(message);
});

import { QueueClient, send } from "@vercel/queue";
import { handleCallback } from "@vercel/queue/web";

const client = new QueueClient({
  token: "my-token",
  headers: { "X-Custom": "header" },
});

// Send with custom client
await send("my-topic", { hello: "world" }, { client });

// Handle callbacks with custom client
export const POST = handleCallback(async (msg, meta) => console.log(msg), {
  client,
});

import { handleCallback, parseRawCallback } from "@vercel/queue";

// In your framework handler:
const parsed = parseRawCallback(body, headers);
try {
  await handleCallback(async (msg, meta) => {
    console.log("Processing:", msg);
  }, parsed);
  // success
} catch (error) {
  // handle error → 500
}

import { send, JsonTransport } from "@vercel/queue";

// JsonTransport is the default
await send("json-topic", { data: "example" });

// Explicit transport configuration
await send(
  "json-topic",
  { data: "example" },
  { transport: new JsonTransport() },
);

// JsonTransport with custom serialization
const transport = new JsonTransport({
  replacer: (key, value) => (key === "password" ? undefined : value),
  reviver: (key, value) => (key === "date" ? new Date(value) : value),
});
await send("json-topic", { data: "example" }, { transport });

await receive("my-topic", "my-consumer", async (message, metadata) => {
  if (!message) {
    console.log("No message received - queue is empty");
    return;
  }

  // Process the message
  console.log("Processing:", message);
  console.log("Message ID:", metadata.messageId);
});

import { handleCallback } from "@vercel/queue/web";

export const POST = handleCallback(async (message, metadata) => {
  if (!message) {
    // No message available - handle gracefully
    return;
  }
  await processMessage(message);
});

import {
  BadRequestError,
  DuplicateMessageError,
  ForbiddenError,
  InternalServerError,
  UnauthorizedError,
} from "@vercel/queue";

try {
  await send("my-topic", payload);
} catch (error) {
  if (error instanceof UnauthorizedError) {
    console.log("Invalid token - refresh authentication");
  } else if (error instanceof ForbiddenError) {
    console.log("Environment mismatch - check configuration");
  } else if (error instanceof BadRequestError) {
    console.log("Invalid parameters:", error.message);
  } else if (error instanceof DuplicateMessageError) {
    console.log("Duplicate message:", error.idempotencyKey);
  } else if (error instanceof InternalServerError) {
    console.log("Server error - retry with backoff");
  }
}

import { receive } from "@vercel/queue";

// Process next available message (or null if queue is empty)
await receive<T>(topicName, consumerGroup, async (message, metadata) => {
  if (!message) {
    console.log("Queue is empty");
    return;
  }
  // Process message
});

// Batch processing: fetch up to 10 messages in one request
await receive<T>(topicName, consumerGroup, handler, {
  limit: 10, // Default: 1, Min: 1, Max: 10
});

// Process specific message by ID
await receive<T>(topicName, consumerGroup, handler, {
  messageId: "message-id",
});

// Note: limit and messageId are mutually exclusive options

// Handler function signature
// When queue is empty, both message and metadata are null
type MessageHandler<T = unknown> = (
  message: T | null,
  metadata: MessageMetadata | null,
) => Promise<void> | void;

// MessageMetadata type
interface MessageMetadata {
  messageId: string;
  deliveryCount: number;
  createdAt: Date;
  topicName: string;
  consumerGroup: string;
}

import { QueueClient } from "@vercel/queue";

const client = new QueueClient({
  // Base URL for the queue service
  // Default: "https://vercel-queue.com"
  // Env: VERCEL_QUEUE_BASE_URL
  baseUrl: "https://vercel-queue.com",

  // API path prefix
  // Default: "/api/v3/topic"
  // Env: VERCEL_QUEUE_BASE_PATH
  basePath: "/api/v3/topic",

  // Auth token (auto-fetched via OIDC if not provided)
  token: "my-token",

  // Custom headers for all requests
  headers: { "X-Custom": "value" },

  // Deployment ID for message routing
  // Default: process.env.VERCEL_DEPLOYMENT_ID
  deploymentId: "dpl_xxx",

  // Pin messages to current deployment when publishing
  // Default: true
  pinToDeployment: true,
});

// Pass to any function via options
await send("my-topic", payload, { client });
export const POST = handleCallback(handler, { client });

await send("my-topic", payload, {
  // Deduplication key
  // Dedup window: min(retentionSeconds, 24 hours)
  idempotencyKey: "unique-key",

  // Message TTL in seconds
  // Default: 86400, Min: 60, Max: 86400
  retentionSeconds: 3600,

  // Delay before message becomes visible
  // Default: 0, Min: 0, Max: retentionSeconds
  delaySeconds: 60,

  // Custom serializer (default: JsonTransport)
  transport: new JsonTransport(),
});

// Batch mode: receive multiple messages
await receive("my-topic", "my-consumer", handler, {
  // Maximum messages to retrieve in a single request
  // Default: 1, Min: 1, Max: 10
  limit: 10,

  // Message lock duration in seconds
  // Default: 300, Min: 30, Max: 3600
  visibilityTimeoutSeconds: 60,
});

// By-ID mode: receive a specific message
await receive("my-topic", "my-consumer", handler, {
  // Specific message ID to consume
  messageId: "0-1",

  // Message lock duration in seconds
  // Default: 300, Min: 30, Max: 3600
  visibilityTimeoutSeconds: 60,
});

import { handleCallback } from "@vercel/queue/web";

export const POST = handleCallback(
  async (message, metadata) => {
    await processMessage(message);
  },
  {
    // Message lock duration for long-running handlers
    // Default: 300, Min: 30, Max: 3600
    visibilityTimeoutSeconds: 300, // 5 minutes
  },
);

import { handleCallback, parseCallback, parseRawCallback } from "@vercel/queue";

// Web API Request
const parsed = await parseCallback(request);

// Or, for frameworks that pre-parse the body (e.g. Pages Router)
const parsed = parseRawCallback(req.body, req.headers);

try {
  await handleCallback(handler, parsed);
} catch (error) {
  // handle error → 500
}