@warlock.js/queue 5.13.0 → 5.15.0

package/cjs/index.cjs

@@ -1,7 +1,312 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_define_job = require('./define-job-DideGKQK.cjs');
 let _warlock_js_logger = require("@warlock.js/logger");
+let bullmq = require("bullmq");
 
+//#region ../queue/src/errors.ts
+/**
+* Thrown when the queue is used before `setQueueConfig` (or the queue
+* connector) supplied a configuration.
+*/
+var QueueNotConfiguredError = class extends Error {
+	constructor() {
+		super("@warlock.js/queue is not configured. Add src/config/queue.ts exporting a QueueConfig and register queueConnector() in warlock.config.ts > connectors, or call setQueueConfig() yourself.");
+		this.name = "QueueNotConfiguredError";
+	}
+};
+/**
+* Thrown for a malformed duration such as `"10 minutes"`.
+*/
+var InvalidDurationError = class extends Error {
+	constructor(value) {
+		super(`Invalid duration ${JSON.stringify(value)}: expected milliseconds as a non-negative number or a string like "500ms", "30s", "10m", "2h", "1d".`);
+		this.name = "InvalidDurationError";
+	}
+};
+/**
+* Thrown by `defineJob` for an invalid definition.
+*/
+var InvalidJobDefinitionError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "InvalidJobDefinitionError";
+	}
+};
+/**
+* Thrown by `retryFailedJob` when no failed job has the given id.
+*/
+var FailedJobNotFoundError = class extends Error {
+	constructor(id, queue) {
+		super(`No failed job with id "${id}" on queue "${queue}".`);
+		this.name = "FailedJobNotFoundError";
+	}
+};
+/**
+* Thrown by `queueDashboard` when an optional bull-board package is not
+* installed.
+*/
+var QueueDashboardDependencyError = class extends Error {
+	constructor(missing) {
+		super(`The queue dashboard needs the optional package "${missing}", which is not installed.\nInstall both bull-board packages:
+
+  npm install @bull-board/api @bull-board/fastify
+`);
+		this.name = "QueueDashboardDependencyError";
+	}
+};
+
+//#endregion
+//#region ../queue/src/config.ts
+let activeConfig;
+/**
+* Set the active queue configuration. In a Warlock app the queue connector
+* calls this at boot with `src/config/queue.ts`; scripts and tests may call
+* it directly. Replaces (does not merge) any previous configuration.
+*/
+function setQueueConfig(config) {
+	activeConfig = config;
+}
+/**
+* The active queue configuration. Throws {@link QueueNotConfiguredError}
+* when none was set.
+*/
+function getQueueConfig() {
+	if (!activeConfig) throw new QueueNotConfiguredError();
+	return activeConfig;
+}
+/** Forget the active configuration. */
+function resetQueueConfig() {
+	activeConfig = void 0;
+}
+/** The queue a job runs on when it names none. */
+function defaultQueueName() {
+	return activeConfig?.defaultQueue ?? "default";
+}
+
+//#endregion
+//#region ../queue/src/dashboard-middleware-adapter.ts
+/**
+* Run a Warlock middleware list against a raw Fastify request/reply pair.
+*
+* Bull-board's `FastifyAdapter` hands back a plain Fastify plugin, not a
+* Warlock route — there is no `Route`, no validation pipeline, and none of
+* `createRequestStore`'s context wiring (CSP, tracing, `@warlock.js/context`
+* stores). Reusing that full pipeline here would pull the whole request
+* machinery into a place it was never meant to run. Instead this builds the
+* minimal `Request`/`Response` pair — enough for guard-style middleware
+* (`authMiddleware`, `ipFilterMiddleware`, a custom check) to read the
+* request and short-circuit with a response, which covers every one of
+* bull-board's routes because they all sit behind the same hook.
+*
+* `@warlock.js/core` is imported dynamically so this module never drags
+* core's runtime graph into a process that never mounts the dashboard.
+*
+* @returns `true` when a middleware sent a response and the caller must not
+* continue (bull-board's handler must not run); `false` to continue.
+*/
+async function runDashboardMiddleware(middlewareList, fastifyRequest, fastifyReply) {
+	if (middlewareList.length === 0) return false;
+	const { Request, Response } = await import("@warlock.js/core");
+	const request = new Request();
+	const response = new Response();
+	response.setResponse(fastifyReply);
+	request.response = response;
+	response.request = request;
+	request.setRequest(fastifyRequest);
+	for (const middlewareFunction of middlewareList) if (await middlewareFunction({
+		request,
+		response
+	})) return true;
+	return false;
+}
+
+//#endregion
+//#region ../queue/src/dashboard-guard-plugin.ts
+/**
+* Wrap bull-board's Fastify plugin in a scope that runs `middlewareList`
+* on every request before bull-board's own routes see it.
+*
+* Bull-board's `FastifyAdapter.registerPlugin()` returns a plain Fastify
+* plugin with no hook for Warlock middleware to run through, and Fastify
+* only lets an `onRequest` hook be added to a plugin scope — never spliced
+* into a plugin someone else wrote. So this builds ONE plugin that adds the
+* hook to its own scope and then registers bull-board's plugin as a child of
+* that scope; Fastify's encapsulation runs the hook for every route the
+* child registers, which is every dashboard route.
+*/
+function buildDashboardGuardPlugin(middlewareList, bullBoardPlugin) {
+	return function dashboardGuardPlugin(instance, _options, done) {
+		if (middlewareList.length > 0) instance.addHook("onRequest", async (request, reply) => {
+			if (await runDashboardMiddleware(middlewareList, request, reply)) return reply;
+		});
+		instance.register(bullBoardPlugin);
+		done();
+	};
+}
+
+//#endregion
+//#region ../queue/src/job-registry.ts
+const jobs = /* @__PURE__ */ new Map();
+const listeners = /* @__PURE__ */ new Set();
+/**
+* Register a definition under its name.
+*
+* Re-registering a name REPLACES the previous definition: in development a
+* job module is re-evaluated on every reload, and refusing the second
+* evaluation would break the reload. Job names must therefore be unique
+* across the app — two different modules using one name leave only the
+* later handler active.
+*/
+function registerJob(job) {
+	jobs.set(job.name, job);
+	for (const listener of listeners) listener(job);
+}
+/** The definition registered under `name`, if any. */
+function findRegisteredJob(name) {
+	return jobs.get(name);
+}
+/** Every registered definition. */
+function registeredJobs() {
+	return [...jobs.values()];
+}
+/** The queue a definition runs on, resolved against the active config. */
+function queueOf(job) {
+	return job.queue ?? defaultQueueName();
+}
+/** Be told whenever a job is registered. Returns an unsubscribe function. */
+function onJobRegistered(listener) {
+	listeners.add(listener);
+	return () => listeners.delete(listener);
+}
+
+//#endregion
+//#region ../queue/src/process-job.ts
+/**
+* The single BullMQ processor every worker runs: route the job to the
+* handler registered under its name.
+*
+* A name with no handler in this process fails with `UnrecoverableError` —
+* retrying cannot make a missing definition appear, so it must not burn
+* through its attempts.
+*/
+async function processJob(job) {
+	const definition = findRegisteredJob(job.name);
+	if (!definition) throw new bullmq.UnrecoverableError(`No job named "${job.name}" is defined in this process. Make sure the module that calls defineJob() is imported by the worker process.`);
+	const context = {
+		id: String(job.id),
+		name: job.name,
+		queue: job.queueName,
+		attempt: job.attemptsMade + 1,
+		maxAttempts: job.opts.attempts ?? 1,
+		progress: (value) => job.updateProgress(value),
+		log: async (line) => {
+			await job.log(line);
+		}
+	};
+	return definition.handle(job.data, context);
+}
+
+//#endregion
+//#region ../queue/src/queue-manager.ts
+const DEFAULT_SHUTDOWN_TIMEOUT = 3e4;
+const queues = /* @__PURE__ */ new Map();
+const workers = /* @__PURE__ */ new Map();
+let stopListening;
+/**
+* The BullMQ queue for `name`, created on first use with the configured
+* connection and prefix.
+*/
+function getQueue(name) {
+	let queue = queues.get(name);
+	if (!queue) {
+		const config = getQueueConfig();
+		queue = new bullmq.Queue(name, {
+			connection: config.connection,
+			prefix: config.prefix ?? "warlock"
+		});
+		queue.on("error", (error) => {
+			_warlock_js_logger.log.error("queue", "connection", error);
+		});
+		queues.set(name, queue);
+	}
+	return queue;
+}
+/**
+* Start one worker per queue that has a registered job, and keep starting
+* workers for queues whose first job is defined later.
+*
+* A no-op returning `[]` when `workers.enabled` is `false`. Calling it again
+* while workers run starts only the missing ones.
+*
+* @returns the queue names that now have a worker in this process.
+*/
+async function startWorkers() {
+	if (getQueueConfig().workers?.enabled === false) return [];
+	for (const job of registeredJobs()) ensureWorker(queueOf(job));
+	stopListening ??= onJobRegistered((job) => {
+		ensureWorker(queueOf(job));
+	});
+	await Promise.all([...workers.values()].map((worker) => worker.waitUntilReady()));
+	return [...workers.keys()];
+}
+/** The queue names with a running worker in this process. */
+function runningWorkers() {
+	return [...workers.keys()];
+}
+function ensureWorker(queueName) {
+	if (workers.has(queueName)) return;
+	const config = getQueueConfig();
+	const worker = new bullmq.Worker(queueName, processJob, {
+		connection: config.connection,
+		prefix: config.prefix ?? "warlock",
+		concurrency: config.workers?.concurrency ?? 1
+	});
+	worker.on("error", (error) => {
+		_warlock_js_logger.log.error("queue", "worker", error);
+	});
+	worker.on("failed", (job, error) => {
+		_warlock_js_logger.log.error("queue", "job.failed", `${job?.name ?? "unknown"} (${job?.id ?? "?"}): ${error.message}`);
+	});
+	workers.set(queueName, worker);
+}
+/**
+* Graceful shutdown: stop workers taking new jobs and wait for active ones
+* (bounded by `timeout`, then force-close), then close every queue
+* connection. Safe to call when nothing was started, and more than once.
+*/
+async function closeQueue(options = {}) {
+	stopListening?.();
+	stopListening = void 0;
+	const timeout = options.timeout ?? configuredShutdownTimeout();
+	const closingWorkers = [...workers.values()];
+	workers.clear();
+	await Promise.all(closingWorkers.map((worker) => closeWorker(worker, timeout)));
+	const closingQueues = [...queues.values()];
+	queues.clear();
+	await Promise.all(closingQueues.map((queue) => queue.close()));
+}
+function configuredShutdownTimeout() {
+	try {
+		return getQueueConfig().workers?.shutdownTimeout ?? DEFAULT_SHUTDOWN_TIMEOUT;
+	} catch {
+		return DEFAULT_SHUTDOWN_TIMEOUT;
+	}
+}
+async function closeWorker(worker, timeout) {
+	let timer;
+	const timedOut = new Promise((resolve) => {
+		timer = setTimeout(() => resolve("timeout"), timeout);
+	});
+	const closing = worker.close().then(() => "closed");
+	closing.catch(() => void 0);
+	const outcome = await Promise.race([closing, timedOut]);
+	clearTimeout(timer);
+	if (outcome === "timeout") {
+		_warlock_js_logger.log.warn("queue", "shutdown", `Worker for "${worker.name}" still had active jobs after ${timeout}ms; disconnecting. Those jobs are retried once their lock expires.`);
+		await worker.disconnect();
+	}
+}
+
+//#endregion
 //#region ../queue/src/dashboard.ts
 /**
 * Mount the bull-board failed/active/delayed job UI on Warlock's Fastify
@@ -19,14 +324,15 @@ let _warlock_js_logger = require("@warlock.js/logger");
 async function queueDashboard(server, options = {}) {
 	const basePath = options.basePath ?? "/admin/queues";
 	const { createBullBoard, BullMQAdapter, FastifyAdapter } = await loadBullBoard();
-	const queueNames = options.queues ?? [...new Set([require_define_job.defaultQueueName(), ...require_define_job.registeredJobs().map((job) => require_define_job.queueOf(job))])];
+	const queueNames = options.queues ?? [...new Set([defaultQueueName(), ...registeredJobs().map((job) => queueOf(job))])];
 	const serverAdapter = new FastifyAdapter();
 	serverAdapter.setBasePath(basePath);
 	createBullBoard({
-		queues: queueNames.map((name) => new BullMQAdapter(require_define_job.getQueue(name))),
+		queues: queueNames.map((name) => new BullMQAdapter(getQueue(name))),
 		serverAdapter
 	});
-	await server.register(serverAdapter.registerPlugin(), { prefix: basePath });
+	const guardedPlugin = buildDashboardGuardPlugin(options.middleware ?? [], serverAdapter.registerPlugin());
+	await server.register(guardedPlugin, { prefix: basePath });
 }
 /**
 * Load the optional bull-board packages. Exported for tests of the missing
@@ -46,7 +352,7 @@ async function importOptional(importer, specifier) {
 	try {
 		return await importer(specifier);
 	} catch (error) {
-		if (isModuleNotFound(error)) throw new require_define_job.QueueDashboardDependencyError(specifier.split("/").slice(0, 2).join("/"));
+		if (isModuleNotFound(error)) throw new QueueDashboardDependencyError(specifier.split("/").slice(0, 2).join("/"));
 		throw error;
 	}
 }
@@ -55,6 +361,178 @@ function isModuleNotFound(error) {
 	return code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND";
 }
 
+//#endregion
+//#region ../queue/src/queue-dashboard-unguarded.error.ts
+/**
+* Thrown at boot when `queue.dashboard.enabled` is `true` in production with
+* no guard middleware. The dashboard can retry and delete jobs; mounting it
+* on the open internet without a guard is a production incident waiting to
+* happen, so this fails the boot instead of shipping the hole.
+*/
+var QueueDashboardUnguardedError = class extends Error {
+	constructor() {
+		super("queue.dashboard.enabled is true in production with no middleware. The dashboard can retry and delete jobs, so it must be guarded before it is exposed.\n\nAdd a guard middleware:\n\n  import { middleware } from \"@warlock.js/core\";\n  import { authMiddleware } from \"@warlock.js/auth\";\n\n  const queueConfig: QueueConfig = {\n    // ...\n    dashboard: {\n      enabled: true,\n      middleware: [authMiddleware(\"admin\")],\n    },\n  };\n");
+		this.name = "QueueDashboardUnguardedError";
+	}
+};
+
+//#endregion
+//#region ../queue/src/dashboard-boot.ts
+/** Default path the dashboard mounts on when `dashboard.path` is not set. */
+const DEFAULT_DASHBOARD_PATH = "/admin/queues";
+/**
+* Mount the bull-board dashboard for `queue.dashboard` in `config`, applying
+* the safety rule: `enabled` in production with no middleware throws
+* {@link QueueDashboardUnguardedError} instead of booting exposed; outside
+* production with no middleware it logs one warning and mounts anyway.
+*
+* Called by `queueConnector()` at boot, once the HTTP server exists but
+* before it starts listening — see `queue-connector.ts`. Exported so it can
+* be unit-tested without going through the whole connector lifecycle.
+*/
+async function mountQueueDashboard(server, config) {
+	const dashboard = config.dashboard;
+	if (!dashboard?.enabled) return;
+	const middlewareList = dashboard.middleware ?? [];
+	if (middlewareList.length === 0) {
+		if (process.env.NODE_ENV === "production") throw new QueueDashboardUnguardedError();
+		_warlock_js_logger.log.warn("queue", "dashboard", "queue.dashboard.enabled is true with no middleware. The dashboard can retry and delete jobs — add a guard middleware before this ships to production.");
+	}
+	if (!server) {
+		_warlock_js_logger.log.warn("queue", "dashboard", "queue.dashboard.enabled is true but no HTTP server was found; the dashboard was not mounted.");
+		return;
+	}
+	await queueDashboard(server, {
+		basePath: dashboard.path ?? "/admin/queues",
+		middleware: middlewareList
+	});
+}
+
+//#endregion
+//#region ../queue/src/duration.ts
+const UNIT_MILLISECONDS = {
+	ms: 1,
+	s: 1e3,
+	m: 6e4,
+	h: 36e5,
+	d: 864e5
+};
+const DURATION_PATTERN = /^(\d+(?:\.\d+)?)(ms|s|m|h|d)$/;
+/**
+* Convert a {@link Duration} to milliseconds. Numbers are already
+* milliseconds. Anything else is rejected loudly rather than guessed at.
+*/
+function toMilliseconds(value) {
+	if (typeof value === "number") {
+		if (!Number.isFinite(value) || value < 0) throw new InvalidDurationError(value);
+		return Math.round(value);
+	}
+	const match = typeof value === "string" ? DURATION_PATTERN.exec(value.trim()) : null;
+	if (!match) throw new InvalidDurationError(value);
+	return Math.round(Number(match[1]) * UNIT_MILLISECONDS[match[2]]);
+}
+
+//#endregion
+//#region ../queue/src/define-job.ts
+/**
+* Define a background job.
+*
+* The definition is registered by name so any worker in the process can run
+* it; the returned object dispatches it with a typed payload.
+*
+* @example
+* export const sendInvoice = defineJob({
+*   name: "invoices.send",
+*   attempts: 5,
+*   backoff: { type: "exponential", delay: 2000 },
+*   async handle(payload: { invoiceId: string }, ctx) {
+*     await ctx.progress(50);
+*   },
+* });
+*
+* await sendInvoice.dispatch({ invoiceId: "42" }, { delay: "10m", priority: 1 });
+*/
+function defineJob(definition) {
+	assertValidDefinition(definition);
+	registerJob(definition);
+	return {
+		name: definition.name,
+		get queue() {
+			return queueOf(definition);
+		},
+		async dispatch(payload, options = {}) {
+			const queueName = queueOf(definition);
+			const job = await getQueue(queueName).add(definition.name, payload, toBullJobOptions(definition, options));
+			return {
+				id: String(job.id),
+				name: definition.name,
+				queue: queueName
+			};
+		},
+		async find(id) {
+			const queue = getQueue(queueOf(definition));
+			const initialJob = await queue.getJob(id);
+			if (!initialJob || initialJob.name !== definition.name) return;
+			const state = await initialJob.getState();
+			return toSnapshot(await queue.getJob(id) ?? initialJob, state);
+		}
+	};
+}
+function assertValidDefinition(definition) {
+	if (typeof definition.name !== "string" || definition.name.trim() === "") throw new InvalidJobDefinitionError("defineJob() requires a non-empty `name`.");
+	if (typeof definition.handle !== "function") throw new InvalidJobDefinitionError(`defineJob("${definition.name}") requires a \`handle(payload, ctx)\` function.`);
+	if (definition.attempts !== void 0 && !(Number.isInteger(definition.attempts) && definition.attempts >= 1)) throw new InvalidJobDefinitionError(`defineJob("${definition.name}"): \`attempts\` must be an integer >= 1, got ${definition.attempts}.`);
+}
+/**
+* Merge app defaults < job definition < dispatch options into BullMQ's shape.
+*/
+function toBullJobOptions(definition, options) {
+	const defaults = getQueueConfig().defaultJobOptions ?? {};
+	const attempts = options.attempts ?? definition.attempts ?? defaults.attempts;
+	const backoff = options.backoff ?? definition.backoff ?? defaults.backoff;
+	const removeOnComplete = definition.removeOnComplete ?? defaults.removeOnComplete;
+	const removeOnFail = definition.removeOnFail ?? defaults.removeOnFail;
+	const bullOptions = {};
+	if (attempts !== void 0) bullOptions.attempts = attempts;
+	if (backoff !== void 0) bullOptions.backoff = toBullBackoff(backoff);
+	if (removeOnComplete !== void 0) bullOptions.removeOnComplete = removeOnComplete;
+	if (removeOnFail !== void 0) bullOptions.removeOnFail = removeOnFail;
+	if (options.delay !== void 0) bullOptions.delay = toMilliseconds(options.delay);
+	if (options.priority !== void 0) bullOptions.priority = options.priority;
+	if (options.jobId !== void 0) bullOptions.jobId = options.jobId;
+	return bullOptions;
+}
+function toBullBackoff(backoff) {
+	return typeof backoff === "number" ? {
+		type: "fixed",
+		delay: backoff
+	} : backoff;
+}
+/**
+* A plain view of a BullMQ job.
+*
+* @param job The job to read fields from.
+* @param state The job's state; pass a state read *before* `job` was
+* fetched (or re-fetched) so the returned snapshot's fields are consistent
+* with it. If omitted, the state is read from `job` directly.
+*/
+async function toSnapshot(job, state) {
+	const resolvedState = state ?? await job.getState();
+	return {
+		id: String(job.id),
+		name: job.name,
+		queue: job.queueName,
+		state: resolvedState,
+		payload: job.data,
+		progress: job.progress,
+		attemptsMade: job.attemptsMade,
+		result: job.returnvalue,
+		failedReason: job.failedReason || void 0,
+		createdAt: new Date(job.timestamp),
+		finishedAt: job.finishedOn ? new Date(job.finishedOn) : void 0
+	};
+}
+
 //#endregion
 //#region ../queue/src/failed-jobs.ts
 /**
@@ -62,16 +540,16 @@ function isModuleNotFound(error) {
 * failed unrecoverably. Each entry can be retried.
 */
 async function failedJobs(options = {}) {
-	return (await require_define_job.getQueue(options.queue ?? require_define_job.defaultQueueName()).getFailed(options.start ?? 0, options.end ?? 99)).map((job) => toFailedJob(job));
+	return (await getQueue(options.queue ?? defaultQueueName()).getFailed(options.start ?? 0, options.end ?? 99)).map((job) => toFailedJob(job));
 }
 /**
 * Retry one failed job by id: it goes back to waiting with its attempts reset.
 * Throws {@link FailedJobNotFoundError} when no FAILED job has that id.
 */
 async function retryFailedJob(id, options = {}) {
-	const queueName = options.queue ?? require_define_job.defaultQueueName();
-	const job = await require_define_job.getQueue(queueName).getJob(id);
-	if (!job || !await job.isFailed()) throw new require_define_job.FailedJobNotFoundError(id, queueName);
+	const queueName = options.queue ?? defaultQueueName();
+	const job = await getQueue(queueName).getJob(id);
+	if (!job || !await job.isFailed()) throw new FailedJobNotFoundError(id, queueName);
 	await job.retry("failed");
 }
 function toFailedJob(job) {
@@ -119,15 +597,30 @@ function queueConnector(options = {}) {
 		priority: 11,
 		lifecyclePhase: "late",
 		isActive: () => active,
-		boot: () => void 0,
+		/**
+		* Mounts the dashboard, when configured, here rather than in `start()`:
+		* `boot()` runs for every late-phase connector, in priority order, before
+		* any of them `start()`s — so by the time this runs, the HTTP connector
+		* (priority 5, before queue's 11) has already built its Fastify instance
+		* and registered its own plugins, but has not yet called `listen()`.
+		* Fastify refuses new plugin registrations after `listen()`, so this is
+		* the only point in the boot sequence where mounting is possible.
+		*/
+		async boot() {
+			const queueConfig = options.config ?? await readQueueConfig();
+			if (!queueConfig?.dashboard?.enabled) return;
+			setQueueConfig(queueConfig);
+			const { getHttpServer } = await import("@warlock.js/core");
+			await mountQueueDashboard(getHttpServer(), queueConfig);
+		},
 		async start() {
 			const queueConfig = options.config ?? await readQueueConfig();
 			if (!queueConfig) {
 				_warlock_js_logger.log.warn("queue", "configured", "queueConnector() is registered but no `queue` config was found (src/config/queue.ts); queue not started");
 				return;
 			}
-			require_define_job.setQueueConfig(queueConfig);
-			const started = await require_define_job.startWorkers();
+			setQueueConfig(queueConfig);
+			const started = await startWorkers();
 			active = true;
 			_warlock_js_logger.log.info("queue", "configured", started.length > 0 ? `Queue workers running for: ${started.join(", ")}` : "Queue configured (no in-process workers)");
 		},
@@ -137,8 +630,8 @@ function queueConnector(options = {}) {
 		},
 		async shutdown() {
 			if (!active) return;
-			await require_define_job.closeQueue();
-			require_define_job.resetQueueConfig();
+			await closeQueue();
+			resetQueueConfig();
 			active = false;
 		},
 		shouldRestart(changedFiles) {
@@ -156,25 +649,28 @@ async function readQueueConfig() {
 }
 
 //#endregion
-exports.FailedJobNotFoundError = require_define_job.FailedJobNotFoundError;
-exports.InvalidDurationError = require_define_job.InvalidDurationError;
-exports.InvalidJobDefinitionError = require_define_job.InvalidJobDefinitionError;
+exports.DEFAULT_DASHBOARD_PATH = DEFAULT_DASHBOARD_PATH;
+exports.FailedJobNotFoundError = FailedJobNotFoundError;
+exports.InvalidDurationError = InvalidDurationError;
+exports.InvalidJobDefinitionError = InvalidJobDefinitionError;
 exports.QUEUE_CONNECTOR_PRIORITY = QUEUE_CONNECTOR_PRIORITY;
-exports.QueueDashboardDependencyError = require_define_job.QueueDashboardDependencyError;
-exports.QueueNotConfiguredError = require_define_job.QueueNotConfiguredError;
-exports.closeQueue = require_define_job.closeQueue;
-exports.defaultQueueName = require_define_job.defaultQueueName;
-exports.defineJob = require_define_job.defineJob;
+exports.QueueDashboardDependencyError = QueueDashboardDependencyError;
+exports.QueueDashboardUnguardedError = QueueDashboardUnguardedError;
+exports.QueueNotConfiguredError = QueueNotConfiguredError;
+exports.closeQueue = closeQueue;
+exports.defaultQueueName = defaultQueueName;
+exports.defineJob = defineJob;
 exports.failedJobs = failedJobs;
-exports.getQueue = require_define_job.getQueue;
-exports.getQueueConfig = require_define_job.getQueueConfig;
+exports.getQueue = getQueue;
+exports.getQueueConfig = getQueueConfig;
 exports.loadBullBoard = loadBullBoard;
+exports.mountQueueDashboard = mountQueueDashboard;
 exports.queueConnector = queueConnector;
 exports.queueDashboard = queueDashboard;
-exports.resetQueueConfig = require_define_job.resetQueueConfig;
+exports.resetQueueConfig = resetQueueConfig;
 exports.retryFailedJob = retryFailedJob;
-exports.runningWorkers = require_define_job.runningWorkers;
-exports.setQueueConfig = require_define_job.setQueueConfig;
-exports.startWorkers = require_define_job.startWorkers;
-exports.toMilliseconds = require_define_job.toMilliseconds;
+exports.runningWorkers = runningWorkers;
+exports.setQueueConfig = setQueueConfig;
+exports.startWorkers = startWorkers;
+exports.toMilliseconds = toMilliseconds;
 //# sourceMappingURL=index.cjs.map