@nebutra/queue 0.1.0 → 0.1.2

package/dist/providers/qstash.js

@@ -0,0 +1,226 @@
+import { logger } from "@nebutra/logger";
+import { Client } from "@upstash/qstash";
+import { JobPayloadSchema } from "../types";
+// =============================================================================
+// QStash Provider — Upstash serverless message queue
+// =============================================================================
+// QStash works by POSTing job payloads to your API endpoints.
+// You register HTTP route handlers (e.g. /api/queue/:type) that QStash calls.
+//
+// Architecture:
+//   enqueue()  →  QStash API (publish)  →  HTTP POST to callbackBaseUrl/api/queue/:type
+//   Your API route verifies the QStash signature and processes the job.
+// =============================================================================
+/**
+ * Handlers registered via `registerHandler` are stored here so the
+ * HTTP verification middleware can look them up at request time.
+ */
+const handlerRegistry = new Map();
+/**
+ * Get a registered handler by its composite key (`queue:type`).
+ * Used by the QStash webhook verification middleware.
+ */
+export function getQStashHandler(queue, type) {
+    return handlerRegistry.get(`${queue}:${type}`);
+}
+/**
+ * Get ALL registered handlers (for introspection / health checks).
+ */
+export function getQStashHandlerKeys() {
+    return [...handlerRegistry.keys()];
+}
+function readString(value) {
+    if (typeof value === "string" && value.length > 0)
+        return value;
+    if (Array.isArray(value))
+        return readString(value[0]);
+    return undefined;
+}
+function readNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function readHeader(headers, name) {
+    if (!headers || typeof headers !== "object")
+        return undefined;
+    const entries = Object.entries(headers);
+    const match = entries.find(([key]) => key.toLowerCase() === name.toLowerCase());
+    return match ? readString(match[1]) : undefined;
+}
+function parseOriginalJob(record) {
+    const rawBody = readString(record.body);
+    if (!rawBody)
+        return undefined;
+    try {
+        return JobPayloadSchema.parse(JSON.parse(rawBody));
+    }
+    catch {
+        return undefined;
+    }
+}
+function readFailedAt(record) {
+    const failedAt = readString(record.failedAt) ?? readString(record.time);
+    if (failedAt)
+        return failedAt;
+    const timestamp = readNumber(record.failedAt) ?? readNumber(record.time) ?? readNumber(record.createdAt);
+    return timestamp ? new Date(timestamp).toISOString() : new Date().toISOString();
+}
+function readFailedReason(record) {
+    return (readString(record.failedReason) ??
+        readString(record.error) ??
+        readString(record.responseBody) ??
+        (readNumber(record.responseStatus) ? `HTTP ${readNumber(record.responseStatus)}` : undefined) ??
+        "QStash delivery failed");
+}
+export function toQStashDeadLetterJob(record) {
+    const originalJob = parseOriginalJob(record);
+    if (!originalJob)
+        return undefined;
+    const headerJobId = readHeader(record.header, "x-nebutra-job-id");
+    const headerJobType = readHeader(record.header, "x-nebutra-job-type");
+    const maxRetries = readNumber(record.maxRetries) ?? originalJob.options?.maxRetries ?? 0;
+    return {
+        id: originalJob.id || headerJobId || readString(record.messageId) || "unknown",
+        queue: originalJob.queue,
+        type: originalJob.type || headerJobType || "unknown",
+        originalJob,
+        attempts: readNumber(record.attempts) ?? maxRetries + 1,
+        maxRetries,
+        failedReason: readFailedReason(record),
+        provider: "qstash",
+        failedAt: readFailedAt(record),
+    };
+}
+export class QStashProvider {
+    name = "qstash";
+    client;
+    callbackBaseUrl;
+    token;
+    dlqEndpoint;
+    dlqFetcher;
+    constructor(config) {
+        const token = config.token ?? process.env.QSTASH_TOKEN;
+        if (!token) {
+            throw new Error("QStash token not configured. Set QSTASH_TOKEN env var or pass `token` in config.");
+        }
+        this.token = token;
+        this.client = new Client({ token });
+        this.callbackBaseUrl = config.callbackBaseUrl.replace(/\/$/, "");
+        this.dlqEndpoint = config.dlqEndpoint;
+        this.dlqFetcher = config.dlqFetcher;
+        logger.info("[queue:qstash] Provider initialised", {
+            callbackBaseUrl: this.callbackBaseUrl,
+        });
+    }
+    // ── Enqueue ─────────────────────────────────────────────────────────────
+    async enqueue(job) {
+        const destination = `${this.callbackBaseUrl}/api/queue/${job.queue}/${job.type}`;
+        try {
+            const response = await this.client.publishJSON({
+                url: destination,
+                body: job,
+                ...(job.options?.idempotencyKey !== undefined
+                    ? { deduplicationId: job.options.idempotencyKey }
+                    : {}),
+                ...(job.options?.delaySec ? { delay: job.options.delaySec } : {}),
+                retries: job.options?.maxRetries ?? 3,
+                ...(job.options?.cron ? { cron: job.options.cron } : {}),
+                headers: {
+                    "x-nebutra-queue": job.queue,
+                    "x-nebutra-job-type": job.type,
+                    "x-nebutra-job-id": job.id,
+                    ...(job.options?.tenantId ? { "x-nebutra-tenant-id": job.options.tenantId } : {}),
+                },
+            });
+            const messageId = "messageId" in response ? response.messageId : job.id;
+            logger.info("[queue:qstash] Job enqueued", {
+                jobId: job.id,
+                messageId,
+                destination,
+            });
+            return {
+                jobId: messageId,
+                accepted: true,
+                provider: "qstash",
+            };
+        }
+        catch (error) {
+            logger.error("[queue:qstash] Failed to enqueue job", {
+                jobId: job.id,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+    }
+    async enqueueBatch(jobs) {
+        // QStash supports batch publish — use it for efficiency
+        try {
+            const messages = jobs.map((job) => ({
+                url: `${this.callbackBaseUrl}/api/queue/${job.queue}/${job.type}`,
+                body: JSON.stringify(job),
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-nebutra-queue": job.queue,
+                    "x-nebutra-job-type": job.type,
+                    "x-nebutra-job-id": job.id,
+                    ...(job.options?.tenantId ? { "x-nebutra-tenant-id": job.options.tenantId } : {}),
+                },
+                ...(job.options?.idempotencyKey !== undefined
+                    ? { deduplicationId: job.options.idempotencyKey }
+                    : {}),
+                retries: job.options?.maxRetries ?? 3,
+            }));
+            const responses = await this.client.batchJSON(messages);
+            logger.info("[queue:qstash] Batch enqueued", { count: jobs.length });
+            return responses.map((r, idx) => ({
+                jobId: "messageId" in r ? r.messageId : (jobs[idx]?.id ?? ""),
+                accepted: true,
+                provider: "qstash",
+            }));
+        }
+        catch (error) {
+            logger.error("[queue:qstash] Batch enqueue failed, falling back to sequential", {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            // Fallback: sequential enqueue
+            const results = [];
+            for (const job of jobs) {
+                results.push(await this.enqueue(job));
+            }
+            return results;
+        }
+    }
+    // ── Handler Registration ────────────────────────────────────────────────
+    registerHandler(queue, type, handler) {
+        const key = `${queue}:${type}`;
+        handlerRegistry.set(key, handler);
+        logger.info("[queue:qstash] Handler registered", { key });
+    }
+    async getDeadLetteredJobs(queue) {
+        if (!this.dlqFetcher) {
+            logger.warn("[queue:qstash] DLQ fetcher not configured; returning empty dead-letter list");
+            return [];
+        }
+        try {
+            const records = await this.dlqFetcher({
+                token: this.token,
+                ...(this.dlqEndpoint !== undefined ? { endpoint: this.dlqEndpoint } : {}),
+                ...(queue !== undefined ? { queue } : {}),
+            });
+            return records
+                .map(toQStashDeadLetterJob)
+                .filter((job) => Boolean(job))
+                .filter((job) => queue === undefined || job.queue === queue);
+        }
+        catch (error) {
+            logger.error("[queue:qstash] Failed to fetch dead-letter jobs", {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return [];
+        }
+    }
+    // ── Lifecycle ───────────────────────────────────────────────────────────
+    async close() {
+        handlerRegistry.clear();
+        logger.info("[queue:qstash] Provider closed");
+    }
+}

package/dist/providers/sqs.d.ts

@@ -0,0 +1,18 @@
+import type { JobHandler, JobPayload, JobResult, QueueProvider, SQSProviderConfig } from "../types";
+export declare class SQSProvider implements QueueProvider {
+    readonly name: "sqs";
+    private client;
+    private queueUrl;
+    private waitTimeSeconds;
+    private maxMessages;
+    private visibilityTimeoutSeconds;
+    constructor(config: Omit<SQSProviderConfig, "provider">);
+    enqueue(job: JobPayload): Promise<JobResult>;
+    enqueueBatch(jobs: JobPayload[]): Promise<JobResult[]>;
+    registerHandler<T extends Record<string, unknown>>(queue: string, type: string, handler: JobHandler<T>): void;
+    private pollLoop;
+    private dispatch;
+    private deleteMessage;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=sqs.d.ts.map

package/dist/providers/sqs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqs.d.ts","sourceRoot":"","sources":["../../src/providers/sqs.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AA6BpG,qBAAa,WAAY,YAAW,aAAa;IAC/C,QAAQ,CAAC,IAAI,EAAG,KAAK,CAAU;IAE/B,OAAO,CAAC,MAAM,CAAY;IAC1B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,eAAe,CAAS;IAChC,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,wBAAwB,CAAS;gBAE7B,MAAM,EAAE,IAAI,CAAC,iBAAiB,EAAE,UAAU,CAAC;IA+BjD,OAAO,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC;IAmC5C,YAAY,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IA6C5D,eAAe,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/C,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,UAAU,CAAC,CAAC,CAAC,GACrB,IAAI;YAgBO,QAAQ;YAgCR,QAAQ;YAmCR,aAAa;IAcrB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAM7B"}

package/dist/providers/sqs.js

@@ -0,0 +1,197 @@
+import { DeleteMessageCommand, ReceiveMessageCommand, SendMessageBatchCommand, SendMessageCommand, SQSClient, } from "@aws-sdk/client-sqs";
+import { logger } from "@nebutra/logger";
+const handlerRegistry = new Map();
+function handlerKey(queue, type) {
+    return `${queue}:${type}`;
+}
+export class SQSProvider {
+    name = "sqs";
+    client;
+    queueUrl;
+    waitTimeSeconds;
+    maxMessages;
+    visibilityTimeoutSeconds;
+    constructor(config) {
+        const region = config.region ?? process.env.AWS_REGION;
+        const queueUrl = config.queueUrl ?? process.env.AWS_SQS_QUEUE_URL;
+        if (!region) {
+            throw new Error("SQS region not configured. Set AWS_REGION env var or pass `region`.");
+        }
+        if (!queueUrl) {
+            throw new Error("SQS queue URL not configured. Set AWS_SQS_QUEUE_URL env var or pass `queueUrl`.");
+        }
+        const accessKeyId = config.accessKeyId ?? process.env.AWS_ACCESS_KEY_ID;
+        const secretAccessKey = config.secretAccessKey ?? process.env.AWS_SECRET_ACCESS_KEY;
+        this.client = new SQSClient({
+            region,
+            // If explicit creds provided, use them; otherwise AWS SDK uses default
+            // chain (IAM role on EC2/ECS/Lambda, ~/.aws/credentials, env, etc.).
+            ...(accessKeyId && secretAccessKey ? { credentials: { accessKeyId, secretAccessKey } } : {}),
+        });
+        this.queueUrl = queueUrl;
+        this.waitTimeSeconds = config.waitTimeSeconds ?? 20;
+        this.maxMessages = config.maxMessages ?? 10;
+        this.visibilityTimeoutSeconds = config.visibilityTimeoutSeconds ?? 30;
+        logger.info("[queue:sqs] Provider initialised", { region, queueUrl: queueUrl.slice(0, 60) });
+    }
+    // ── Enqueue ─────────────────────────────────────────────────────────────
+    async enqueue(job) {
+        try {
+            const response = await this.client.send(new SendMessageCommand({
+                QueueUrl: this.queueUrl,
+                MessageBody: JSON.stringify(job),
+                ...(job.options?.delaySec ? { DelaySeconds: Math.min(job.options.delaySec, 900) } : {}),
+                ...(job.options?.idempotencyKey
+                    ? {
+                        // FIFO queues use deduplication ID; standard queues ignore it.
+                        MessageDeduplicationId: job.options.idempotencyKey,
+                        MessageGroupId: job.queue,
+                    }
+                    : {}),
+            }));
+            const messageId = response.MessageId ?? job.id;
+            logger.info("[queue:sqs] Job enqueued", { jobId: job.id, messageId });
+            return {
+                jobId: messageId,
+                accepted: true,
+                provider: "sqs",
+            };
+        }
+        catch (error) {
+            logger.error("[queue:sqs] Failed to enqueue job", {
+                jobId: job.id,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+    }
+    async enqueueBatch(jobs) {
+        // SQS SendMessageBatch caps at 10 entries per request — chunk if needed.
+        const results = [];
+        for (let i = 0; i < jobs.length; i += 10) {
+            const chunk = jobs.slice(i, i + 10);
+            try {
+                const response = await this.client.send(new SendMessageBatchCommand({
+                    QueueUrl: this.queueUrl,
+                    Entries: chunk.map((job, idx) => ({
+                        Id: `msg-${idx}-${Date.now()}`,
+                        MessageBody: JSON.stringify(job),
+                        ...(job.options?.delaySec
+                            ? { DelaySeconds: Math.min(job.options.delaySec, 900) }
+                            : {}),
+                    })),
+                }));
+                const successful = response.Successful ?? [];
+                for (let j = 0; j < chunk.length; j++) {
+                    const ok = successful[j];
+                    results.push({
+                        jobId: ok?.MessageId ?? chunk[j]?.id ?? "",
+                        accepted: Boolean(ok),
+                        provider: "sqs",
+                    });
+                }
+            }
+            catch (error) {
+                logger.error("[queue:sqs] Batch enqueue failed, falling back to sequential", {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                for (const job of chunk) {
+                    try {
+                        results.push(await this.enqueue(job));
+                    }
+                    catch {
+                        results.push({ jobId: job.id, accepted: false, provider: "sqs" });
+                    }
+                }
+            }
+        }
+        return results;
+    }
+    // ── Handler Registration & Poll Loop ─────────────────────────────────────
+    registerHandler(queue, type, handler) {
+        const key = handlerKey(queue, type);
+        if (handlerRegistry.has(key)) {
+            logger.warn("[queue:sqs] Handler already registered, replacing", { key });
+            const existing = handlerRegistry.get(key);
+            existing?.abort.abort();
+        }
+        const abort = new AbortController();
+        handlerRegistry.set(key, { handler: handler, abort });
+        void this.pollLoop(queue, type, handler, abort.signal);
+        logger.info("[queue:sqs] Handler registered + poll loop started", { key });
+    }
+    async pollLoop(queue, type, handler, signal) {
+        while (!signal.aborted) {
+            try {
+                const response = await this.client.send(new ReceiveMessageCommand({
+                    QueueUrl: this.queueUrl,
+                    MaxNumberOfMessages: this.maxMessages,
+                    WaitTimeSeconds: this.waitTimeSeconds,
+                    VisibilityTimeout: this.visibilityTimeoutSeconds,
+                }));
+                const messages = response.Messages ?? [];
+                for (const msg of messages) {
+                    if (signal.aborted)
+                        break;
+                    await this.dispatch(msg, queue, type, handler);
+                }
+            }
+            catch (error) {
+                if (signal.aborted)
+                    break;
+                logger.error("[queue:sqs] Poll error, sleeping 5s", {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                await new Promise((r) => setTimeout(r, 5000));
+            }
+        }
+    }
+    async dispatch(msg, queue, type, handler) {
+        if (!msg.Body || !msg.ReceiptHandle)
+            return;
+        let job;
+        try {
+            job = JSON.parse(msg.Body);
+        }
+        catch {
+            logger.error("[queue:sqs] Malformed message body, deleting", { messageId: msg.MessageId });
+            await this.deleteMessage(msg.ReceiptHandle);
+            return;
+        }
+        if (job.queue !== queue || job.type !== type) {
+            // Not for this handler — leave it for whoever owns it. Visibility timeout
+            // will expire and another consumer can pick it up.
+            return;
+        }
+        try {
+            await handler(job);
+            await this.deleteMessage(msg.ReceiptHandle);
+        }
+        catch (error) {
+            logger.error("[queue:sqs] Handler failed; message will be retried by SQS", {
+                jobId: job.id,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            // Don't delete — SQS will redeliver after visibility timeout.
+            // Configure a DLQ on the SQS queue side for terminal failure handling.
+        }
+    }
+    async deleteMessage(receiptHandle) {
+        try {
+            await this.client.send(new DeleteMessageCommand({ QueueUrl: this.queueUrl, ReceiptHandle: receiptHandle }));
+        }
+        catch (error) {
+            logger.error("[queue:sqs] DeleteMessage failed", {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    // ── Lifecycle ───────────────────────────────────────────────────────────
+    async close() {
+        for (const entry of handlerRegistry.values())
+            entry.abort.abort();
+        handlerRegistry.clear();
+        this.client.destroy();
+        logger.info("[queue:sqs] Provider closed");
+    }
+}

package/dist/queuebase-webhook.d.ts

@@ -0,0 +1,45 @@
+import { z } from "zod";
+export type QueuebaseBackoff = "fixed" | "exponential" | "linear";
+export interface QueuebaseScheduleConfig {
+    cron: string;
+    timezone?: string;
+    overlap?: "allow" | "skip";
+}
+export type QueuebaseSchedule = string | QueuebaseScheduleConfig;
+export interface QueuebaseJobContext<TInput> {
+    input: TInput;
+    jobId: string;
+    attempt: number;
+    maxAttempts: number;
+    fail: (reason: string) => never;
+}
+export interface QueuebaseJobDefinition<TSchema extends z.ZodTypeAny = z.ZodTypeAny, TResult = unknown> {
+    input: TSchema;
+    handler: (context: QueuebaseJobContext<z.output<TSchema>>) => Promise<TResult> | TResult;
+    defaults?: {
+        retries?: number;
+        backoff?: QueuebaseBackoff;
+    };
+    schedule?: QueuebaseSchedule;
+}
+export type QueuebaseJobRouter = Record<string, QueuebaseJobDefinition>;
+export interface QueuebaseWebhookOptions {
+    webhookSecret?: string;
+    signatureHeader?: string;
+}
+export interface QueuebaseScheduleMetadata {
+    name: string;
+    schedule: QueuebaseSchedule;
+}
+export declare function defineQueueJob<TSchema extends z.ZodTypeAny, TResult>(definition: QueuebaseJobDefinition<TSchema, TResult>): QueuebaseJobDefinition<TSchema, TResult>;
+export declare function createJobRouter<TRouter extends QueuebaseJobRouter>(router: TRouter): TRouter;
+export declare function createQueuebaseWebhookHandler<TRouter extends QueuebaseJobRouter>(router: TRouter, options?: QueuebaseWebhookOptions): (request: Request) => Promise<Response>;
+export declare function listQueuebaseSchedules<TRouter extends QueuebaseJobRouter>(router: TRouter): QueuebaseScheduleMetadata[];
+export declare const queuebaseJobs: {
+    invitationCleanup: QueuebaseJobDefinition<z.ZodObject<{}, z.core.$strip>, import("./scheduled").ScheduledJobResult>;
+    sessionCleanup: QueuebaseJobDefinition<z.ZodObject<{}, z.core.$strip>, import("./scheduled").ScheduledJobResult>;
+};
+export type QueuebaseJobs = typeof queuebaseJobs;
+export declare const queuebaseWebhookHandler: (request: Request) => Promise<Response>;
+export declare function verifyQueuebaseSignature(body: string, signature: string | null | undefined, secret: string): boolean;
+//# sourceMappingURL=queuebase-webhook.d.ts.map

package/dist/queuebase-webhook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queuebase-webhook.d.ts","sourceRoot":"","sources":["../src/queuebase-webhook.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,MAAM,MAAM,gBAAgB,GAAG,OAAO,GAAG,aAAa,GAAG,QAAQ,CAAC;AAElE,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;CAC5B;AAED,MAAM,MAAM,iBAAiB,GAAG,MAAM,GAAG,uBAAuB,CAAC;AAEjE,MAAM,WAAW,mBAAmB,CAAC,MAAM;IACzC,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,KAAK,CAAC;CACjC;AAED,MAAM,WAAW,sBAAsB,CACrC,OAAO,SAAS,CAAC,CAAC,UAAU,GAAG,CAAC,CAAC,UAAU,EAC3C,OAAO,GAAG,OAAO;IAEjB,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,CAAC,OAAO,EAAE,mBAAmB,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;IACzF,QAAQ,CAAC,EAAE;QACT,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,OAAO,CAAC,EAAE,gBAAgB,CAAC;KAC5B,CAAC;IACF,QAAQ,CAAC,EAAE,iBAAiB,CAAC;CAC9B;AAED,MAAM,MAAM,kBAAkB,GAAG,MAAM,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAC;AAExE,MAAM,WAAW,uBAAuB;IACtC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,yBAAyB;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,iBAAiB,CAAC;CAC7B;AAqBD,wBAAgB,cAAc,CAAC,OAAO,SAAS,CAAC,CAAC,UAAU,EAAE,OAAO,EAClE,UAAU,EAAE,sBAAsB,CAAC,OAAO,EAAE,OAAO,CAAC,GACnD,sBAAsB,CAAC,OAAO,EAAE,OAAO,CAAC,CAE1C;AAED,wBAAgB,eAAe,CAAC,OAAO,SAAS,kBAAkB,EAAE,MAAM,EAAE,OAAO,GAAG,OAAO,CAE5F;AAED,wBAAgB,6BAA6B,CAAC,OAAO,SAAS,kBAAkB,EAC9E,MAAM,EAAE,OAAO,EACf,OAAO,GAAE,uBAA4B,GACpC,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CAkEzC;AAED,wBAAgB,sBAAsB,CAAC,OAAO,SAAS,kBAAkB,EACvE,MAAM,EAAE,OAAO,GACd,yBAAyB,EAAE,CAQ7B;AAED,eAAO,MAAM,aAAa;;;CAWxB,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC;AAEjD,eAAO,MAAM,uBAAuB,YA/FvB,OAAO,KAAK,OAAO,CAAC,QAAQ,CAmGvC,CAAC;AAEH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACpC,MAAM,EAAE,MAAM,GACb,OAAO,CAUT"}

package/dist/queuebase-webhook.js

@@ -0,0 +1,113 @@
+import { createHmac, timingSafeEqual } from "node:crypto";
+import { z } from "zod";
+import { invitationCleanup, sessionCleanup } from "./scheduled";
+class QueuebaseFailure extends Error {
+    reason;
+    constructor(reason) {
+        super(reason);
+        this.reason = reason;
+        this.name = "QueuebaseFailure";
+    }
+}
+export function defineQueueJob(definition) {
+    return definition;
+}
+export function createJobRouter(router) {
+    return router;
+}
+export function createQueuebaseWebhookHandler(router, options = {}) {
+    return async (request) => {
+        if (request.method !== "POST") {
+            return Response.json({ ok: false, error: "Method not allowed" }, { status: 405 });
+        }
+        const body = await request.text();
+        const signatureHeader = options.signatureHeader ?? "x-queuebase-signature";
+        const secret = options.webhookSecret;
+        if (secret && !verifyQueuebaseSignature(body, request.headers.get(signatureHeader), secret)) {
+            return Response.json({ ok: false, error: "Invalid webhook signature" }, { status: 401 });
+        }
+        let payload;
+        try {
+            payload = JSON.parse(body);
+        }
+        catch {
+            return Response.json({ ok: false, error: "Invalid JSON payload" }, { status: 400 });
+        }
+        const jobName = readString(payload.jobName ?? payload.name ?? payload.type);
+        if (!jobName) {
+            return Response.json({ ok: false, error: "Missing jobName" }, { status: 400 });
+        }
+        const definition = router[jobName];
+        if (!definition) {
+            return Response.json({ ok: false, jobName, error: `Unknown job '${jobName}'` }, { status: 404 });
+        }
+        const parsed = definition.input.safeParse(payload.input ?? payload.payload ?? {});
+        if (!parsed.success) {
+            return Response.json({ ok: false, jobName, error: `Invalid input for job ${jobName}: ${parsed.error.message}` }, { status: 400 });
+        }
+        const jobId = readString(payload.jobId ?? payload.id) ?? crypto.randomUUID();
+        const attempt = readNumber(payload.attempt) ?? 1;
+        const maxAttempts = readNumber(payload.maxAttempts) ?? definition.defaults?.retries ?? 1;
+        try {
+            const result = await definition.handler({
+                input: parsed.data,
+                jobId,
+                attempt,
+                maxAttempts,
+                fail: (reason) => {
+                    throw new QueuebaseFailure(reason);
+                },
+            });
+            return Response.json({ ok: true, jobName, result });
+        }
+        catch (error) {
+            const message = error instanceof QueuebaseFailure
+                ? error.reason
+                : error instanceof Error
+                    ? error.message
+                    : String(error);
+            return Response.json({ ok: false, jobName, error: message }, { status: 500 });
+        }
+    };
+}
+export function listQueuebaseSchedules(router) {
+    return Object.entries(router)
+        .filter((entry) => {
+        return entry[1].schedule !== undefined;
+    })
+        .map(([name, definition]) => ({ name, schedule: definition.schedule }));
+}
+export const queuebaseJobs = createJobRouter({
+    invitationCleanup: defineQueueJob({
+        input: z.object({}),
+        schedule: { cron: invitationCleanup.cron, timezone: "UTC", overlap: "skip" },
+        handler: async () => invitationCleanup.handler(),
+    }),
+    sessionCleanup: defineQueueJob({
+        input: z.object({}),
+        schedule: { cron: sessionCleanup.cron, timezone: "UTC", overlap: "skip" },
+        handler: async () => sessionCleanup.handler(),
+    }),
+});
+export const queuebaseWebhookHandler = createQueuebaseWebhookHandler(queuebaseJobs, {
+    ...(process.env.QUEUEBASE_WEBHOOK_SECRET
+        ? { webhookSecret: process.env.QUEUEBASE_WEBHOOK_SECRET }
+        : {}),
+});
+export function verifyQueuebaseSignature(body, signature, secret) {
+    if (!signature)
+        return false;
+    const raw = signature.startsWith("sha256=") ? signature.slice("sha256=".length) : signature;
+    if (!/^[a-f0-9]{64}$/i.test(raw))
+        return false;
+    const expected = createHmac("sha256", secret).update(body).digest("hex");
+    const actualBuffer = Buffer.from(raw, "hex");
+    const expectedBuffer = Buffer.from(expected, "hex");
+    return (actualBuffer.length === expectedBuffer.length && timingSafeEqual(actualBuffer, expectedBuffer));
+}
+function readString(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function readNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}

package/dist/queuebase.d.ts

@@ -0,0 +1,27 @@
+import type { z } from "zod";
+import type { QueuebaseJobRouter } from "./queuebase-webhook";
+import type { JobOptions, JobResult, QueueProvider } from "./types";
+export type { QueuebaseBackoff, QueuebaseJobContext, QueuebaseJobDefinition, QueuebaseJobRouter, QueuebaseJobs, QueuebaseSchedule, QueuebaseScheduleConfig, QueuebaseScheduleMetadata, QueuebaseWebhookOptions, } from "./queuebase-webhook";
+export { createJobRouter, createQueuebaseWebhookHandler, defineQueueJob, listQueuebaseSchedules, queuebaseJobs, queuebaseWebhookHandler, verifyQueuebaseSignature, } from "./queuebase-webhook";
+export interface QueuebaseClientOptions {
+    callbackUrl: string;
+    apiUrl?: string;
+    apiKey?: string;
+    queue?: QueueProvider;
+}
+export type QueuebaseClient<TRouter extends QueuebaseJobRouter> = {
+    [K in keyof TRouter]: {
+        enqueue: (input: z.input<TRouter[K]["input"]>, options?: JobOptions) => Promise<QueuebaseEnqueueResult>;
+    };
+};
+export interface QueuebaseEnqueueResult extends JobResult {
+    jobName: string;
+    callbackUrl: string;
+}
+export declare function createJobClient<TRouter extends QueuebaseJobRouter>(router: TRouter, options: QueuebaseClientOptions): QueuebaseClient<TRouter>;
+export declare function getQueuebaseCallbackUrl(baseUrl?: string): string;
+export declare const queuebaseJobClient: QueuebaseClient<{
+    invitationCleanup: import("./queuebase-webhook").QueuebaseJobDefinition<z.ZodObject<{}, z.core.$strip>, import("./scheduled").ScheduledJobResult>;
+    sessionCleanup: import("./queuebase-webhook").QueuebaseJobDefinition<z.ZodObject<{}, z.core.$strip>, import("./scheduled").ScheduledJobResult>;
+}>;
+//# sourceMappingURL=queuebase.d.ts.map

package/dist/queuebase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queuebase.d.ts","sourceRoot":"","sources":["../src/queuebase.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAE9D,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAEpE,YAAY,EACV,gBAAgB,EAChB,mBAAmB,EACnB,sBAAsB,EACtB,kBAAkB,EAClB,aAAa,EACb,iBAAiB,EACjB,uBAAuB,EACvB,yBAAyB,EACzB,uBAAuB,GACxB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,eAAe,EACf,6BAA6B,EAC7B,cAAc,EACd,sBAAsB,EACtB,aAAa,EACb,uBAAuB,EACvB,wBAAwB,GACzB,MAAM,qBAAqB,CAAC;AAE7B,MAAM,WAAW,sBAAsB;IACrC,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,aAAa,CAAC;CACvB;AAED,MAAM,MAAM,eAAe,CAAC,OAAO,SAAS,kBAAkB,IAAI;KAC/D,CAAC,IAAI,MAAM,OAAO,GAAG;QACpB,OAAO,EAAE,CACP,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,EACnC,OAAO,CAAC,EAAE,UAAU,KACjB,OAAO,CAAC,sBAAsB,CAAC,CAAC;KACtC;CACF,CAAC;AAEF,MAAM,WAAW,sBAAuB,SAAQ,SAAS;IACvD,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,wBAAgB,eAAe,CAAC,OAAO,SAAS,kBAAkB,EAChE,MAAM,EAAE,OAAO,EACf,OAAO,EAAE,sBAAsB,GAC9B,eAAe,CAAC,OAAO,CAAC,CAoC1B;AAED,wBAAgB,uBAAuB,CAAC,OAAO,SAAsB,GAAG,MAAM,CAE7E;AAED,eAAO,MAAM,kBAAkB;;;EAI7B,CAAC"}