@zintrust/core 0.1.41 → 0.1.43

package/packages/cloudflare-kv-proxy/src/index.js

@@ -0,0 +1,325 @@
+import { ErrorHandler, RequestValidator, SigningService } from '../../../src/proxy.js';
+const DEFAULT_SIGNING_WINDOW_MS = 60_000;
+const DEFAULT_MAX_BODY_BYTES = 128 * 1024;
+const DEFAULT_LIST_LIMIT = 100;
+const json = (status, body) => {
+    return new Response(JSON.stringify(body), {
+        status,
+        headers: {
+            'Content-Type': 'application/json; charset=utf-8',
+            'Cache-Control': 'no-store',
+        },
+    });
+};
+const toErrorResponse = (status, code, message) => {
+    const error = ErrorHandler.toProxyError(status, code, message);
+    return json(error.status, error.body);
+};
+const getEnvInt = (env, name, fallback) => {
+    const raw = env[name];
+    if (typeof raw !== 'string')
+        return fallback;
+    const parsed = Number.parseInt(raw, 10);
+    return Number.isFinite(parsed) ? parsed : fallback;
+};
+const isRecord = (value) => typeof value === 'object' && value !== null;
+const isString = (value) => typeof value === 'string';
+const normalizeBindingName = (value) => {
+    if (!isString(value))
+        return null;
+    const trimmed = value.trim();
+    return trimmed === '' ? null : trimmed;
+};
+const readBodyBytes = async (request, maxBytes) => {
+    const buf = await request.arrayBuffer();
+    if (buf.byteLength > maxBytes) {
+        return {
+            ok: false,
+            response: toErrorResponse(413, 'PAYLOAD_TOO_LARGE', 'Body too large'),
+        };
+    }
+    const bytes = new Uint8Array(buf);
+    const text = new TextDecoder().decode(bytes);
+    return { ok: true, bytes, text };
+};
+const parseOptionalJson = (text) => {
+    if (text.trim() === '')
+        return { ok: true, payload: null };
+    const parsed = RequestValidator.parseJson(text);
+    if (!parsed.ok) {
+        // Type guard: we know parsed has 'error' property when ok is false
+        const errorResult = parsed;
+        let message = errorResult.error.message;
+        if (errorResult.error.code === 'INVALID_JSON') {
+            message = 'Invalid JSON body';
+        }
+        else if (errorResult.error.code === 'VALIDATION_ERROR') {
+            message = 'Invalid body';
+        }
+        return { ok: false, response: toErrorResponse(400, errorResult.error.code, message) };
+    }
+    // Type guard: we know parsed has 'value' property when ok is true
+    const successResult = parsed;
+    return { ok: true, payload: successResult.value };
+};
+const loadSigningSecret = (env) => {
+    const direct = typeof env.KV_REMOTE_SECRET === 'string' ? env.KV_REMOTE_SECRET.trim() : '';
+    if (direct !== '')
+        return direct;
+    const fallback = typeof env.APP_KEY === 'string' ? env.APP_KEY.trim() : '';
+    if (fallback !== '')
+        return fallback;
+    return null;
+};
+const verifyNonceKv = async (kv, keyId, nonce, ttlMs) => {
+    const ttlSeconds = Math.max(1, Math.ceil(ttlMs / 1000));
+    const storageKey = `nonce:${keyId}:${nonce}`;
+    const existing = await kv.get(storageKey);
+    if (existing !== null)
+        return false;
+    await kv.put(storageKey, '1', { expirationTtl: ttlSeconds });
+    return true;
+};
+const verifySignedRequest = async (request, env, bodyBytes) => {
+    const secret = loadSigningSecret(env);
+    if (secret === null) {
+        return toErrorResponse(500, 'CONFIG_ERROR', 'Missing signing secret (KV_REMOTE_SECRET or APP_KEY)');
+    }
+    const windowMs = getEnvInt(env, 'ZT_PROXY_SIGNING_WINDOW_MS', DEFAULT_SIGNING_WINDOW_MS);
+    const verifyResult = await SigningService.verifyWithKeyProvider({
+        method: request.method,
+        url: request.url,
+        body: bodyBytes,
+        headers: request.headers,
+        windowMs,
+        getSecretForKeyId: async (_keyId) => secret,
+        verifyNonce: env.ZT_NONCES === undefined
+            ? undefined
+            : async (keyId, nonce, ttlMs) => verifyNonceKv(env.ZT_NONCES, keyId, nonce, ttlMs),
+    });
+    if (verifyResult.ok === false) {
+        return toErrorResponse(verifyResult.status, verifyResult.code, verifyResult.message);
+    }
+    return { ok: true };
+};
+const requireCache = (env) => {
+    if (env.CACHE !== undefined && env.CACHE !== null)
+        return env.CACHE;
+    const bindingName = normalizeBindingName(env.KV_NAMESPACE);
+    if (bindingName !== null) {
+        const record = env;
+        const kv = record[bindingName];
+        if (kv !== undefined && kv !== null)
+            return kv;
+    }
+    return toErrorResponse(500, 'CONFIG_ERROR', 'Missing KV binding (CACHE)');
+};
+const normalizeNamespace = (value) => {
+    if (!isString(value))
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed === '' ? undefined : trimmed;
+};
+const buildStorageKey = (env, params) => {
+    const prefix = typeof env.ZT_KV_PREFIX === 'string' ? env.ZT_KV_PREFIX : '';
+    const ns = normalizeNamespace(params.namespace);
+    const parts = [];
+    if (prefix.trim() !== '')
+        parts.push(prefix.trim());
+    if (ns !== undefined)
+        parts.push(ns);
+    parts.push(params.key);
+    return parts.join(':');
+};
+const readAndVerifyJson = async (request, env) => {
+    const maxBodyBytes = getEnvInt(env, 'ZT_MAX_BODY_BYTES', DEFAULT_MAX_BODY_BYTES);
+    const bodyResult = await readBodyBytes(request, maxBodyBytes);
+    if (bodyResult.ok === false)
+        return { ok: false, response: bodyResult.response };
+    const auth = await verifySignedRequest(request, env, bodyResult.bytes);
+    if (auth instanceof Response)
+        return { ok: false, response: auth };
+    const parsed = parseOptionalJson(bodyResult.text);
+    if (parsed.ok === false)
+        return { ok: false, response: parsed.response };
+    return { ok: true, payload: parsed.payload, bodyBytes: bodyResult.bytes };
+};
+const parseGetPayload = (payload) => {
+    if (!isRecord(payload)) {
+        return {
+            ok: false,
+            response: toErrorResponse(400, 'VALIDATION_ERROR', 'Invalid body'),
+        };
+    }
+    const key = payload['key'];
+    const type = payload['type'];
+    if (!isString(key) || key.trim() === '') {
+        return {
+            ok: false,
+            response: toErrorResponse(400, 'VALIDATION_ERROR', 'key is required'),
+        };
+    }
+    const typeValue = type === 'text' || type === 'arrayBuffer' || type === 'json' ? type : 'text';
+    return { ok: true, namespace: normalizeNamespace(payload['namespace']), key, type: typeValue };
+};
+const handleGet = async (request, env) => {
+    const check = await readAndVerifyJson(request, env);
+    if (check.ok === false)
+        return check.response;
+    const cache = requireCache(env);
+    if (cache instanceof Response)
+        return cache;
+    const parsed = parseGetPayload(check.payload);
+    if (parsed.ok === false)
+        return parsed.response;
+    const storageKey = buildStorageKey(env, { namespace: parsed.namespace, key: parsed.key });
+    if (parsed.type === 'json') {
+        const value = await cache.get(storageKey, 'json');
+        return json(200, { value: value ?? null });
+    }
+    if (parsed.type === 'arrayBuffer') {
+        const value = await cache.get(storageKey, 'arrayBuffer');
+        return json(200, { value: value ?? null });
+    }
+    const value = await cache.get(storageKey);
+    return json(200, { value: value ?? null });
+};
+const parsePutPayload = (payload) => {
+    if (!isRecord(payload)) {
+        return {
+            ok: false,
+            response: toErrorResponse(400, 'VALIDATION_ERROR', 'Invalid body'),
+        };
+    }
+    const key = payload['key'];
+    if (!isString(key) || key.trim() === '') {
+        return {
+            ok: false,
+            response: toErrorResponse(400, 'VALIDATION_ERROR', 'key is required'),
+        };
+    }
+    const ttlSeconds = payload['ttlSeconds'];
+    const ttl = typeof ttlSeconds === 'number' && Number.isFinite(ttlSeconds) && ttlSeconds > 0
+        ? ttlSeconds
+        : undefined;
+    return {
+        ok: true,
+        namespace: normalizeNamespace(payload['namespace']),
+        key,
+        value: payload['value'],
+        ttlSeconds: ttl,
+    };
+};
+const handlePut = async (request, env) => {
+    const check = await readAndVerifyJson(request, env);
+    if (check.ok === false)
+        return check.response;
+    const cache = requireCache(env);
+    if (cache instanceof Response)
+        return cache;
+    const parsed = parsePutPayload(check.payload);
+    if (parsed.ok === false)
+        return parsed.response;
+    const storageKey = buildStorageKey(env, { namespace: parsed.namespace, key: parsed.key });
+    const value = JSON.stringify(parsed.value);
+    const options = {};
+    if (parsed.ttlSeconds !== undefined) {
+        options.expirationTtl = Math.floor(parsed.ttlSeconds);
+    }
+    await cache.put(storageKey, value, options);
+    return json(200, { ok: true });
+};
+const parseDeletePayload = (payload) => {
+    if (!isRecord(payload)) {
+        return {
+            ok: false,
+            response: toErrorResponse(400, 'VALIDATION_ERROR', 'Invalid body'),
+        };
+    }
+    const key = payload['key'];
+    if (!isString(key) || key.trim() === '') {
+        return {
+            ok: false,
+            response: toErrorResponse(400, 'VALIDATION_ERROR', 'key is required'),
+        };
+    }
+    return { ok: true, namespace: normalizeNamespace(payload['namespace']), key };
+};
+const handleDelete = async (request, env) => {
+    const check = await readAndVerifyJson(request, env);
+    if (check.ok === false)
+        return check.response;
+    const cache = requireCache(env);
+    if (cache instanceof Response)
+        return cache;
+    const parsed = parseDeletePayload(check.payload);
+    if (parsed.ok === false)
+        return parsed.response;
+    const storageKey = buildStorageKey(env, { namespace: parsed.namespace, key: parsed.key });
+    await cache.delete(storageKey);
+    return json(200, { ok: true });
+};
+const parseListPayload = (payload) => {
+    if (payload === null)
+        return { ok: true, params: {} };
+    if (!isRecord(payload)) {
+        return {
+            ok: false,
+            response: toErrorResponse(400, 'VALIDATION_ERROR', 'Invalid body'),
+        };
+    }
+    const namespace = normalizeNamespace(payload['namespace']);
+    const prefix = isString(payload['prefix']) ? payload['prefix'] : undefined;
+    const cursor = isString(payload['cursor']) ? payload['cursor'] : undefined;
+    const limitRaw = payload['limit'];
+    const limitParsed = typeof limitRaw === 'number' && Number.isFinite(limitRaw) ? Math.floor(limitRaw) : undefined;
+    return { ok: true, params: { namespace, prefix, cursor, limit: limitParsed } };
+};
+const handleList = async (request, env) => {
+    const check = await readAndVerifyJson(request, env);
+    if (check.ok === false)
+        return check.response;
+    const cache = requireCache(env);
+    if (cache instanceof Response)
+        return cache;
+    const parsed = parseListPayload(check.payload);
+    if (parsed.ok === false)
+        return parsed.response;
+    const envLimit = getEnvInt(env, 'ZT_KV_LIST_LIMIT', DEFAULT_LIST_LIMIT);
+    const requested = parsed.params.limit ?? envLimit;
+    const limit = Math.max(1, Math.min(requested, envLimit));
+    const prefixKey = parsed.params.prefix;
+    const nsPrefix = normalizeNamespace(parsed.params.namespace);
+    const basePrefix = buildStorageKey(env, { namespace: nsPrefix, key: '' });
+    const fullPrefix = prefixKey === undefined ? basePrefix : `${basePrefix}${prefixKey}`;
+    const out = await cache.list({ prefix: fullPrefix, limit, cursor: parsed.params.cursor });
+    return json(200, {
+        keys: out.keys.map((k) => k.name),
+        cursor: out.cursor,
+        listComplete: out.list_complete,
+    });
+};
+export const ZintrustKvProxy = Object.freeze({
+    _ZINTRUST_CLOUDFLARE_KV_PROXY_VERSION: '0.1.15',
+    _ZINTRUST_CLOUDFLARE_KV_PROXY_BUILD_DATE: '__BUILD_DATE__',
+    async fetch(request, env) {
+        const url = new URL(request.url);
+        const methodError = RequestValidator.requirePost(request.method);
+        if (methodError !== null) {
+            return toErrorResponse(405, methodError.code, 'Method not allowed');
+        }
+        switch (url.pathname) {
+            case '/zin/kv/get':
+                return handleGet(request, env);
+            case '/zin/kv/put':
+                return handlePut(request, env);
+            case '/zin/kv/delete':
+                return handleDelete(request, env);
+            case '/zin/kv/list':
+                return handleList(request, env);
+            default:
+                return toErrorResponse(404, 'NOT_FOUND', 'Not found');
+        }
+    },
+});
+export default ZintrustKvProxy;

package/packages/queue-monitor/src/QueueMonitoringService.d.ts

@@ -0,0 +1,35 @@
+import type { IRequest, IResponse } from '../../../src/index.js';
+import type { QueueDriver } from './driver';
+import type { LockAnalytics, QueueMonitorSnapshot } from './index';
+import type { JobSummary, Metrics } from './metrics';
+type QueueSnapshotData = {
+    type: string;
+    ts: string;
+    queue: string | null;
+    snapshot: QueueMonitorSnapshot;
+    jobs: unknown[];
+    locks: LockAnalytics;
+};
+type QueueMonitoringConfig = {
+    getSnapshot: () => Promise<QueueMonitorSnapshot>;
+    getLocks: (pattern?: string) => Promise<LockAnalytics>;
+    getRecentJobsForQueue: (queue: string, metrics: Metrics, driver: QueueDriver) => Promise<unknown[]>;
+    metrics: Metrics;
+    driver: QueueDriver;
+    queue: string;
+    pattern: string;
+    intervalMs: number;
+};
+export declare const QueueMonitoringService: Readonly<{
+    subscribe(callback: (data: QueueSnapshotData) => void): void;
+    unsubscribe(callback: (data: QueueSnapshotData) => void): void;
+    startPollingForClient(config: QueueMonitoringConfig): void;
+    stopPollingForClient(): void;
+}>;
+export declare const QueueMonitoringStream: (res: IResponse, req: IRequest, getSnapshot: () => Promise<QueueMonitorSnapshot>, getLocks: (pattern?: string) => Promise<LockAnalytics>, metrics: Metrics, driver: QueueDriver, settings: {
+    basePath: string;
+    refreshIntervalMs: number;
+}) => void;
+export declare function getRecentJobsForQueue(queueName: string, metrics: Metrics, driver: QueueDriver): Promise<JobSummary[]>;
+export {};
+//# sourceMappingURL=QueueMonitoringService.d.ts.map

package/packages/queue-monitor/src/QueueMonitoringService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueueMonitoringService.d.ts","sourceRoot":"","sources":["../../../../packages/queue-monitor/src/QueueMonitoringService.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE1D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AACnE,OAAO,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAErD,KAAK,iBAAiB,GAAG;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,QAAQ,EAAE,oBAAoB,CAAC;IAC/B,IAAI,EAAE,OAAO,EAAE,CAAC;IAChB,KAAK,EAAE,aAAa,CAAC;CACtB,CAAC;AAEF,KAAK,qBAAqB,GAAG;IAC3B,WAAW,EAAE,MAAM,OAAO,CAAC,oBAAoB,CAAC,CAAC;IACjD,QAAQ,EAAE,CAAC,OAAO,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,aAAa,CAAC,CAAC;IACvD,qBAAqB,EAAE,CACrB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,WAAW,KAChB,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;IACxB,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,WAAW,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA4DF,eAAO,MAAM,sBAAsB;wBACb,CAAC,IAAI,EAAE,iBAAiB,KAAK,IAAI,GAAG,IAAI;0BAKtC,CAAC,IAAI,EAAE,iBAAiB,KAAK,IAAI,GAAG,IAAI;kCAShC,qBAAqB,GAAG,IAAI;4BAOlC,IAAI;EAM5B,CAAC;AAOH,eAAO,MAAM,qBAAqB,GAChC,KAAK,SAAS,EACd,KAAK,QAAQ,EACb,aAAa,MAAM,OAAO,CAAC,oBAAoB,CAAC,EAChD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,aAAa,CAAC,EACtD,SAAS,OAAO,EAChB,QAAQ,WAAW,EACnB,UAAU;IACR,QAAQ,EAAE,MAAM,CAAC;IACjB,iBAAiB,EAAE,MAAM,CAAC;CAC3B,KACA,IAkEF,CAAC;AAEF,wBAAsB,qBAAqB,CACzC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,WAAW,GAClB,OAAO,CAAC,UAAU,EAAE,CAAC,CAmDvB"}

package/packages/queue-monitor/src/QueueMonitoringService.js

@@ -0,0 +1,194 @@
+import { Logger, NodeSingletons } from '../../../src/index.js';
+// Internal state
+const emitter = new NodeSingletons.EventEmitter();
+emitter.setMaxListeners(Infinity);
+let interval = null;
+let subscribers = 0;
+let currentConfig = null;
+const broadcastSnapshot = async () => {
+    try {
+        if (subscribers <= 0 || !currentConfig)
+            return;
+        const { getSnapshot, getLocks, metrics, driver, queue: initialQueue, pattern } = currentConfig;
+        const snapshot = await getSnapshot();
+        let queue = initialQueue;
+        if (!queue && snapshot.queues.length > 0) {
+            queue = snapshot.queues[0].name;
+        }
+        const jobs = queue ? await getRecentJobsForQueue(queue, metrics, driver) : [];
+        const locks = await getLocks(pattern);
+        const payload = {
+            type: 'snapshot',
+            ts: new Date().toISOString(),
+            queue: queue || null,
+            snapshot,
+            jobs,
+            locks,
+        };
+        emitter.emit('snapshot', payload);
+    }
+    catch (err) {
+        Logger.error('QueueMonitoringService.broadcastSnapshot failed', err);
+        if (emitter.listenerCount('error') > 0) {
+            emitter.emit('error', err);
+        }
+    }
+};
+const startPolling = () => {
+    if (interval || !currentConfig)
+        return;
+    Logger.debug('Starting QueueMonitoringService polling');
+    // Initial fetch
+    void broadcastSnapshot();
+    interval = setInterval(() => {
+        void broadcastSnapshot();
+    }, currentConfig.intervalMs);
+};
+const stopPolling = () => {
+    if (interval) {
+        Logger.debug('Stopping QueueMonitoringService polling');
+        clearInterval(interval);
+        interval = null;
+    }
+};
+export const QueueMonitoringService = Object.freeze({
+    subscribe(callback) {
+        emitter.on('snapshot', callback);
+        subscribers++;
+    },
+    unsubscribe(callback) {
+        emitter.off('snapshot', callback);
+        subscribers--;
+        if (subscribers <= 0) {
+            stopPolling();
+            currentConfig = null;
+        }
+    },
+    startPollingForClient(config) {
+        if (subscribers === 1) {
+            currentConfig = config;
+            startPolling();
+        }
+    },
+    stopPollingForClient() {
+        if (subscribers <= 0) {
+            stopPolling();
+            currentConfig = null;
+        }
+    },
+});
+//  settings: {
+//     basePath: string;
+//     refreshIntervalMs: number;
+//   },
+//   routeOptions: unknown,
+//   getSnapshot: () => Promise<QueueMonitorSnapshot>,
+export const QueueMonitoringStream = (res, req, getSnapshot, getLocks, metrics, driver, settings) => {
+    const raw = res.getRaw();
+    raw.writeHead(200, {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache, no-transform',
+        Connection: 'keep-alive',
+        'X-Accel-Buffering': 'no',
+    });
+    let closed = false;
+    const send = (payload) => {
+        if (closed)
+            return;
+        try {
+            const data = JSON.stringify(payload);
+            raw.write(`data: ${data}\n\n`);
+        }
+        catch (err) {
+            Logger.error('QueueMonitor SSE send failed', err);
+        }
+    };
+    // Send hello immediately
+    send({ type: 'hello', ts: new Date().toISOString() });
+    // Get query parameters
+    const getQuery = () => typeof req.getQuery === 'function'
+        ? req.getQuery()
+        : {};
+    const query = getQuery();
+    const queue = query['queue'] ?? '';
+    const pattern = query['pattern'] ?? '*';
+    // Define subscription callback
+    const onSnapshot = (data) => {
+        send(data);
+    };
+    // Subscribe to centralized service
+    QueueMonitoringService.subscribe(onSnapshot);
+    // Start polling for this client
+    QueueMonitoringService.startPollingForClient({
+        getSnapshot,
+        getLocks,
+        getRecentJobsForQueue,
+        metrics,
+        driver,
+        queue,
+        pattern,
+        intervalMs: settings.refreshIntervalMs,
+    });
+    // Heartbeat to keep connection alive
+    const hb = setInterval(() => {
+        if (!closed)
+            raw.write(': ping\n\n');
+    }, 15000);
+    raw.on('close', () => {
+        closed = true;
+        clearInterval(hb);
+        QueueMonitoringService.unsubscribe(onSnapshot);
+        QueueMonitoringService.stopPollingForClient();
+    });
+};
+export async function getRecentJobsForQueue(queueName, metrics, driver) {
+    const recent = await metrics.getRecentJobs(queueName);
+    const failed = await metrics.getFailedJobs(queueName);
+    const all = [...recent, ...failed].sort((a, b) => b.timestamp - a.timestamp).slice(0, 100);
+    if (all.length > 0) {
+        return all;
+    }
+    const jobs = await driver.getRecentJobs(queueName, 100);
+    const now = Date.now();
+    return jobs.map((job) => {
+        // Use the actual state from BullMQ if available
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const jobState = job._state;
+        // Fallback detection if state is not available
+        const isFailed = Boolean(job.failedReason) || jobState === 'failed';
+        const isCompleted = Boolean(job.finishedOn) || jobState === 'completed';
+        const isActive = Boolean(job.processedOn && !job.finishedOn && !job.failedReason) || jobState === 'active';
+        const isDelayed = jobState === 'delayed';
+        const isPaused = jobState === 'paused';
+        let status;
+        if (isFailed) {
+            status = 'failed';
+        }
+        else if (isCompleted) {
+            status = 'completed';
+        }
+        else if (isActive) {
+            status = 'active';
+        }
+        else if (isDelayed) {
+            status = 'delayed';
+        }
+        else if (isPaused) {
+            status = 'paused';
+        }
+        else {
+            status = 'waiting';
+        }
+        return {
+            id: job.id,
+            name: job.name,
+            data: job.data,
+            attempts: job.attemptsMade,
+            status,
+            failedReason: job.failedReason || undefined,
+            timestamp: job.timestamp ?? now,
+            processedOn: job.processedOn ?? undefined,
+            finishedOn: job.finishedOn ?? undefined,
+        };
+    });
+}

package/packages/queue-monitor/src/connection.d.ts

@@ -0,0 +1,3 @@
+export { createRedisConnection } from '../../../src/index.js';
+export type { RedisConfig } from '../../../src/index.js';
+//# sourceMappingURL=connection.d.ts.map

package/packages/queue-monitor/src/connection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection.d.ts","sourceRoot":"","sources":["../../../../packages/queue-monitor/src/connection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AACvD,YAAY,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC"}

package/packages/queue-monitor/src/connection.js

@@ -0,0 +1 @@
+export { createRedisConnection } from '../../../src/index.js';

package/packages/queue-monitor/src/dashboard-ui.d.ts

@@ -0,0 +1,7 @@
+export type DashboardUiOptions = {
+    basePath: string;
+    autoRefresh: boolean;
+    refreshIntervalMs: number;
+};
+export declare const getDashboardHtml: (options: DashboardUiOptions) => string;
+//# sourceMappingURL=dashboard-ui.d.ts.map

package/packages/queue-monitor/src/dashboard-ui.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dashboard-ui.d.ts","sourceRoot":"","sources":["../../../../packages/queue-monitor/src/dashboard-ui.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,OAAO,CAAC;IACrB,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AAq/BF,eAAO,MAAM,gBAAgB,GAAI,SAAS,kBAAkB,KAAG,MAiBvD,CAAC"}