@zintrust/queue-cloudflare 2.4.1

package/dist/migrations/20260608000003_create_cloudflare_queue_job_logs_table.js

@@ -0,0 +1,22 @@
+import { MigrationSchema } from '@zintrust/core/database';
+export const migration = {
+    async up(db) {
+        const schema = MigrationSchema.create(db);
+        await schema.create('cf_queue_job_logs', (table) => {
+            table.string('id').primary();
+            table.string('job_id');
+            table.string('queue_name');
+            table.string('level');
+            table.text('message');
+            table.text('data').nullable();
+            table.timestamp('created_at');
+            table.index(['job_id', 'queue_name']);
+            table.index(['queue_name', 'level', 'created_at']);
+            table.index('created_at');
+        });
+    },
+    async down(db) {
+        const schema = MigrationSchema.create(db);
+        await schema.dropIfExists('cf_queue_job_logs');
+    },
+};

package/dist/migrations/20260608000004_create_cloudflare_queue_repeatables_table.d.ts

@@ -0,0 +1,6 @@
+import { type IDatabase } from '@zintrust/core/database';
+export interface Migration {
+    up(db: IDatabase): Promise<void>;
+    down(db: IDatabase): Promise<void>;
+}
+export declare const migration: Migration;

package/dist/migrations/20260608000004_create_cloudflare_queue_repeatables_table.js

@@ -0,0 +1,28 @@
+import { MigrationSchema } from '@zintrust/core/database';
+export const migration = {
+    async up(db) {
+        const schema = MigrationSchema.create(db);
+        await schema.create('cf_queue_repeatables', (table) => {
+            table.string('id').primary();
+            table.string('queue_name');
+            table.string('name');
+            table.text('payload');
+            table.string('cron').nullable();
+            table.integer('every_ms').nullable();
+            table.timestamp('start_at').nullable();
+            table.timestamp('end_at').nullable();
+            table.integer('limit_count').nullable();
+            table.integer('run_count').default(0);
+            table.timestamp('next_run_at');
+            table.boolean('active').default(true);
+            table.timestamp('created_at');
+            table.timestamp('updated_at');
+            table.index(['active', 'next_run_at']);
+            table.index(['queue_name', 'active']);
+        });
+    },
+    async down(db) {
+        const schema = MigrationSchema.create(db);
+        await schema.dropIfExists('cf_queue_repeatables');
+    },
+};

package/dist/migrations/20260608000005_create_cloudflare_queue_flow_dependencies_table.d.ts

@@ -0,0 +1,6 @@
+import { type IDatabase } from '@zintrust/core/database';
+export interface Migration {
+    up(db: IDatabase): Promise<void>;
+    down(db: IDatabase): Promise<void>;
+}
+export declare const migration: Migration;

package/dist/migrations/20260608000005_create_cloudflare_queue_flow_dependencies_table.js

@@ -0,0 +1,22 @@
+import { MigrationSchema } from '@zintrust/core/database';
+export const migration = {
+    async up(db) {
+        const schema = MigrationSchema.create(db);
+        await schema.create('cf_queue_flow_dependencies', (table) => {
+            table.string('id').primary();
+            table.string('queue_name');
+            table.string('parent_job_id');
+            table.string('child_job_id');
+            table.string('state');
+            table.timestamp('created_at');
+            table.timestamp('updated_at');
+            table.index(['queue_name', 'parent_job_id']);
+            table.index(['queue_name', 'child_job_id']);
+            table.index(['queue_name', 'state']);
+        });
+    },
+    async down(db) {
+        const schema = MigrationSchema.create(db);
+        await schema.dropIfExists('cf_queue_flow_dependencies');
+    },
+};

package/dist/migrations/index.d.ts

@@ -0,0 +1,2 @@
+export type { Migration } from './20260608000001_create_cloudflare_queue_jobs_table';
+export declare const migrations: import("./20260608000001_create_cloudflare_queue_jobs_table").Migration[];

package/dist/migrations/index.js

@@ -0,0 +1,12 @@
+import { migration as createJobs } from './20260608000001_create_cloudflare_queue_jobs_table.js';
+import { migration as createEvents } from './20260608000002_create_cloudflare_queue_job_events_table.js';
+import { migration as createLogs } from './20260608000003_create_cloudflare_queue_job_logs_table.js';
+import { migration as createRepeatables } from './20260608000004_create_cloudflare_queue_repeatables_table.js';
+import { migration as createFlowDependencies } from './20260608000005_create_cloudflare_queue_flow_dependencies_table.js';
+export const migrations = [
+    createJobs,
+    createEvents,
+    createLogs,
+    createRepeatables,
+    createFlowDependencies,
+];

package/dist/register.d.ts

@@ -0,0 +1,5 @@
+type QueueApi = {
+    register?: (name: string, driver: unknown) => void;
+};
+export declare function registerCloudflareQueueDriver(queue: QueueApi): Promise<void>;
+export {};

package/dist/register.js

@@ -0,0 +1,20 @@
+export async function registerCloudflareQueueDriver(queue) {
+    const { CloudflareQueues } = (await import('./index.js'));
+    if (typeof queue.register !== 'function')
+        return;
+    const driver = CloudflareQueues.create();
+    queue.register('cloudflare', driver);
+    queue.register('cloudflare-queues', driver);
+}
+const importCore = async () => {
+    try {
+        return await import('@zintrust/core');
+    }
+    catch {
+        return {};
+    }
+};
+const core = (await importCore());
+if (typeof core.Queue?.register === 'function') {
+    await registerCloudflareQueueDriver(core.Queue);
+}

package/dist/types.d.ts

@@ -0,0 +1,240 @@
+export type CloudflareQueueContentType = 'json' | 'text' | 'bytes' | 'v8';
+export type CloudflareQueueState = 'waiting' | 'queued' | 'delayed' | 'prioritized' | 'active' | 'completed' | 'failed' | 'retrying' | 'stalled' | 'waiting_children' | 'canceled' | 'dead_lettered';
+export type CloudflareQueueBackoff = {
+    type: 'fixed' | 'exponential';
+    delay: number;
+};
+export type CloudflareQueueRetention = boolean | number | {
+    age?: number;
+    count?: number;
+};
+export type CloudflareRepeatOptions = {
+    every?: number;
+    cron?: string;
+    limit?: number;
+    startDate?: Date;
+    endDate?: Date;
+};
+export type CloudflareJobOptions = {
+    jobId?: string;
+    attempts?: number;
+    delay?: number;
+    priority?: number;
+    lifo?: boolean;
+    backoff?: CloudflareQueueBackoff;
+    removeOnComplete?: CloudflareQueueRetention;
+    removeOnFail?: CloudflareQueueRetention;
+    deduplication?: {
+        id: string;
+        ttl?: number;
+        collisionBehavior?: 'suppress' | 'enqueue';
+    };
+    uniqueId?: string;
+    repeat?: CloudflareRepeatOptions;
+};
+export type CloudflareQueueEnvelope = {
+    protocol: 'zintrust.cf.queue.v1';
+    jobId: string;
+    queueName: string;
+    name: string;
+    attempt: number;
+    availableAt: string;
+    traceId?: string;
+};
+export type QueueMessage<T = unknown> = {
+    id: string;
+    payload: T;
+    attempts: number;
+};
+export type CloudflareQueueSendOptions = {
+    contentType?: CloudflareQueueContentType;
+    delaySeconds?: number;
+};
+export type CloudflareQueueBatchMessage = {
+    body: unknown;
+    options?: CloudflareQueueSendOptions;
+};
+export type CloudflareQueueBinding = {
+    send: (body: unknown, options?: CloudflareQueueSendOptions) => Promise<void>;
+    sendBatch?: (messages: CloudflareQueueBatchMessage[]) => Promise<void>;
+};
+export type D1PreparedStatementLike = {
+    bind: (...values: unknown[]) => D1PreparedStatementLike;
+    all: <T = Record<string, unknown>>() => Promise<{
+        results?: T[];
+    }>;
+    first: <T = Record<string, unknown>>() => Promise<T | null>;
+    run: () => Promise<unknown>;
+};
+export type D1DatabaseLike = {
+    prepare: (query: string) => D1PreparedStatementLike;
+    batch?: (statements: D1PreparedStatementLike[]) => Promise<unknown[]>;
+    exec?: (query: string) => Promise<unknown>;
+};
+export type ZinTrustDatabaseLike = {
+    query: (sql: string, parameters?: unknown[]) => Promise<unknown[]>;
+    queryOne: (sql: string, parameters?: unknown[]) => Promise<unknown>;
+    execute: (sql: string, parameters?: unknown[]) => Promise<unknown>;
+};
+export type CloudflareQueueStateConfig = {
+    d1?: D1DatabaseLike;
+    db?: ZinTrustDatabaseLike;
+    d1BindingName?: string;
+    kv?: CloudflareQueueKvBinding;
+    kvBindingName?: string;
+    coordinator?: CloudflareQueueCoordinatorBinding;
+    coordinatorBindingName?: string;
+    workerId?: string;
+    heartbeatTtlMs?: number;
+    rateLimit?: {
+        max: number;
+        durationMs: number;
+        key?: string;
+    };
+};
+export type CloudflareQueueKvBinding = {
+    get: (key: string) => Promise<string | null>;
+    put: (key: string, value: string, options?: {
+        expirationTtl?: number;
+    }) => Promise<void>;
+    delete: (key: string) => Promise<void>;
+};
+export type CloudflareQueueCoordinatorBinding = {
+    getByName?: (name: string) => CloudflareQueueCoordinatorStub;
+    idFromName?: (name: string) => unknown;
+    get?: (id: unknown) => CloudflareQueueCoordinatorStub;
+};
+export type CloudflareQueueCoordinatorStub = {
+    acquireLease?: (input: LeaseInput) => Promise<LeaseResult>;
+    heartbeat?: (input: LeaseInput) => Promise<LeaseResult>;
+    releaseLease?: (input: LeaseInput) => Promise<void>;
+    pause?: () => Promise<void>;
+    resume?: () => Promise<void>;
+    isPaused?: () => Promise<boolean>;
+    rateLimit?: (input: RateLimitInput) => Promise<RateLimitResult>;
+};
+export type LeaseInput = {
+    queueName: string;
+    jobId: string;
+    workerId: string;
+    ttlMs: number;
+};
+export type LeaseResult = {
+    acquired: boolean;
+    expiresAt?: number;
+    owner?: string;
+};
+export type RateLimitInput = {
+    key: string;
+    max: number;
+    durationMs: number;
+};
+export type RateLimitResult = {
+    allowed: boolean;
+    remaining: number;
+    resetAt: number;
+};
+export type CloudflareQueueConfig = {
+    driver: 'cloudflare' | 'cloudflare-queues';
+    bindingName?: string;
+    bindings?: Record<string, CloudflareQueueBinding | undefined>;
+    accountId?: string;
+    queueId?: string;
+    apiToken?: string;
+    apiBaseUrl?: string;
+    contentType?: CloudflareQueueContentType;
+    delaySeconds?: number;
+    batchSize?: number;
+    visibilityTimeoutMs?: number;
+    state?: CloudflareQueueStateConfig;
+};
+export type CloudflareQueueJobRow = {
+    id: string;
+    queue_name: string;
+    name: string;
+    payload: string;
+    opts: string | null;
+    state: CloudflareQueueState;
+    priority: number;
+    attempts: number;
+    max_attempts: number;
+    progress: string | null;
+    result: string | null;
+    error: string | null;
+    dedupe_key: string | null;
+    idempotency_key: string | null;
+    available_at: string;
+    started_at: string | null;
+    completed_at: string | null;
+    failed_at: string | null;
+    stalled_at: string | null;
+    created_at: string;
+    updated_at: string;
+};
+export type CloudflareQueueJob<T = unknown> = {
+    id: string;
+    queueName: string;
+    name: string;
+    data: T;
+    state: CloudflareQueueState;
+    attemptsMade: number;
+    maxAttempts: number;
+    priority: number;
+    progress: unknown;
+    result: unknown;
+    error: unknown;
+    opts: CloudflareJobOptions;
+    availableAt: string;
+    createdAt: string;
+    updatedAt: string;
+    updateProgress(progress: unknown): Promise<void>;
+    log(message: string, data?: unknown): Promise<void>;
+    remove(): Promise<void>;
+    retry(): Promise<void>;
+};
+export type CloudflareQueueProcessorContext<T = unknown> = {
+    job: CloudflareQueueJob<T>;
+    attempt: number;
+    updateProgress(progress: unknown): Promise<void>;
+    log(message: string, data?: unknown): Promise<void>;
+    heartbeat(): Promise<void>;
+};
+export type CloudflareQueueProcessor<T = unknown, TResult = unknown> = (data: T, context: CloudflareQueueProcessorContext<T>) => Promise<TResult> | TResult;
+export type CloudflareRepeatableRow = {
+    id: string;
+    queue_name: string;
+    name: string;
+    payload: string;
+    cron: string | null;
+    every_ms: number | null;
+    start_at: string | null;
+    end_at: string | null;
+    limit_count: number | null;
+    run_count: number;
+    next_run_at: string;
+    active: number;
+    created_at: string;
+    updated_at: string;
+};
+export type CloudflareFlowInput<TParent = unknown, TChild = unknown> = {
+    queueName: string;
+    parent: {
+        name: string;
+        data: TParent;
+        options?: CloudflareJobOptions;
+    };
+    children: Array<{
+        name: string;
+        data: TChild;
+        options?: CloudflareJobOptions;
+    }>;
+};
+export type CloudflareFlowResult<TParent = unknown, TChild = unknown> = {
+    parent: CloudflareQueueJob<TParent>;
+    children: Array<CloudflareQueueJob<TChild>>;
+};
+export type CloudflareQueueMetrics = {
+    queueName: string;
+    counts: Record<string, number>;
+    total: number;
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@zintrust/queue-cloudflare",
+  "version": "2.4.1",
+  "description": "Cloudflare Queues driver for ZinTrust.",
+  "private": false,
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./register": {
+      "types": "./dist/register.d.ts",
+      "default": "./dist/register.js"
+    },
+    "./cli-register": {
+      "types": "./dist/cli-register.d.ts",
+      "default": "./dist/cli-register.js"
+    },
+    "./migrations": {
+      "types": "./dist/migrations/index.d.ts",
+      "default": "./dist/migrations/index.js"
+    }
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "peerDependencies": {
+    "@zintrust/core": "*"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "zintrust",
+    "queue",
+    "cloudflare",
+    "cloudflare-queues",
+    "workers",
+    "adapter"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json && tsc -p tsconfig.migrations.json && node ../../scripts/fix-dist-esm-imports.mjs dist",
+    "prepublishOnly": "npm run build"
+  }
+}