@zintrust/queue-cloudflare 2.4.1

package/dist/index.js

@@ -0,0 +1,499 @@
+import { Cloudflare } from '@zintrust/core/cloudflare';
+import { ErrorFactory } from '@zintrust/core/errors';
+import { generateUuid } from '@zintrust/core/utils';
+import { CloudflareJobStore } from './CloudflareJobStore.js';
+import { CloudflareQueueConsumer } from './CloudflareQueueConsumer.js';
+import { CloudflareQueueMigrator } from './CloudflareQueueMigrator.js';
+import { CloudflareQueueScheduler } from './CloudflareQueueScheduler.js';
+export { CloudflareJobStore } from './CloudflareJobStore.js';
+export { CloudflareQueueConsumer } from './CloudflareQueueConsumer.js';
+export { CloudflareQueueCoordinator } from './CloudflareQueueCoordinator.js';
+export { CloudflareQueueMigrator } from './CloudflareQueueMigrator.js';
+export { CloudflareQueueScheduler } from './CloudflareQueueScheduler.js';
+const LEASES_MAX_ENTRIES = 10000;
+const LEASES_TTL_MS = 15 * 60 * 1000;
+const envValue = (key) => {
+    const workersValue = Cloudflare.getWorkersVar(key);
+    if (workersValue !== null)
+        return workersValue;
+    const nodeEnv = typeof process !== 'undefined' && process.env !== undefined ? process.env[key] : undefined;
+    return typeof nodeEnv === 'string' ? nodeEnv : '';
+};
+const nonEmpty = (value) => {
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed === '' ? undefined : trimmed;
+};
+const resolveBindingName = (queue, config) => {
+    return (nonEmpty(config?.bindingName) ??
+        nonEmpty(envValue('CLOUDFLARE_QUEUE_BINDING')) ??
+        nonEmpty(envValue('QUEUE_BINDING')) ??
+        queue);
+};
+const resolveBinding = (queue, config) => {
+    const bindingName = resolveBindingName(queue, config);
+    const configured = config?.bindings?.[bindingName];
+    if (configured !== undefined)
+        return configured;
+    const env = Cloudflare.getWorkersEnv();
+    const candidate = env?.[bindingName];
+    if (candidate !== undefined && typeof candidate.send === 'function')
+        return candidate;
+    return null;
+};
+const resolveApiBaseUrl = (config) => {
+    return (nonEmpty(config?.apiBaseUrl) ??
+        nonEmpty(envValue('CLOUDFLARE_API_BASE_URL')) ??
+        'https://api.cloudflare.com/client/v4').replace(/\/$/, '');
+};
+const resolveAccountId = (config) => {
+    const accountId = nonEmpty(config?.accountId) ??
+        nonEmpty(envValue('CLOUDFLARE_ACCOUNT_ID')) ??
+        nonEmpty(envValue('CF_ACCOUNT_ID'));
+    if (accountId === undefined) {
+        throw ErrorFactory.createConfigError('Cloudflare Queues requires CLOUDFLARE_ACCOUNT_ID');
+    }
+    return accountId;
+};
+const resolveQueueId = (queue, config) => {
+    const queueId = nonEmpty(config?.queueId) ??
+        nonEmpty(envValue('CLOUDFLARE_QUEUE_ID')) ??
+        nonEmpty(envValue('CF_QUEUE_ID')) ??
+        nonEmpty(queue);
+    if (queueId === undefined) {
+        throw ErrorFactory.createConfigError('Cloudflare Queues requires a queue id or queue name');
+    }
+    return queueId;
+};
+const resolveApiToken = (config) => {
+    const apiToken = nonEmpty(config?.apiToken) ??
+        nonEmpty(envValue('CLOUDFLARE_API_TOKEN')) ??
+        nonEmpty(envValue('CF_API_TOKEN'));
+    if (apiToken === undefined) {
+        throw ErrorFactory.createConfigError('Cloudflare Queues requires CLOUDFLARE_API_TOKEN');
+    }
+    return apiToken;
+};
+const resolveSendOptions = (config) => {
+    const options = {};
+    if (config?.contentType !== undefined)
+        options.contentType = config.contentType;
+    if (config?.delaySeconds !== undefined)
+        options.delaySeconds = config.delaySeconds;
+    return options;
+};
+const toApiContentType = (contentType) => {
+    return contentType === 'text' ? 'text' : 'json';
+};
+const createEnvelope = (id, payload) => ({
+    id,
+    payload,
+    attempts: 0,
+});
+const pruneLeases = (state) => {
+    const now = Date.now();
+    for (const [id, value] of state.leases.entries()) {
+        if (now - value.seenAt > LEASES_TTL_MS)
+            state.leases.delete(id);
+    }
+    if (state.leases.size <= LEASES_MAX_ENTRIES)
+        return;
+    const overflow = state.leases.size - LEASES_MAX_ENTRIES;
+    let removed = 0;
+    for (const id of state.leases.keys()) {
+        state.leases.delete(id);
+        removed += 1;
+        if (removed >= overflow)
+            break;
+    }
+};
+const apiUrl = (queue, config, path) => {
+    const accountId = encodeURIComponent(resolveAccountId(config));
+    const queueId = encodeURIComponent(resolveQueueId(queue, config));
+    return `${resolveApiBaseUrl(config)}/accounts/${accountId}/queues/${queueId}${path}`;
+};
+const apiFetch = async (queue, config, path, init) => {
+    const response = await fetch(apiUrl(queue, config, path), {
+        ...init,
+        headers: {
+            authorization: `Bearer ${resolveApiToken(config)}`,
+            'content-type': 'application/json',
+            ...(init?.headers ?? {}),
+        },
+    });
+    const text = await response.text();
+    const parsed = text === '' ? {} : JSON.parse(text);
+    if (!response.ok || parsed.success === false) {
+        const message = parsed.errors?.map((error) => error.message).filter(Boolean).join('; ') ||
+            `Cloudflare Queues API error (${response.status})`;
+        throw ErrorFactory.createConnectionError(message, { status: response.status, body: parsed });
+    }
+    return (parsed.result ?? parsed);
+};
+const decodePulledBody = (message) => {
+    const body = message.body;
+    if (body !== null &&
+        typeof body === 'object' &&
+        typeof body.id === 'string' &&
+        'payload' in body) {
+        const envelope = body;
+        return {
+            id: envelope.id,
+            payload: envelope.payload,
+            attempts: typeof envelope.attempts === 'number' ? envelope.attempts : (message.attempts ?? 0),
+        };
+    }
+    return {
+        id: message.id ?? generateUuid(),
+        payload: body,
+        attempts: message.attempts ?? 0,
+    };
+};
+const createEnqueue = (config) => async (queue, payload) => {
+    const id = generateUuid();
+    const envelope = createEnvelope(id, payload);
+    const options = resolveSendOptions(config);
+    const binding = resolveBinding(queue, config);
+    if (binding !== null) {
+        await binding.send(envelope, options);
+        return id;
+    }
+    const contentType = toApiContentType(config?.contentType);
+    await apiFetch(queue, config, '/messages', {
+        method: 'POST',
+        body: JSON.stringify({
+            body: contentType === 'text' ? JSON.stringify(envelope) : envelope,
+            content_type: contentType,
+            delay_seconds: config?.delaySeconds,
+        }),
+    });
+    return id;
+};
+const sendRaw = (config) => async (queue, payload, optionsOverride) => {
+    const options = { ...resolveSendOptions(config), ...(optionsOverride ?? {}) };
+    const binding = resolveBinding(queue, config);
+    if (binding !== null) {
+        await binding.send(payload, options);
+        return;
+    }
+    const contentType = toApiContentType(options.contentType ?? config?.contentType);
+    await apiFetch(queue, config, '/messages', {
+        method: 'POST',
+        body: JSON.stringify({
+            body: contentType === 'text' ? JSON.stringify(payload) : payload,
+            content_type: contentType,
+            delay_seconds: options.delaySeconds,
+        }),
+    });
+};
+const sendRawBatch = (config) => async (queue, messages) => {
+    if (messages.length === 0)
+        return;
+    const binding = resolveBinding(queue, config);
+    if (binding?.sendBatch !== undefined) {
+        for (let index = 0; index < messages.length; index += 100) {
+            await binding.sendBatch(messages.slice(index, index + 100));
+        }
+        return;
+    }
+    const rawSender = sendRaw(config);
+    for (const message of messages) {
+        await rawSender(queue, message.body, message.options);
+    }
+};
+const createDequeue = (state, config) => async (queue) => {
+    pruneLeases(state);
+    const body = {};
+    if (config?.batchSize !== undefined)
+        body['batch_size'] = config.batchSize;
+    if (config?.visibilityTimeoutMs !== undefined) {
+        body['visibility_timeout_ms'] = config.visibilityTimeoutMs;
+    }
+    const pulled = await apiFetch(queue, config, '/messages/pull', {
+        method: 'POST',
+        body: JSON.stringify(body),
+    });
+    state.lastBacklogCount =
+        pulled.message_backlog_count ?? pulled.metadata?.metrics?.backlog_count ?? state.lastBacklogCount;
+    const message = pulled.messages?.[0];
+    if (message === undefined)
+        return undefined;
+    const decoded = decodePulledBody(message);
+    if (message.lease_id !== undefined) {
+        state.leases.set(decoded.id, { leaseId: message.lease_id, seenAt: Date.now() });
+    }
+    return decoded;
+};
+const createAck = (state, config) => async (queue, id) => {
+    pruneLeases(state);
+    const lease = state.leases.get(id);
+    if (lease === undefined)
+        return;
+    state.leases.delete(id);
+    await apiFetch(queue, config, '/messages/ack', {
+        method: 'POST',
+        body: JSON.stringify({
+            acks: [{ lease_id: lease.leaseId }],
+            retries: [],
+        }),
+    });
+};
+const createLength = (state, config) => async (queue) => {
+    const metrics = await apiFetch(queue, config, '/metrics', {
+        method: 'GET',
+    });
+    const count = metrics.metadata?.metrics?.backlog_count ?? state.lastBacklogCount ?? 0;
+    return Number.isFinite(count) ? count : 0;
+};
+const createDrain = (config) => async (queue) => {
+    await apiFetch(queue, config, '/purge', {
+        method: 'POST',
+        body: JSON.stringify({ delete_messages_permanently: true }),
+    });
+};
+const createStore = (config) => {
+    return CloudflareJobStore.create(config?.state);
+};
+const toQueueEnvelope = (job) => ({
+    protocol: 'zintrust.cf.queue.v1',
+    jobId: job.id,
+    queueName: job.queueName,
+    name: job.name,
+    attempt: job.attemptsMade,
+    availableAt: job.availableAt,
+});
+const resolveCoordinator = (config, queueName) => {
+    const direct = config?.state?.coordinator;
+    if (direct?.getByName !== undefined)
+        return direct.getByName(queueName);
+    if (direct?.idFromName !== undefined && direct.get !== undefined) {
+        return direct.get(direct.idFromName(queueName));
+    }
+    const env = Cloudflare.getWorkersEnv();
+    const bindingName = config?.state?.coordinatorBindingName ?? 'QUEUE_COORDINATOR';
+    const binding = env?.[bindingName];
+    if (binding?.getByName !== undefined)
+        return binding.getByName(queueName);
+    if (binding?.idFromName !== undefined && binding.get !== undefined) {
+        return binding.get(binding.idFromName(queueName));
+    }
+    return null;
+};
+const shouldSendImmediately = (options) => {
+    const delay = options?.delay ?? 0;
+    if (options?.priority !== undefined || options?.lifo === true)
+        return false;
+    return delay <= 43200 * 1000;
+};
+const delayOptions = (options) => {
+    const delaySeconds = Math.max(0, Math.floor((options?.delay ?? 0) / 1000));
+    return delaySeconds > 0 ? { delaySeconds } : undefined;
+};
+function createCloudflareQueueDriver(config) {
+    const state = { leases: new Map() };
+    const rawSender = sendRaw(config);
+    const rawBatchSender = sendRawBatch(config);
+    let storeRef;
+    const getStore = () => {
+        storeRef ??= createStore(config);
+        return storeRef;
+    };
+    return {
+        enqueue: createEnqueue(config),
+        dequeue: createDequeue(state, config),
+        ack: createAck(state, config),
+        length: createLength(state, config),
+        drain: createDrain(config),
+        async add(queue, name, data, options) {
+            const job = await getStore().createJob({ queueName: queue, name, data, options });
+            const coordinator = resolveCoordinator(config, queue);
+            if ((await coordinator?.isPaused?.()) === true)
+                return job;
+            const rate = config?.state?.rateLimit;
+            if (rate !== undefined) {
+                const result = await coordinator?.rateLimit?.({
+                    key: rate.key ?? queue,
+                    max: rate.max,
+                    durationMs: rate.durationMs,
+                });
+                if (result !== undefined && !result.allowed) {
+                    await getStore().updateState({
+                        queueName: queue,
+                        jobId: job.id,
+                        state: job.state,
+                        availableAt: new Date(result.resetAt).toISOString(),
+                    });
+                    return job;
+                }
+            }
+            if (shouldSendImmediately(options)) {
+                await rawSender(queue, toQueueEnvelope(job), delayOptions(options));
+                await getStore().markDispatched(queue, job.id);
+            }
+            return job;
+        },
+        async addBulk(queue, jobs) {
+            const created = [];
+            const batch = [];
+            const coordinator = resolveCoordinator(config, queue);
+            const rate = config?.state?.rateLimit;
+            const rateResult = rate === undefined
+                ? undefined
+                : await coordinator?.rateLimit?.({
+                    key: rate.key ?? queue,
+                    max: rate.max,
+                    durationMs: rate.durationMs,
+                });
+            for (const jobInput of jobs) {
+                const job = await getStore().createJob({
+                    queueName: queue,
+                    name: jobInput.name,
+                    data: jobInput.data,
+                    options: jobInput.options,
+                });
+                created.push(job);
+                if (rateResult !== undefined && !rateResult.allowed) {
+                    await getStore().updateState({
+                        queueName: queue,
+                        jobId: job.id,
+                        state: job.state,
+                        availableAt: new Date(rateResult.resetAt).toISOString(),
+                    });
+                    continue;
+                }
+                if (shouldSendImmediately(jobInput.options)) {
+                    batch.push({
+                        body: toQueueEnvelope(job),
+                        options: delayOptions(jobInput.options),
+                        id: job.id,
+                    });
+                }
+            }
+            if ((await resolveCoordinator(config, queue)?.isPaused?.()) !== true) {
+                await rawBatchSender(queue, batch.map((message) => ({ body: message.body, options: message.options })));
+                for (const message of batch) {
+                    await getStore().markDispatched(queue, message.id);
+                }
+            }
+            return created;
+        },
+        async getJob(queue, id) {
+            return await getStore().getJob(queue, id);
+        },
+        async getJobs(queue, states, limit) {
+            return await getStore().getJobs(queue, states, limit);
+        },
+        async getJobCounts(queue, ...states) {
+            return await getStore().getJobCounts(queue, ...states);
+        },
+        async getMetrics(queue) {
+            return await getStore().getMetrics(queue);
+        },
+        async updateProgress(queue, id, progress) {
+            await getStore().updateProgress(queue, id, progress);
+        },
+        async log(queue, id, message, data) {
+            await getStore().recordLog(queue, id, 'info', message, data);
+        },
+        async remove(queue, id) {
+            await getStore().updateState({ queueName: queue, jobId: id, state: 'canceled' });
+        },
+        async retry(queue, id) {
+            const job = await getStore().getJob(queue, id);
+            if (job === null)
+                return;
+            await getStore().updateState({ queueName: queue, jobId: id, state: 'waiting' });
+            await rawSender(queue, toQueueEnvelope(job));
+            await getStore().markDispatched(queue, id);
+        },
+        async promote(queue, id) {
+            const job = await getStore().getJob(queue, id);
+            if (job === null)
+                return;
+            await getStore().updateState({
+                queueName: queue,
+                jobId: id,
+                state: 'waiting',
+                availableAt: new Date().toISOString(),
+            });
+            await rawSender(queue, toQueueEnvelope(job));
+            await getStore().markDispatched(queue, id);
+        },
+        async clean(queue, states, olderThanMs) {
+            await getStore().clean(queue, states, olderThanMs);
+        },
+        async upsertJobScheduler(queue, name, data, repeat, id) {
+            return await getStore().upsertRepeatable({ id, queueName: queue, name, data, options: repeat });
+        },
+        async removeJobScheduler(id) {
+            await getStore().removeRepeatable(id);
+        },
+        async runScheduler(queue, limit) {
+            return await CloudflareQueueScheduler.create({
+                queueName: queue,
+                store: getStore(),
+                queue: { enqueue: async (queueName, payload) => {
+                        await rawSender(queueName, payload);
+                        return generateUuid();
+                    } },
+                batchSize: limit,
+            }).run();
+        },
+        async reconcileStalled(queue, olderThanMs, limit) {
+            return await CloudflareQueueScheduler.create({
+                queueName: queue,
+                store: getStore(),
+                queue: { enqueue: async (queueName, payload) => {
+                        await rawSender(queueName, payload);
+                        return generateUuid();
+                    } },
+                batchSize: limit,
+                stalledAfterMs: olderThanMs,
+            }).reconcileStalled();
+        },
+        async createFlow(input) {
+            return await getStore().createFlow(input);
+        },
+        async getFlowChildren(queue, parentJobId) {
+            return await getStore().getFlowChildren(queue, parentJobId);
+        },
+        async markFlowChildCompleted(queue, childJobId) {
+            const released = await getStore().markFlowChildCompleted(queue, childJobId);
+            for (const parent of released) {
+                await rawSender(parent.queueName, toQueueEnvelope(parent));
+                await getStore().markDispatched(parent.queueName, parent.id);
+            }
+            return released;
+        },
+        createConsumer(processor, queueName) {
+            return CloudflareQueueConsumer.create({
+                queueName,
+                store: getStore(),
+                processor,
+                state: config?.state,
+                queue: { enqueue: async (queueName, payload) => {
+                        await rawSender(queueName, payload);
+                    } },
+            });
+        },
+        async migrateState() {
+            if (config?.state?.d1 !== undefined) {
+                await CloudflareQueueMigrator.up({ d1: config.state.d1 });
+                return;
+            }
+            if (config?.state?.db !== undefined) {
+                await CloudflareQueueMigrator.up({ db: config.state.db });
+                return;
+            }
+            throw ErrorFactory.createConfigError('Cloudflare queue state migration requires config.state.d1 or config.state.db');
+        },
+    };
+}
+export const CloudflareQueues = Object.freeze({
+    create(config) {
+        return createCloudflareQueueDriver(config);
+    },
+});
+export const CloudflareQueue = CloudflareQueues;
+export default CloudflareQueues;

package/dist/migrationSql.d.ts

@@ -0,0 +1,2 @@
+export declare const cloudflareQueueMigrationStatements: readonly string[];
+export declare const cloudflareQueueRollbackStatements: readonly string[];

package/dist/migrationSql.js

@@ -0,0 +1,104 @@
+export const cloudflareQueueMigrationStatements = Object.freeze([
+    `CREATE TABLE IF NOT EXISTS cf_queue_jobs (
+    id TEXT PRIMARY KEY,
+    queue_name TEXT NOT NULL,
+    name TEXT NOT NULL,
+    payload TEXT NOT NULL,
+    opts TEXT,
+    state TEXT NOT NULL,
+    priority INTEGER NOT NULL DEFAULT 0,
+    attempts INTEGER NOT NULL DEFAULT 0,
+    max_attempts INTEGER NOT NULL DEFAULT 1,
+    progress TEXT,
+    result TEXT,
+    error TEXT,
+    dedupe_key TEXT,
+    idempotency_key TEXT,
+    available_at TEXT NOT NULL,
+    started_at TEXT,
+    completed_at TEXT,
+    failed_at TEXT,
+    stalled_at TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  )`,
+    `CREATE INDEX IF NOT EXISTS idx_cf_queue_jobs_queue_state_priority_available_at
+    ON cf_queue_jobs(queue_name, state, priority, available_at)`,
+    `CREATE INDEX IF NOT EXISTS idx_cf_queue_jobs_queue_dedupe_key
+    ON cf_queue_jobs(queue_name, dedupe_key)`,
+    `CREATE INDEX IF NOT EXISTS idx_cf_queue_jobs_queue_idempotency_key
+    ON cf_queue_jobs(queue_name, idempotency_key)`,
+    `CREATE INDEX IF NOT EXISTS idx_cf_queue_jobs_queue_updated_at
+    ON cf_queue_jobs(queue_name, updated_at)`,
+    `CREATE TABLE IF NOT EXISTS cf_queue_job_events (
+    id TEXT PRIMARY KEY,
+    job_id TEXT NOT NULL,
+    queue_name TEXT NOT NULL,
+    event TEXT NOT NULL,
+    data TEXT,
+    created_at TEXT NOT NULL
+  )`,
+    `CREATE INDEX IF NOT EXISTS idx_cf_queue_job_events_job_queue
+    ON cf_queue_job_events(job_id, queue_name)`,
+    `CREATE INDEX IF NOT EXISTS idx_cf_queue_job_events_queue_event_created_at
+    ON cf_queue_job_events(queue_name, event, created_at)`,
+    `CREATE INDEX IF NOT EXISTS idx_cf_queue_job_events_created_at
+    ON cf_queue_job_events(created_at)`,
+    `CREATE TABLE IF NOT EXISTS cf_queue_job_logs (
+    id TEXT PRIMARY KEY,
+    job_id TEXT NOT NULL,
+    queue_name TEXT NOT NULL,
+    level TEXT NOT NULL,
+    message TEXT NOT NULL,
+    data TEXT,
+    created_at TEXT NOT NULL
+  )`,
+    `CREATE INDEX IF NOT EXISTS idx_cf_queue_job_logs_job_queue
+    ON cf_queue_job_logs(job_id, queue_name)`,
+    `CREATE INDEX IF NOT EXISTS idx_cf_queue_job_logs_queue_level_created_at
+    ON cf_queue_job_logs(queue_name, level, created_at)`,
+    `CREATE INDEX IF NOT EXISTS idx_cf_queue_job_logs_created_at
+    ON cf_queue_job_logs(created_at)`,
+    `CREATE TABLE IF NOT EXISTS cf_queue_repeatables (
+    id TEXT PRIMARY KEY,
+    queue_name TEXT NOT NULL,
+    name TEXT NOT NULL,
+    payload TEXT NOT NULL,
+    cron TEXT,
+    every_ms INTEGER,
+    start_at TEXT,
+    end_at TEXT,
+    limit_count INTEGER,
+    run_count INTEGER NOT NULL DEFAULT 0,
+    next_run_at TEXT NOT NULL,
+    active INTEGER NOT NULL DEFAULT 1,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  )`,
+    `CREATE INDEX IF NOT EXISTS idx_cf_queue_repeatables_active_next_run_at
+    ON cf_queue_repeatables(active, next_run_at)`,
+    `CREATE INDEX IF NOT EXISTS idx_cf_queue_repeatables_queue_active
+    ON cf_queue_repeatables(queue_name, active)`,
+    `CREATE TABLE IF NOT EXISTS cf_queue_flow_dependencies (
+    id TEXT PRIMARY KEY,
+    queue_name TEXT NOT NULL,
+    parent_job_id TEXT NOT NULL,
+    child_job_id TEXT NOT NULL,
+    state TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  )`,
+    `CREATE INDEX IF NOT EXISTS idx_cf_queue_flow_dependencies_queue_parent
+    ON cf_queue_flow_dependencies(queue_name, parent_job_id)`,
+    `CREATE INDEX IF NOT EXISTS idx_cf_queue_flow_dependencies_queue_child
+    ON cf_queue_flow_dependencies(queue_name, child_job_id)`,
+    `CREATE INDEX IF NOT EXISTS idx_cf_queue_flow_dependencies_queue_state
+    ON cf_queue_flow_dependencies(queue_name, state)`,
+]);
+export const cloudflareQueueRollbackStatements = Object.freeze([
+    'DROP TABLE IF EXISTS cf_queue_flow_dependencies',
+    'DROP TABLE IF EXISTS cf_queue_repeatables',
+    'DROP TABLE IF EXISTS cf_queue_job_logs',
+    'DROP TABLE IF EXISTS cf_queue_job_events',
+    'DROP TABLE IF EXISTS cf_queue_jobs',
+]);

package/dist/migrations/20260608000001_create_cloudflare_queue_jobs_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/20260608000001_create_cloudflare_queue_jobs_table.js

@@ -0,0 +1,37 @@
+import { MigrationSchema } from '@zintrust/core/database';
+export const migration = {
+    async up(db) {
+        const schema = MigrationSchema.create(db);
+        await schema.create('cf_queue_jobs', (table) => {
+            table.string('id').primary();
+            table.string('queue_name');
+            table.string('name');
+            table.text('payload');
+            table.text('opts').nullable();
+            table.string('state');
+            table.integer('priority').default(0);
+            table.integer('attempts').default(0);
+            table.integer('max_attempts').default(1);
+            table.text('progress').nullable();
+            table.text('result').nullable();
+            table.text('error').nullable();
+            table.string('dedupe_key').nullable();
+            table.string('idempotency_key').nullable();
+            table.timestamp('available_at');
+            table.timestamp('started_at').nullable();
+            table.timestamp('completed_at').nullable();
+            table.timestamp('failed_at').nullable();
+            table.timestamp('stalled_at').nullable();
+            table.timestamp('created_at');
+            table.timestamp('updated_at');
+            table.index(['queue_name', 'state', 'priority', 'available_at']);
+            table.index(['queue_name', 'dedupe_key']);
+            table.index(['queue_name', 'idempotency_key']);
+            table.index(['queue_name', 'updated_at']);
+        });
+    },
+    async down(db) {
+        const schema = MigrationSchema.create(db);
+        await schema.dropIfExists('cf_queue_jobs');
+    },
+};

package/dist/migrations/20260608000002_create_cloudflare_queue_job_events_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/20260608000002_create_cloudflare_queue_job_events_table.js

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

package/dist/migrations/20260608000003_create_cloudflare_queue_job_logs_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;