API Reference

curl -X POST "https://api.queuebear.com/v1/projects/proj_xxx/publish" \
  -H "Authorization: Bearer qb_live_xxxxx" \
  -H "Content-Type: application/json" \
  -d '{
    "destination": "https://api.example.com/webhook",
    "body": {"event": "user.created", "userId": "123"},
    "delay": "30s",
    "retries": 5,
    "callbackUrl": "https://api.example.com/callback",
    "headers": {"X-Custom-Header": "value"}
  }'

{
  "messageId": "msg_a1b2c3d4e5f6...",
  "destination": "https://api.example.com/webhook",
  "status": "completed",
  "retries": 3,
  "retryCount": 0,
  "createdAt": "2024-01-15T10:00:00Z",
  "completedAt": "2024-01-15T10:00:31Z",
  "deliveryLogs": [...]
}

const message = await qb.messages.get(messageId);
console.log(message.status); // "pending" | "completed" | "failed"
console.log(message.deliveryLogs); // Delivery attempt history

const { messages, pagination } = await qb.messages.list({
  status: "pending",
  limit: 20,
  offset: 0,
});

await qb.messages.cancel(messageId);

const message = await qb.messages.publishAndWait(
  "https://api.example.com/webhook",
  { event: "user.created" },
  { timeoutMs: 30000 }
);
console.log(message.status); // "completed"

const schedule = await qb.schedules.create({
  destination: "https://api.example.com/cron-job",
  cron: "0 9 * * *", // Daily at 9 AM
  timezone: "America/New_York",
  method: "POST",
  body: JSON.stringify({ type: "daily-report" }),
  headers: { "Content-Type": "application/json" },
  retries: 3,
  metadata: { jobName: "daily-report" },
});

const { schedules } = await qb.schedules.list();

{
  "scheduleId": "sched_a1b2c3d4e5f6...",
  "destination": "https://api.example.com/cron-job",
  "cron": "0 9 * * *",
  "timezone": "America/New_York",
  "method": "POST",
  "retries": 3,
  "isActive": true,
  "isPaused": false,
  "lastExecutedAt": "2024-01-15T14:00:00Z",
  "nextExecutionAt": "2024-01-16T14:00:00Z",
  "executionCount": 42,
  "failureCount": 2
}

await qb.schedules.pause(scheduleId);
await qb.schedules.resume(scheduleId);

await qb.schedules.delete(scheduleId);

{
  "entries": [
    {
      "id": "uuid...",
      "originalMessageId": "msg_a1b2c3d4e5f6...",
      "destination": "https://api.example.com/webhook",
      "failureReason": "Connection timeout",
      "totalAttempts": 4
    }
  ]
}

const { entries } = await qb.dlq.list();
for (const entry of entries) {
  console.log(`${entry.id}: ${entry.failureReason}`);
}

{
  "id": "uuid...",
  "originalMessageId": "msg_a1b2c3d4e5f6...",
  "destination": "https://api.example.com/webhook",
  "method": "POST",
  "body": "{\"event\": \"user.created\"}",
  "failureReason": "Connection timeout",
  "lastStatusCode": 504,
  "totalAttempts": 4,
  "recoveredAt": null,
  "recoveryMessageId": null
}

const entry = await qb.dlq.get(dlqId);
console.log(entry.body); // Original message body
console.log(entry.totalAttempts); // Number of failed attempts

const result = await qb.dlq.retry(dlqId);
console.log(result.newMessageId); // New message created

await qb.dlq.delete(dlqId);

await qb.dlq.purge(); // Delete all entries

const results = await qb.dlq.retryAll();
console.log(`Retried ${results.length} entries`);

const { runId } = await qb.workflows.trigger(
  "user-onboarding",
  "https://your-app.com/api/workflows/onboarding",
  { userId: "123", email: "[email protected]" },
  {
    idempotencyKey: "onboarding-user-123",
    maxDuration: 60 * 60 * 24 * 7, // 7 day timeout
  }
);

const status = await qb.workflows.getStatus(runId);
console.log(status.status); // "running" | "sleeping" | "completed"
console.log(status.steps); // Array of step details

{
  "eventKey": "order-123",
  "payload": { "status": "approved" }
}

// In workflow: await context.waitForEvent("order-approved", "order.approved")

// From external code:
await qb.workflows.sendEvent("order.approved", {
  eventKey: "order-123",
  payload: { status: "approved" },
});

await qb.workflows.cancel(runId);
await qb.workflows.retry(runId); // Resume from last completed step

const result = await qb.workflows.waitForCompletion(runId, {
  pollIntervalMs: 2000,
  timeoutMs: 60000,
});

const result = await qb.triggerAndWait(
  "user-onboarding",
  "https://your-app.com/api/workflows/onboarding",
  { userId: "123" },
  { timeoutMs: 120000 }
);
console.log(result.result); // Workflow output

import { Hono } from "hono";
import { serve } from "queuebear";

const app = new Hono();

const handler = serve(async (context) => {
  await context.run("step-1", async () => { /* ... */ });
  return { success: true };
});

app.post("/api/workflows/my-workflow", async (c) => {
  return await handler(c.req.raw);
});

const steps = await context.getCompletedSteps();
console.log(`Completed ${steps.length} steps`);

// app/api/workflows/onboarding/route.ts
import { serve } from "queuebear";

interface OnboardingInput {
  userId: string;
  email: string;
}

export const POST = serve<OnboardingInput>(
  async (context) => {
    const { userId, email } = context.input;

    // Step 1: Send welcome email (cached if already done)
    await context.run("send-welcome", async () => {
      await sendEmail(email, "welcome");
    });

    // Step 2: Wait 3 days
    await context.sleep("wait-3-days", 60 * 60 * 24 * 3);

    // Step 3: Send tips email
    await context.run("send-tips", async () => {
      await sendEmail(email, "tips");
    });

    return { completed: true };
  },
  {
    signingSecret: process.env.QUEUEBEAR_SIGNING_SECRET,
  }
);