@zintrust/core 0.1.41 → 0.1.43

package/packages/queue-redis/src/RedisPublishClient.js

@@ -0,0 +1,251 @@
+import { Env, ErrorFactory, SignedRequest, ZintrustLang } from '../../../src/index.js';
+const resolveSigningPrefix = (baseUrl) => {
+    try {
+        const parsed = new URL(baseUrl);
+        const path = parsed.pathname.endsWith('/') ? parsed.pathname.slice(0, -1) : parsed.pathname;
+        if (path === '' || path === '/')
+            return undefined;
+        return path;
+    }
+    catch {
+        return undefined;
+    }
+};
+const buildRequestUrl = (baseUrl, path) => {
+    const url = new URL(baseUrl);
+    const basePath = url.pathname.endsWith('/') ? url.pathname.slice(0, -1) : url.pathname;
+    const requestPath = path.startsWith('/') ? path : `/${path}`;
+    url.pathname = `${basePath}${requestPath}`;
+    return url;
+};
+const buildSigningUrl = (requestUrl, baseUrl) => {
+    const prefix = resolveSigningPrefix(baseUrl);
+    if (!prefix)
+        return requestUrl;
+    if (requestUrl.pathname === prefix || requestUrl.pathname.startsWith(`${prefix}/`)) {
+        const signingUrl = new URL(requestUrl.toString());
+        const stripped = requestUrl.pathname.slice(prefix.length);
+        signingUrl.pathname = stripped.startsWith('/') ? stripped : `/${stripped}`;
+        return signingUrl;
+    }
+    return requestUrl;
+};
+let publishClientInstance = null;
+let publishClientConnected = false;
+const resolveProxyBaseUrl = () => {
+    const explicit = Env.REDIS_PROXY_URL.trim();
+    if (explicit !== '')
+        return explicit;
+    if (Env.USE_REDIS_PROXY === false)
+        return '';
+    const host = Env.REDIS_PROXY_HOST || '127.0.0.1';
+    const port = Env.REDIS_PROXY_PORT;
+    return `http://${host}:${port}`;
+};
+const buildProxySettings = () => {
+    const baseUrl = resolveProxyBaseUrl();
+    const keyId = Env.REDIS_PROXY_KEY_ID || undefined;
+    const secret = Env.REDIS_PROXY_SECRET || Env.APP_KEY || undefined;
+    const timeoutMs = Env.REDIS_PROXY_TIMEOUT_MS;
+    return { baseUrl, keyId, secret, timeoutMs };
+};
+const buildHeaders = async (settings, requestUrl, body) => {
+    const headers = {
+        'Content-Type': 'application/json',
+    };
+    if (settings.keyId && settings.secret) {
+        const signingUrl = buildSigningUrl(requestUrl, settings.baseUrl);
+        const signed = await SignedRequest.createHeaders({
+            method: 'POST',
+            url: signingUrl,
+            body,
+            keyId: settings.keyId,
+            secret: settings.secret,
+        });
+        Object.assign(headers, signed);
+    }
+    return headers;
+};
+const requestProxy = async (settings, path, payload) => {
+    if (settings.baseUrl.trim() === '') {
+        throw ErrorFactory.createConfigError('Redis proxy URL is missing (REDIS_PROXY_URL)');
+    }
+    const body = JSON.stringify(payload);
+    const url = buildRequestUrl(settings.baseUrl, path);
+    const headers = await buildHeaders(settings, url, body);
+    const timeoutSignal = typeof AbortSignal !== 'undefined' && 'timeout' in AbortSignal;
+    const signal = timeoutSignal ? AbortSignal.timeout(settings.timeoutMs) : undefined;
+    const response = await fetch(url.toString(), {
+        method: 'POST',
+        headers,
+        body,
+        signal,
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw ErrorFactory.createTryCatchError(`Redis proxy request failed (${response.status})`, text);
+    }
+    return (await response.json());
+};
+const toNumber = (value) => {
+    if (typeof value === 'number')
+        return value;
+    if (typeof value === 'string') {
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? parsed : 0;
+    }
+    return 0;
+};
+const tryCreateProxyPublishClient = async () => {
+    const settings = buildProxySettings();
+    if (settings.baseUrl.trim() === '')
+        return null;
+    return {
+        publish: async (channel, message) => {
+            const response = await requestProxy(settings, '/zin/redis/command', {
+                command: 'PUBLISH',
+                args: [channel, message],
+            });
+            return toNumber(response.result);
+        },
+    };
+};
+/**
+ * Build Redis URL from environment variables
+ */
+const buildRedisUrl = () => {
+    // Get REDIS_URL from environment
+    const redisUrl = getRedisUrlFromEnv();
+    if (redisUrl)
+        return redisUrl;
+    // Build URL from individual components
+    return buildRedisUrlFromComponents();
+};
+/**
+ * Get REDIS_URL from environment variables
+ */
+const getRedisUrlFromEnv = () => {
+    const anyEnv = process.env;
+    const fromEnv = typeof anyEnv.get === 'function' ? anyEnv.get('REDIS_URL', '') : '';
+    const hasProcess = typeof process === 'object' && process !== null;
+    const fallback = hasProcess ? (process.env?.['REDIS_URL'] ?? '') : '';
+    const trimmed = fromEnv.trim();
+    const url = (trimmed.length > 0 ? fromEnv : String(fallback)).trim();
+    return url.length > 0 ? url : null;
+};
+/**
+ * Build Redis URL from individual environment components
+ */
+const buildRedisUrlFromComponents = () => {
+    const host = process.env?.['REDIS_HOST'] ?? 'localhost';
+    const port = Number(process.env?.['REDIS_PORT'] ?? ZintrustLang.REDIS_DEFAULT_PORT);
+    const password = process.env?.['REDIS_PASSWORD'];
+    const database = Number(process.env?.['REDIS_QUEUE_DB'] ?? ZintrustLang.REDIS_DEFAULT_DB);
+    let redisUrl = `redis://`;
+    if (password)
+        redisUrl += `:${password}@`;
+    redisUrl += `${host}:${port}`;
+    if (database > 0)
+        redisUrl += `/${database}`;
+    return redisUrl;
+};
+/**
+ * Singleton Redis publish client factory
+ * Creates and caches a Redis publish client for broadcasting
+ */
+export const createRedisPublishClient = async () => {
+    // Return cached instance if available
+    if (publishClientConnected && publishClientInstance !== null) {
+        return publishClientInstance;
+    }
+    const proxyClient = await tryCreateProxyPublishClient();
+    if (proxyClient) {
+        return cacheAndReturnClient(proxyClient);
+    }
+    const url = buildRedisUrl();
+    if (url === null)
+        throw ErrorFactory.createConfigError('Redis publish client requires REDIS_URL');
+    // Try different Redis clients in order of preference
+    const redisClient = (await tryCreateRedisClient(url)) || (await tryCreateIoRedisClient(url)) || getFallbackClient();
+    return redisClient;
+};
+/**
+ * Try to create client using 'redis' package
+ */
+const tryCreateRedisClient = async (url) => {
+    try {
+        const mod = (await import('redis'));
+        const client = mod.createClient({ url });
+        if (typeof client.connect === 'function') {
+            await connectClient(client, 'Redis publish client failed to connect');
+        }
+        return cacheAndReturnClient(client);
+    }
+    catch {
+        return null;
+    }
+};
+/**
+ * Try to create client using 'ioredis' package
+ */
+const tryCreateIoRedisClient = async (url) => {
+    try {
+        const mod = (await import('ioredis'));
+        const redis = mod.default(url);
+        const client = {
+            publish: (channel, message) => redis.publish(channel, message),
+            connect: redis.connect
+                ? async () => {
+                    const connectFn = redis.connect;
+                    await connectFn();
+                }
+                : undefined,
+        };
+        if (typeof client.connect === 'function') {
+            await connectClient(client, 'Redis publish client (ioredis) failed to connect');
+        }
+        return cacheAndReturnClient(client);
+    }
+    catch {
+        return null;
+    }
+};
+/**
+ * Get fallback client from global or throw error
+ */
+const getFallbackClient = () => {
+    const globalFake = globalThis
+        .__fakeRedisClient;
+    if (globalFake === undefined) {
+        throw ErrorFactory.createConfigError("Redis publish client requires the 'redis' or 'ioredis' package (run `zin add broadcast:redis' / `zin plugin install broadcast:redis`, or `npm install redis` / `npm install ioredis`) or a test fake client set in globalThis.__fakeRedisClient");
+    }
+    return cacheAndReturnClient(globalFake);
+};
+/**
+ * Connect to Redis client with error handling
+ */
+const connectClient = async (client, errorMessage) => {
+    try {
+        if (client.connect) {
+            await client.connect();
+        }
+    }
+    catch (err) {
+        throw ErrorFactory.createTryCatchError(errorMessage, err);
+    }
+};
+/**
+ * Cache and return the client instance
+ */
+const cacheAndReturnClient = (client) => {
+    publishClientInstance = client;
+    publishClientConnected = true;
+    return client;
+};
+/**
+ * Reset the singleton publish client (useful for testing)
+ */
+export const resetPublishClient = () => {
+    publishClientInstance = null;
+    publishClientConnected = false;
+};

package/packages/queue-redis/src/index.d.ts

@@ -0,0 +1,12 @@
+export { BullMQRedisQueue } from './BullMQRedisQueue';
+export { HttpQueueDriver } from './HttpQueueDriver';
+export { QueueHttpGateway } from './QueueHttpGateway';
+export { createRedisPublishClient, resetPublishClient, type RedisPublishClient, } from './RedisPublishClient';
+export type { QueueMessage } from '../../../src/index.js';
+/**
+ * Package version and build metadata
+ * Available at runtime for debugging and health checks
+ */
+export declare const _ZINTRUST_QUEUE_REDIS_VERSION = "0.1.15";
+export declare const _ZINTRUST_QUEUE_REDIS_BUILD_DATE = "__BUILD_DATE__";
+//# sourceMappingURL=index.d.ts.map

package/packages/queue-redis/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../packages/queue-redis/src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EACL,wBAAwB,EACxB,kBAAkB,EAClB,KAAK,kBAAkB,GACxB,MAAM,sBAAsB,CAAC;AAE9B,YAAY,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD;;;GAGG;AACH,eAAO,MAAM,6BAA6B,WAAW,CAAC;AACtD,eAAO,MAAM,gCAAgC,mBAAmB,CAAC"}

package/packages/queue-redis/src/index.js

@@ -0,0 +1,10 @@
+export { BullMQRedisQueue } from './BullMQRedisQueue.js';
+export { HttpQueueDriver } from './HttpQueueDriver.js';
+export { QueueHttpGateway } from './QueueHttpGateway.js';
+export { createRedisPublishClient, resetPublishClient, } from './RedisPublishClient.js';
+/**
+ * Package version and build metadata
+ * Available at runtime for debugging and health checks
+ */
+export const _ZINTRUST_QUEUE_REDIS_VERSION = '0.1.15';
+export const _ZINTRUST_QUEUE_REDIS_BUILD_DATE = '__BUILD_DATE__';

package/packages/queue-redis/src/register.d.ts

@@ -0,0 +1,6 @@
+type QueueApi = {
+    register: (name: string, driver: unknown) => void;
+};
+export declare function registerRedisQueueDriver(queue: QueueApi): Promise<void>;
+export {};
+//# sourceMappingURL=register.d.ts.map

package/packages/queue-redis/src/register.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../../../packages/queue-redis/src/register.ts"],"names":[],"mappings":"AAAA,KAAK,QAAQ,GAAG;IACd,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,KAAK,IAAI,CAAC;CACnD,CAAC;AAEF,wBAAsB,wBAAwB,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAG7E"}

package/packages/queue-redis/src/register.js

@@ -0,0 +1,21 @@
+export async function registerRedisQueueDriver(queue) {
+    const mod = await import('./BullMQRedisQueue.js');
+    queue.register('redis', mod.default);
+}
+const importCore = async () => {
+    try {
+        return await import('../../../src/index.js');
+    }
+    catch {
+        try {
+            return await import('../../../src/index.js');
+        }
+        catch {
+            return {};
+        }
+    }
+};
+const core = (await importCore());
+if (core.Queue !== undefined) {
+    await registerRedisQueueDriver(core.Queue);
+}

package/packages/workers/migrations/20260119100000_create_zintrust_workers_table.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Migration: CreateWorkersTable
+ * Creates workers table for persistence
+ */
+import { type IDatabase } from '../../../src/index.js';
+export interface Migration {
+    up(db: IDatabase): Promise<void>;
+    down(db: IDatabase): Promise<void>;
+}
+export declare const migration: Migration;
+//# sourceMappingURL=20260119100000_create_zintrust_workers_table.d.ts.map

package/packages/workers/migrations/20260119100000_create_zintrust_workers_table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"20260119100000_create_zintrust_workers_table.d.ts","sourceRoot":"","sources":["../../../../packages/workers/migrations/20260119100000_create_zintrust_workers_table.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAmC,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEjF,MAAM,WAAW,SAAS;IACxB,EAAE,CAAC,EAAE,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACjC,IAAI,CAAC,EAAE,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACpC;AAED,eAAO,MAAM,SAAS,EAAE,SA4BvB,CAAC"}

package/packages/workers/migrations/20260119100000_create_zintrust_workers_table.js

@@ -0,0 +1,32 @@
+/**
+ * Migration: CreateWorkersTable
+ * Creates workers table for persistence
+ */
+import { MigrationSchema } from '../../../src/index.js';
+export const migration = {
+    async up(db) {
+        const schema = MigrationSchema.create(db);
+        await schema.create('zintrust_workers', (table) => {
+            table.id();
+            table.string('name').unique();
+            table.string('queue_name');
+            table.string('version').nullable();
+            table.string('processor_spec').nullable();
+            table.string('status').default('running');
+            table.boolean('auto_start').default(false);
+            table.integer('concurrency').default(1);
+            table.string('region').nullable();
+            table.json('features').nullable();
+            table.json('infrastructure').nullable();
+            table.json('datacenter').nullable();
+            table.text('last_error').nullable();
+            table.string('connection_state').nullable();
+            table.timestamp('last_health_check').nullable();
+            table.timestamps();
+        });
+    },
+    async down(db) {
+        const schema = MigrationSchema.create(db);
+        await schema.dropIfExists('zintrust_workers');
+    },
+};

package/packages/workers/migrations/20260123180000_create_queue_jobs_table.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Migration: CreateQueueJobsTable
+ * Creates queue_jobs table for database-driven queue system
+ */
+import { type IDatabase } from '../../../src/index.js';
+export interface Migration {
+    up(db: IDatabase): Promise<void>;
+    down(db: IDatabase): Promise<void>;
+}
+export declare const migration: Migration;
+//# sourceMappingURL=20260123180000_create_queue_jobs_table.d.ts.map

package/packages/workers/migrations/20260123180000_create_queue_jobs_table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"20260123180000_create_queue_jobs_table.d.ts","sourceRoot":"","sources":["../../../../packages/workers/migrations/20260123180000_create_queue_jobs_table.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAmC,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEjF,MAAM,WAAW,SAAS;IACxB,EAAE,CAAC,EAAE,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACjC,IAAI,CAAC,EAAE,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACpC;AAED,eAAO,MAAM,SAAS,EAAE,SA6CvB,CAAC"}

package/packages/workers/migrations/20260123180000_create_queue_jobs_table.js

@@ -0,0 +1,46 @@
+/**
+ * Migration: CreateQueueJobsTable
+ * Creates queue_jobs table for database-driven queue system
+ */
+import { MigrationSchema } from '../../../src/index.js';
+export const migration = {
+    async up(db) {
+        const schema = MigrationSchema.create(db);
+        await schema.create('queue_jobs', (table) => {
+            table.uuid('id').primary();
+            table.string('queue');
+            table.json('payload');
+            table.integer('attempts').default(0);
+            table.integer('max_attempts').default(3);
+            table.timestamp('reserved_at').nullable();
+            table.timestamp('available_at').default('CURRENT_TIMESTAMP');
+            table.timestamps();
+            table.timestamp('failed_at').nullable();
+            table.text('error_message').nullable();
+            // Indexes for performance
+            table.index('queue');
+            table.index('available_at');
+            table.index('reserved_at');
+            table.index('failed_at');
+        });
+        // Create failed jobs table for dead letter queue
+        await schema.create('queue_jobs_failed', (table) => {
+            table.id();
+            table.string('original_id');
+            table.string('queue');
+            table.json('payload');
+            table.integer('attempts');
+            table.timestamp('failed_at');
+            table.text('error_message');
+            table.timestamps();
+            // Indexes for failed jobs
+            table.index(['queue', 'failed_at']);
+            table.index('failed_at');
+        });
+    },
+    async down(db) {
+        const schema = MigrationSchema.create(db);
+        await schema.dropIfExists('queue_jobs_failed');
+        await schema.dropIfExists('queue_jobs');
+    },
+};

package/packages/workers/migrations/20260213142000_create_zintrust_job_tracking_tables.d.ts

@@ -0,0 +1,7 @@
+import type { IDatabase } from '../../../src/index.js';
+export interface Migration {
+    up(db: IDatabase): Promise<void>;
+    down(db: IDatabase): Promise<void>;
+}
+export declare const migration: Migration;
+//# sourceMappingURL=20260213142000_create_zintrust_job_tracking_tables.d.ts.map

package/packages/workers/migrations/20260213142000_create_zintrust_job_tracking_tables.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"20260213142000_create_zintrust_job_tracking_tables.d.ts","sourceRoot":"","sources":["../../../../packages/workers/migrations/20260213142000_create_zintrust_job_tracking_tables.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAa,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAG3D,MAAM,WAAW,SAAS;IACxB,EAAE,CAAC,EAAE,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACjC,IAAI,CAAC,EAAE,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACpC;AAED,eAAO,MAAM,SAAS,EAAE,SA+CvB,CAAC"}

package/packages/workers/migrations/20260213142000_create_zintrust_job_tracking_tables.js

@@ -0,0 +1,44 @@
+import { MigrationSchema } from '../../../src/index.js';
+export const migration = {
+    async up(db) {
+        const schema = MigrationSchema.create(db);
+        await schema.create('zintrust_jobs', (table) => {
+            table.id();
+            table.string('job_id');
+            table.string('queue_name');
+            table.string('status');
+            table.integer('attempts').default(0);
+            table.integer('max_attempts').nullable();
+            table.text('payload_json').notNullable();
+            table.text('result_json').nullable();
+            table.text('last_error').nullable();
+            table.timestamp('retry_at').nullable();
+            table.timestamp('created_at').nullable();
+            table.timestamp('started_at').nullable();
+            table.timestamp('completed_at').nullable();
+            table.timestamp('updated_at').nullable();
+            table.index(['job_id', 'queue_name']);
+            table.index(['queue_name', 'status']);
+            table.index('updated_at');
+        });
+        await schema.create('zintrust_job_transitions', (table) => {
+            table.id();
+            table.string('job_id');
+            table.string('queue_name');
+            table.string('from_status').nullable();
+            table.string('to_status');
+            table.string('reason').nullable();
+            table.integer('attempts').nullable();
+            table.text('error').nullable();
+            table.timestamp('transitioned_at').nullable();
+            table.timestamps();
+            table.index(['job_id', 'queue_name']);
+            table.index('transitioned_at');
+        });
+    },
+    async down(db) {
+        const schema = MigrationSchema.create(db);
+        await schema.dropIfExists('zintrust_job_transitions');
+        await schema.dropIfExists('zintrust_jobs');
+    },
+};

package/packages/workers/migrations/20260213183000_expand_zintrust_job_tracking_reliability_tables.d.ts

@@ -0,0 +1,7 @@
+import type { IDatabase } from '../../../src/index.js';
+export interface Migration {
+    up(db: IDatabase): Promise<void>;
+    down(db: IDatabase): Promise<void>;
+}
+export declare const migration: Migration;
+//# sourceMappingURL=20260213183000_expand_zintrust_job_tracking_reliability_tables.d.ts.map

package/packages/workers/migrations/20260213183000_expand_zintrust_job_tracking_reliability_tables.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"20260213183000_expand_zintrust_job_tracking_reliability_tables.d.ts","sourceRoot":"","sources":["../../../../packages/workers/migrations/20260213183000_expand_zintrust_job_tracking_reliability_tables.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAa,SAAS,EAAE,MAAM,gBAAgB,CAAC;AA8H3D,MAAM,WAAW,SAAS;IACxB,EAAE,CAAC,EAAE,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACjC,IAAI,CAAC,EAAE,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACpC;AAED,eAAO,MAAM,SAAS,EAAE,SAYvB,CAAC"}

package/packages/workers/migrations/20260213183000_expand_zintrust_job_tracking_reliability_tables.js

@@ -0,0 +1,104 @@
+import { MigrationSchema } from '../../../src/index.js';
+const createHasIndex = (db) => {
+    return async (tableName, indexName) => {
+        const t = db.getType();
+        if (t === 'mysql') {
+            const rows = await db.query('SELECT 1 FROM information_schema.statistics WHERE table_schema = DATABASE() AND table_name=? AND index_name=? LIMIT 1', [tableName, indexName], true);
+            return rows.length > 0;
+        }
+        if (t === 'postgresql') {
+            const rows = await db.query("SELECT 1 FROM pg_indexes WHERE schemaname='public' AND tablename=? AND indexname=? LIMIT 1", [tableName, indexName], true);
+            return rows.length > 0;
+        }
+        if (t === 'sqlite' || t === 'd1' || t === 'd1-remote') {
+            const rows = await db.query(`PRAGMA index_list("${tableName}")`, [], true);
+            return rows.some((row) => row.name === indexName);
+        }
+        if (t === 'sqlserver') {
+            const rows = await db.query('SELECT 1 FROM sys.indexes WHERE object_id = OBJECT_ID(?) AND name=?', [tableName, indexName], true);
+            return rows.length > 0;
+        }
+        return false;
+    };
+};
+const expandJobsTableIfNeeded = async (db, schema) => {
+    const jobsTableExists = await schema.hasTable('zintrust_jobs');
+    if (!jobsTableExists)
+        return;
+    const hasIndex = createHasIndex(db);
+    const [hasLastErrorCode, hasTimeoutAt, hasHeartbeatAt, hasExpectedCompletionAt, hasWorkerName, hasWorkerInstanceId, hasWorkerRegion, hasWorkerVersion, hasRecoveredAt, hasIdempotencyKey,] = await Promise.all([
+        schema.hasColumn('zintrust_jobs', 'last_error_code'),
+        schema.hasColumn('zintrust_jobs', 'timeout_at'),
+        schema.hasColumn('zintrust_jobs', 'heartbeat_at'),
+        schema.hasColumn('zintrust_jobs', 'expected_completion_at'),
+        schema.hasColumn('zintrust_jobs', 'worker_name'),
+        schema.hasColumn('zintrust_jobs', 'worker_instance_id'),
+        schema.hasColumn('zintrust_jobs', 'worker_region'),
+        schema.hasColumn('zintrust_jobs', 'worker_version'),
+        schema.hasColumn('zintrust_jobs', 'recovered_at'),
+        schema.hasColumn('zintrust_jobs', 'idempotency_key'),
+    ]);
+    const [hasIdxStatusUpdated, hasIdxExpectedCompletion, hasIdxHeartbeat, hasIdxIdempotency] = await Promise.all([
+        hasIndex('zintrust_jobs', 'idx_zj_status_updated'),
+        hasIndex('zintrust_jobs', 'idx_zj_expected_completion'),
+        hasIndex('zintrust_jobs', 'idx_zj_heartbeat_at'),
+        hasIndex('zintrust_jobs', 'idx_zj_idempotency'),
+    ]);
+    await schema.table('zintrust_jobs', (table) => {
+        if (!hasLastErrorCode)
+            table.string('last_error_code').nullable();
+        if (!hasTimeoutAt)
+            table.timestamp('timeout_at').nullable();
+        if (!hasHeartbeatAt)
+            table.timestamp('heartbeat_at').nullable();
+        if (!hasExpectedCompletionAt)
+            table.timestamp('expected_completion_at').nullable();
+        if (!hasWorkerName)
+            table.string('worker_name').nullable();
+        if (!hasWorkerInstanceId)
+            table.string('worker_instance_id').nullable();
+        if (!hasWorkerRegion)
+            table.string('worker_region').nullable();
+        if (!hasWorkerVersion)
+            table.string('worker_version').nullable();
+        if (!hasRecoveredAt)
+            table.timestamp('recovered_at').nullable();
+        if (!hasIdempotencyKey)
+            table.string('idempotency_key').nullable();
+        if (!hasIdxStatusUpdated)
+            table.index(['status', 'updated_at'], 'idx_zj_status_updated');
+        if (!hasIdxExpectedCompletion) {
+            table.index('expected_completion_at', 'idx_zj_expected_completion');
+        }
+        if (!hasIdxHeartbeat)
+            table.index('heartbeat_at', 'idx_zj_heartbeat_at');
+        if (!hasIdxIdempotency)
+            table.index('idempotency_key', 'idx_zj_idempotency');
+    });
+};
+const ensureHeartbeatsTable = async (schema) => {
+    await schema.create('zintrust_job_heartbeats', (table) => {
+        table.id();
+        table.string('job_id');
+        table.string('queue_name');
+        table.string('worker_instance_id').nullable();
+        table.timestamp('last_heartbeat_at').nullable();
+        table.timestamp('expected_next_heartbeat_at').nullable();
+        table.integer('heartbeat_interval_ms').default(10000);
+        table.timestamp('created_at').nullable();
+        table.timestamp('updated_at').nullable();
+        table.index(['queue_name', 'expected_next_heartbeat_at'], 'idx_zjh_qn_next_hb');
+        table.index(['job_id', 'queue_name'], 'idx_zjh_job_queue');
+    });
+};
+export const migration = {
+    async up(db) {
+        const schema = MigrationSchema.create(db);
+        await expandJobsTableIfNeeded(db, schema);
+        await ensureHeartbeatsTable(schema);
+    },
+    async down(db) {
+        const schema = MigrationSchema.create(db);
+        await schema.dropIfExists('zintrust_job_heartbeats');
+    },
+};