Review funkt

node_modules/bullmq/dist/esm/utils/create-backend.js

@@ -0,0 +1,75 @@
+import { RedisQueueBackend } from '../classes/redis-queue-backend';
+import { RedisConnection } from '../classes/redis-connection';
+import { QueueKeys } from '../classes/queue-keys';
+import { createIORedisClient, isIRedisClient } from '../classes/ioredis-client';
+import { isRedisInstance } from './index';
+/**
+ * Builds the dedicated, blocking connection that a worker needs so its blocking
+ * fetch (`BZPOPMIN`) does not stall regular operations. Reuses / duplicates the
+ * provided connection options with its own name.
+ */
+const createBlockingConnection = (name, opts) => {
+    var _a;
+    const base64Name = Buffer.from(name).toString('base64');
+    const workerName = opts.name;
+    const connectionName = `${(_a = opts.prefix) !== null && _a !== void 0 ? _a : 'bull'}:${base64Name}${workerName ? `:w:${workerName}` : ''}`;
+    return new RedisConnection(isRedisInstance(opts.connection)
+        ? (isIRedisClient(opts.connection)
+            ? opts.connection
+            : createIORedisClient(opts.connection)).duplicate({ connectionName })
+        : Object.assign(Object.assign({}, opts.connection), { connectionName }), {
+        shared: false,
+        blocking: true,
+        skipVersionCheck: opts.skipVersionCheck,
+    });
+};
+/**
+ * The default ({@link RedisConnection}-based) implementation of
+ * {@link BackendFactory}. The returned backend owns its connection(s); the
+ * high-level classes (Queue, Worker, FlowProducer, …) depend only on
+ * {@link IQueueBackend} and never touch a Redis client directly.
+ *
+ * Other datastores can provide their own {@link BackendFactory} and inject it
+ * into the queue classes.
+ */
+export const createRedisBackend = (name, opts, { blocking = false, withBlockingConnection = false } = {}) => {
+    const connection = new RedisConnection(opts.connection, {
+        shared: isRedisInstance(opts.connection),
+        blocking,
+        skipVersionCheck: opts.skipVersionCheck,
+        skipWaitingForReady: opts.skipWaitingForReady,
+    });
+    const blockingConnection = withBlockingConnection
+        ? createBlockingConnection(name, opts)
+        : undefined;
+    const queueKeys = new QueueKeys(opts.prefix);
+    const keys = queueKeys.getKeys(name);
+    const toKey = (type) => queueKeys.toKey(name, type);
+    return new RedisQueueBackend(connection, name, keys, toKey, opts, blockingConnection);
+};
+/**
+ * The process-wide default {@link BackendFactory} used by the high-level
+ * classes ({@link QueueBase}, {@link FlowProducer}) when the caller does not
+ * pass an explicit `backendFactory`. Initialised to the Redis backend so the
+ * default behaviour is unchanged.
+ */
+let defaultBackendFactory = createRedisBackend;
+/**
+ * Overrides the process-wide default {@link BackendFactory}. Useful to point
+ * every Queue/Worker/FlowProducer at a different datastore (e.g. the PostgreSQL
+ * backend) without threading a factory through every constructor — notably so
+ * the existing test suite can run unchanged against another backend.
+ *
+ * Pass no argument (or `undefined`) to reset back to the Redis backend.
+ */
+export function setDefaultBackendFactory(factory) {
+    defaultBackendFactory =
+        factory !== null && factory !== void 0 ? factory : createRedisBackend;
+}
+/**
+ * Returns the current process-wide default {@link BackendFactory}, typed as the
+ * caller's concrete backend `B`.
+ */
+export function getDefaultBackendFactory() {
+    return defaultBackendFactory;
+}