@queuedash/sdk 0.1.0

package/README.md

@@ -0,0 +1,163 @@
+# @queuedash/sdk
+
+Official SDK for QueueDash - Real-time monitoring for Bull, BullMQ, and Bee-Queue.
+
+## Installation
+
+```bash
+npm install @queuedash/sdk
+# or
+pnpm add @queuedash/sdk
+# or
+yarn add @queuedash/sdk
+```
+
+## Quick Start
+
+### BullMQ
+
+```typescript
+import { Queue } from "bullmq";
+import { QueueDashClient, attachToBullMQ } from "@queuedash/sdk";
+
+// Create your queue
+const myQueue = new Queue("my-queue", {
+  connection: { host: "localhost", port: 6379 },
+});
+
+// Initialize QueueDash client
+const queueDash = new QueueDashClient({
+  apiKey: process.env.QUEUEDASH_API_KEY,
+});
+
+// Attach to your queue - that's it!
+attachToBullMQ(myQueue, queueDash);
+
+// Jobs are now automatically synced to QueueDash
+```
+
+### Bull
+
+```typescript
+import Queue from "bull";
+import { QueueDashClient, attachToBull } from "@queuedash/sdk";
+
+const myQueue = new Queue("my-queue", {
+  redis: { host: "localhost", port: 6379 },
+});
+
+const queueDash = new QueueDashClient({
+  apiKey: process.env.QUEUEDASH_API_KEY,
+});
+
+attachToBull(myQueue, queueDash);
+```
+
+### Bee-Queue
+
+```typescript
+import Queue from "bee-queue";
+import { QueueDashClient, attachToBeeQueue } from "@queuedash/sdk";
+
+const myQueue = new Queue("my-queue", {
+  redis: { host: "localhost", port: 6379 },
+});
+
+const queueDash = new QueueDashClient({
+  apiKey: process.env.QUEUEDASH_API_KEY,
+});
+
+attachToBeeQueue(myQueue, queueDash);
+```
+
+## Configuration
+
+### API Key
+
+Get your API key from [QueueDash](https://queuedash.com):
+
+1. Navigate to your environment settings
+2. Click "API Keys"
+3. Generate a new API key
+
+```bash
+# Set in your environment
+QUEUEDASH_API_KEY=sk_live_...
+```
+
+### Advanced Options
+
+```typescript
+interface QueueDashClientOptions {
+  // Required: Your API key from QueueDash
+  apiKey: string;
+
+  // Optional: Batch size for syncing jobs (defaults to 50)
+  batchSize?: number;
+
+  // Optional: Flush interval in milliseconds (defaults to 100)
+  flushInterval?: number;
+
+  // Optional: Max retry attempts with exponential backoff (defaults to 5)
+  maxRetries?: number;
+
+  // Optional: Request timeout in milliseconds (defaults to 30000)
+  requestTimeout?: number;
+
+  // Optional: Max jobs to queue in memory (defaults to 10000)
+  maxQueueSize?: number;
+
+  // Optional: Error handler called on critical failures
+  onError?: (error: Error) => void;
+}
+```
+
+### Reliability & Robustness
+
+The SDK is production-ready with multiple layers of protection:
+
+**Retry Logic**
+
+- Automatic retries up to 5 times (configurable)
+- Exponential backoff: 1s → 2s → 4s → 8s → 16s → 30s (capped)
+- Jobs preserved in local queue until successfully synced
+
+**Circuit Breaker**
+
+- Opens after 10 consecutive failures to prevent overwhelming the API
+- Auto-resets after 60 seconds
+- Prevents cascading failures
+
+**Memory Protection**
+
+- Queue size limit (10,000 jobs default) prevents memory leaks
+- Oldest jobs dropped first if limit reached
+- Warning logged when queue limit hit
+
+**Graceful Shutdown**
+
+- SIGTERM/SIGINT handlers flush pending jobs before exit
+- Warns if jobs remain unsynced on crash
+- No jobs lost during normal shutdown
+
+**Request Safety**
+
+- 30-second timeout on all HTTP requests
+- Duplicate detection prevents same job syncing twice
+- Network errors handled gracefully
+
+## Features
+
+- **Real-time sync**: Jobs are synced as events happen
+- **Smart batching**: Events are automatically batched for performance
+- **Auto-retry**: Failed syncs are automatically retried
+- **Zero config**: Works out of the box with sensible defaults
+- **TypeScript**: Full TypeScript support
+
+## How It Works
+
+The SDK automatically syncs your queue jobs to QueueDash's SaaS platform at `api.queuedash.com`. Just provide your API key and you're done - no additional configuration needed!
+
+## License
+
+MIT

package/dist/client.d.ts

@@ -0,0 +1,37 @@
+import { JobData, QueueDashClientOptions } from "./types";
+export declare class QueueDashClient {
+    private apiKey;
+    private apiUrl;
+    private batchSize;
+    private flushInterval;
+    private maxRetries;
+    private requestTimeout;
+    private maxQueueSize;
+    private onError?;
+    private jobQueue;
+    private flushTimer?;
+    private isFlushing;
+    private retryCount;
+    private circuitBreakerFailures;
+    private circuitBreakerOpen;
+    private circuitBreakerResetTimer?;
+    private syncingJobIds;
+    constructor(options: QueueDashClientOptions);
+    /**
+     * Queue a job for syncing
+     */
+    syncJob(job: JobData): void;
+    /**
+     * Manually flush all pending jobs
+     */
+    flush(): Promise<void>;
+    private openCircuitBreaker;
+    private logger;
+    /**
+     * Stop the client and flush remaining jobs
+     */
+    stop(): Promise<void>;
+    private startFlushTimer;
+    private setupShutdownHandlers;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,sBAAsB,EAAgB,MAAM,SAAS,CAAC;AAExE,qBAAa,eAAe;IAC1B,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,OAAO,CAAC,CAAyB;IAEzC,OAAO,CAAC,QAAQ,CAAiB;IACjC,OAAO,CAAC,UAAU,CAAC,CAAiB;IACpC,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,sBAAsB,CAAK;IACnC,OAAO,CAAC,kBAAkB,CAAS;IACnC,OAAO,CAAC,wBAAwB,CAAC,CAAiB;IAClD,OAAO,CAAC,aAAa,CAAqB;gBAE9B,OAAO,EAAE,sBAAsB;IA0B3C;;OAEG;IACI,OAAO,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI;IA8BlC;;OAEG;IACU,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAyGnC,OAAO,CAAC,kBAAkB;IAoB1B,OAAO,CAAC,MAAM;IASd;;OAEG;IACU,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAUlC,OAAO,CAAC,eAAe;IAavB,OAAO,CAAC,qBAAqB;CAkB9B"}

package/dist/client.js

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueueDashClient = void 0;
+class QueueDashClient {
+    constructor(options) {
+        this.jobQueue = [];
+        this.isFlushing = false;
+        this.retryCount = 0;
+        this.circuitBreakerFailures = 0;
+        this.circuitBreakerOpen = false;
+        this.syncingJobIds = new Set();
+        if (!options.apiKey) {
+            throw new Error("QueueDash: apiKey is required");
+        }
+        this.apiKey = options.apiKey;
+        // Hardcoded SaaS API URL - can be overridden for staging only
+        this.apiUrl =
+            options.__dangerouslyOverrideApiUrl ||
+                (process.env.NODE_ENV === "production"
+                    ? "https://api.queuedash.com"
+                    : "http://localhost:4001");
+        this.batchSize = options.batchSize || 50;
+        this.flushInterval = options.flushInterval || 100; // ms
+        this.maxRetries = options.maxRetries || 5;
+        this.requestTimeout = options.requestTimeout || 30000; // 30s default
+        this.maxQueueSize = options.maxQueueSize || 10000; // Prevent memory issues
+        this.onError = options.onError;
+        // Start auto-flush timer
+        this.startFlushTimer();
+        // Graceful shutdown handlers
+        this.setupShutdownHandlers();
+    }
+    /**
+     * Queue a job for syncing
+     */
+    syncJob(job) {
+        // Check circuit breaker
+        if (this.circuitBreakerOpen) {
+            this.logger("Circuit breaker open, dropping job");
+            return;
+        }
+        // Prevent duplicate syncs of same job
+        const jobKey = `${job.queueName}:${job.jobId}`;
+        if (this.syncingJobIds.has(jobKey)) {
+            return;
+        }
+        this.syncingJobIds.add(jobKey);
+        // Prevent memory leak - drop oldest jobs if queue too large
+        if (this.jobQueue.length >= this.maxQueueSize) {
+            const dropped = this.jobQueue.shift();
+            this.logger(`Queue size limit reached (${this.maxQueueSize}), dropping oldest job: ${dropped?.jobId}`);
+        }
+        this.jobQueue.push(job);
+        // Flush if batch size reached
+        if (this.jobQueue.length >= this.batchSize) {
+            this.flush();
+        }
+    }
+    /**
+     * Manually flush all pending jobs
+     */
+    async flush() {
+        if (this.isFlushing ||
+            this.jobQueue.length === 0 ||
+            this.circuitBreakerOpen) {
+            return;
+        }
+        this.isFlushing = true;
+        const jobsToSync = [...this.jobQueue];
+        this.jobQueue = [];
+        try {
+            // Add timeout to fetch
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), this.requestTimeout);
+            const response = await fetch(`${this.apiUrl}/api/v1/jobs/sync`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${this.apiKey}`,
+                },
+                body: JSON.stringify({
+                    jobs: jobsToSync,
+                }),
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`HTTP ${response.status}: ${errorText}`);
+            }
+            const result = (await response.json());
+            if (!result.success && result.errors) {
+                console.warn("QueueDash: Some jobs failed to sync:", result.errors);
+            }
+            // Success - reset counters and clear syncing jobs
+            this.retryCount = 0;
+            this.circuitBreakerFailures = 0;
+            jobsToSync.forEach((job) => {
+                this.syncingJobIds.delete(`${job.queueName}:${job.jobId}`);
+            });
+        }
+        catch (error) {
+            this.retryCount++;
+            this.circuitBreakerFailures++;
+            const err = error instanceof Error ? error : new Error(String(error));
+            // Circuit breaker - open after 10 consecutive failures
+            if (this.circuitBreakerFailures >= 10) {
+                this.openCircuitBreaker();
+            }
+            // Check if we should retry
+            if (this.retryCount <= this.maxRetries) {
+                // Put jobs back in queue for retry with exponential backoff
+                this.jobQueue.unshift(...jobsToSync);
+                const backoffMs = Math.min(1000 * Math.pow(2, this.retryCount - 1), 30000); // Max 30s
+                this.logger(`Retry ${this.retryCount}/${this.maxRetries} after ${backoffMs}ms`, err);
+                // Schedule retry
+                setTimeout(() => {
+                    if (this.jobQueue.length > 0) {
+                        this.flush();
+                    }
+                }, backoffMs);
+            }
+            else {
+                // Max retries reached - clear syncing jobs and alert
+                this.retryCount = 0;
+                jobsToSync.forEach((job) => {
+                    this.syncingJobIds.delete(`${job.queueName}:${job.jobId}`);
+                });
+                const errorMsg = `Failed to sync ${jobsToSync.length} jobs after ${this.maxRetries} retries`;
+                if (this.onError) {
+                    this.onError(new Error(`${errorMsg}: ${err.message}`));
+                }
+                else {
+                    console.error(`QueueDash: ${errorMsg}`, err);
+                }
+            }
+        }
+        finally {
+            this.isFlushing = false;
+        }
+    }
+    openCircuitBreaker() {
+        if (this.circuitBreakerOpen)
+            return;
+        this.circuitBreakerOpen = true;
+        console.error("QueueDash: Circuit breaker opened after 10 consecutive failures. Will retry in 60s.");
+        // Auto-reset after 60 seconds
+        this.circuitBreakerResetTimer = setTimeout(() => {
+            this.circuitBreakerOpen = false;
+            this.circuitBreakerFailures = 0;
+            console.log("QueueDash: Circuit breaker reset, resuming sync attempts");
+        }, 60000);
+        if (this.circuitBreakerResetTimer.unref) {
+            this.circuitBreakerResetTimer.unref();
+        }
+    }
+    logger(message, error) {
+        if (this.onError && error) {
+            // If onError is provided, use it for warnings too
+            console.warn(`QueueDash: ${message}`, error);
+        }
+        else {
+            console.warn(`QueueDash: ${message}`);
+        }
+    }
+    /**
+     * Stop the client and flush remaining jobs
+     */
+    async stop() {
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+        }
+        if (this.circuitBreakerResetTimer) {
+            clearTimeout(this.circuitBreakerResetTimer);
+        }
+        await this.flush();
+    }
+    startFlushTimer() {
+        this.flushTimer = setInterval(() => {
+            if (this.jobQueue.length > 0) {
+                this.flush();
+            }
+        }, this.flushInterval);
+        // Don't keep process alive
+        if (this.flushTimer.unref) {
+            this.flushTimer.unref();
+        }
+    }
+    setupShutdownHandlers() {
+        const shutdown = async () => {
+            console.log("QueueDash: Graceful shutdown - flushing remaining jobs...");
+            await this.stop();
+            process.exit(0);
+        };
+        // Handle graceful shutdown
+        process.once("SIGTERM", shutdown);
+        process.once("SIGINT", shutdown);
+        process.once("beforeExit", () => {
+            if (this.jobQueue.length > 0) {
+                console.warn(`QueueDash: Process exiting with ${this.jobQueue.length} unsync'd jobs`);
+            }
+        });
+    }
+}
+exports.QueueDashClient = QueueDashClient;

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { QueueDashClient } from "./client";
+export { attachToBullMQ } from "./integrations/bullmq";
+export { attachToBull } from "./integrations/bull";
+export { attachToBeeQueue } from "./integrations/bee";
+export type { QueueDashClientOptions, JobData, SyncResponse } from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAC3C,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,YAAY,EAAE,sBAAsB,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attachToBeeQueue = exports.attachToBull = exports.attachToBullMQ = exports.QueueDashClient = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "QueueDashClient", { enumerable: true, get: function () { return client_1.QueueDashClient; } });
+var bullmq_1 = require("./integrations/bullmq");
+Object.defineProperty(exports, "attachToBullMQ", { enumerable: true, get: function () { return bullmq_1.attachToBullMQ; } });
+var bull_1 = require("./integrations/bull");
+Object.defineProperty(exports, "attachToBull", { enumerable: true, get: function () { return bull_1.attachToBull; } });
+var bee_1 = require("./integrations/bee");
+Object.defineProperty(exports, "attachToBeeQueue", { enumerable: true, get: function () { return bee_1.attachToBeeQueue; } });

package/dist/integrations/bee.d.ts

@@ -0,0 +1,8 @@
+import { QueueDashClient } from "../client";
+type BeeQueue = any;
+/**
+ * Attach QueueDash monitoring to a Bee-Queue
+ */
+export declare function attachToBeeQueue(queue: BeeQueue, client: QueueDashClient): void;
+export {};
+//# sourceMappingURL=bee.d.ts.map

package/dist/integrations/bee.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bee.d.ts","sourceRoot":"","sources":["../../src/integrations/bee.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAG5C,KAAK,QAAQ,GAAG,GAAG,CAAC;AAGpB;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,QAAQ,EACf,MAAM,EAAE,eAAe,GACtB,IAAI,CAwCN"}

package/dist/integrations/bee.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attachToBeeQueue = attachToBeeQueue;
+/**
+ * Attach QueueDash monitoring to a Bee-Queue
+ */
+function attachToBeeQueue(queue, client) {
+    const queueName = queue.name;
+    const extractJobData = (job) => {
+        return {
+            jobId: String(job.id),
+            name: "default", // Bee-Queue doesn't have job names
+            queueName,
+            data: job.data,
+            opts: job.options || {},
+            addedAt: job.options?.timestamp
+                ? new Date(job.options.timestamp)
+                : new Date(),
+            processedAt: null,
+            finishedAt: null,
+            priority: null,
+            delay: job.options?.delay,
+        };
+    };
+    // Listen to queue events
+    queue.on("succeeded", (job) => {
+        const jobData = extractJobData(job);
+        jobData.finishedAt = new Date();
+        client.syncJob(jobData);
+    });
+    queue.on("failed", (job, err) => {
+        const jobData = extractJobData(job);
+        jobData.failedReason = err.message;
+        jobData.stacktrace = err.stack ? [err.stack] : undefined;
+        jobData.finishedAt = new Date();
+        client.syncJob(jobData);
+    });
+    queue.on("retrying", (job) => {
+        const jobData = extractJobData(job);
+        jobData.retriedAt = new Date();
+        client.syncJob(jobData);
+    });
+}

package/dist/integrations/bull.d.ts

@@ -0,0 +1,8 @@
+import { QueueDashClient } from "../client";
+type BullQueue = any;
+/**
+ * Attach QueueDash monitoring to a Bull queue
+ */
+export declare function attachToBull(queue: BullQueue, client: QueueDashClient): void;
+export {};
+//# sourceMappingURL=bull.d.ts.map

package/dist/integrations/bull.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bull.d.ts","sourceRoot":"","sources":["../../src/integrations/bull.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAG5C,KAAK,SAAS,GAAG,GAAG,CAAC;AAGrB;;GAEG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CA4C5E"}

package/dist/integrations/bull.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attachToBull = attachToBull;
+/**
+ * Attach QueueDash monitoring to a Bull queue
+ */
+function attachToBull(queue, client) {
+    const queueName = queue.name;
+    const extractJobData = (job) => {
+        return {
+            jobId: job.id,
+            name: job.name || "default",
+            queueName,
+            data: job.data,
+            opts: job.opts,
+            addedAt: new Date(job.timestamp),
+            processedAt: job.processedOn ? new Date(job.processedOn) : null,
+            finishedAt: job.finishedOn ? new Date(job.finishedOn) : null,
+            failedReason: job.failedReason,
+            stacktrace: job.stacktrace,
+            priority: job.opts?.priority,
+            delay: job.opts?.delay,
+            timestamp: job.timestamp,
+            progress: job._progress || null,
+        };
+    };
+    // Listen to queue events
+    queue.on("completed", (job) => {
+        client.syncJob(extractJobData(job));
+    });
+    queue.on("failed", (job) => {
+        if (job) {
+            client.syncJob(extractJobData(job));
+        }
+    });
+    queue.on("active", (job) => {
+        client.syncJob(extractJobData(job));
+    });
+    queue.on("progress", (job) => {
+        client.syncJob(extractJobData(job));
+    });
+    queue.on("removed", (job) => {
+        client.syncJob(extractJobData(job));
+    });
+}

package/dist/integrations/bullmq.d.ts

@@ -0,0 +1,8 @@
+import { QueueDashClient } from "../client";
+type BullMQQueue = any;
+/**
+ * Attach QueueDash monitoring to a BullMQ queue
+ */
+export declare function attachToBullMQ(queue: BullMQQueue, client: QueueDashClient): void;
+export {};
+//# sourceMappingURL=bullmq.d.ts.map

package/dist/integrations/bullmq.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bullmq.d.ts","sourceRoot":"","sources":["../../src/integrations/bullmq.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAG5C,KAAK,WAAW,GAAG,GAAG,CAAC;AAGvB;;GAEG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,WAAW,EAClB,MAAM,EAAE,eAAe,GACtB,IAAI,CA6CN"}

package/dist/integrations/bullmq.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attachToBullMQ = attachToBullMQ;
+/**
+ * Attach QueueDash monitoring to a BullMQ queue
+ */
+function attachToBullMQ(queue, client) {
+    const queueName = queue.name;
+    const extractJobData = (job) => {
+        return {
+            jobId: job.id,
+            name: job.name,
+            queueName,
+            data: job.data,
+            opts: job.opts,
+            addedAt: new Date(job.timestamp),
+            processedAt: job.processedOn ? new Date(job.processedOn) : null,
+            finishedAt: job.finishedOn ? new Date(job.finishedOn) : null,
+            failedReason: job.failedReason,
+            stacktrace: job.stacktrace,
+            retriedAt: job.retriedAt ? new Date(job.retriedAt) : null,
+            priority: job.opts?.priority,
+            delay: job.opts?.delay,
+            timestamp: job.timestamp,
+            progress: job.progress || null,
+        };
+    };
+    // Listen to queue events
+    queue.on("completed", (job) => {
+        client.syncJob(extractJobData(job));
+    });
+    queue.on("failed", (job) => {
+        if (job) {
+            client.syncJob(extractJobData(job));
+        }
+    });
+    queue.on("active", (job) => {
+        client.syncJob(extractJobData(job));
+    });
+    queue.on("progress", (job) => {
+        client.syncJob(extractJobData(job));
+    });
+    queue.on("removed", (job) => {
+        client.syncJob(extractJobData(job));
+    });
+}

package/dist/types.d.ts

@@ -0,0 +1,35 @@
+export interface QueueDashClientOptions {
+    apiKey: string;
+    batchSize?: number;
+    flushInterval?: number;
+    maxRetries?: number;
+    requestTimeout?: number;
+    maxQueueSize?: number;
+    onError?: (error: Error) => void;
+    /** @internal - Not for public use. Override API URL for staging environments only. */
+    __dangerouslyOverrideApiUrl?: string;
+}
+export interface JobData {
+    jobId: string;
+    name: string;
+    queueName: string;
+    data?: Record<string, unknown>;
+    opts?: Record<string, unknown>;
+    addedAt: Date;
+    processedAt?: Date | null;
+    finishedAt?: Date | null;
+    failedReason?: string;
+    stacktrace?: string[];
+    logs?: string[];
+    retriedAt?: Date | null;
+    priority?: number | null;
+    delay?: number | null;
+    timestamp?: number | null;
+    progress?: number | null;
+}
+export interface SyncResponse {
+    success: boolean;
+    synced: number;
+    errors?: string[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACjC,sFAAsF;IACtF,2BAA2B,CAAC,EAAE,MAAM,CAAC;CACtC;AAED,MAAM,WAAW,OAAO;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,OAAO,EAAE,IAAI,CAAC;IACd,WAAW,CAAC,EAAE,IAAI,GAAG,IAAI,CAAC;IAC1B,UAAU,CAAC,EAAE,IAAI,GAAG,IAAI,CAAC;IACzB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,SAAS,CAAC,EAAE,IAAI,GAAG,IAAI,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;CACnB"}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@queuedash/sdk",
+  "version": "0.1.0",
+  "description": "QueueDash SDK for real-time queue monitoring",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "keywords": [
+    "queue",
+    "bullmq",
+    "bull",
+    "bee-queue",
+    "monitoring",
+    "dashboard"
+  ],
+  "author": "QueueDash",
+  "license": "MIT",
+  "peerDependencies": {
+    "bullmq": ">=3.0.0",
+    "bull": ">=4.0.0",
+    "bee-queue": ">=1.0.0"
+  },
+  "peerDependenciesMeta": {
+    "bullmq": {
+      "optional": true
+    },
+    "bull": {
+      "optional": true
+    },
+    "bee-queue": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.9.3"
+  },
+  "scripts": {
+    "build": "tsc"
+  }
+}