Review funkt

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

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRedisBackend = void 0;
+exports.setDefaultBackendFactory = setDefaultBackendFactory;
+exports.getDefaultBackendFactory = getDefaultBackendFactory;
+const redis_queue_backend_1 = require("../classes/redis-queue-backend");
+const redis_connection_1 = require("../classes/redis-connection");
+const queue_keys_1 = require("../classes/queue-keys");
+const ioredis_client_1 = require("../classes/ioredis-client");
+const index_1 = require("./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 redis_connection_1.RedisConnection((0, index_1.isRedisInstance)(opts.connection)
+        ? ((0, ioredis_client_1.isIRedisClient)(opts.connection)
+            ? opts.connection
+            : (0, ioredis_client_1.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.
+ */
+const createRedisBackend = (name, opts, { blocking = false, withBlockingConnection = false } = {}) => {
+    const connection = new redis_connection_1.RedisConnection(opts.connection, {
+        shared: (0, index_1.isRedisInstance)(opts.connection),
+        blocking,
+        skipVersionCheck: opts.skipVersionCheck,
+        skipWaitingForReady: opts.skipWaitingForReady,
+    });
+    const blockingConnection = withBlockingConnection
+        ? createBlockingConnection(name, opts)
+        : undefined;
+    const queueKeys = new queue_keys_1.QueueKeys(opts.prefix);
+    const keys = queueKeys.getKeys(name);
+    const toKey = (type) => queueKeys.toKey(name, type);
+    return new redis_queue_backend_1.RedisQueueBackend(connection, name, keys, toKey, opts, blockingConnection);
+};
+exports.createRedisBackend = createRedisBackend;
+/**
+ * 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 = exports.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.
+ */
+function setDefaultBackendFactory(factory) {
+    defaultBackendFactory =
+        factory !== null && factory !== void 0 ? factory : exports.createRedisBackend;
+}
+/**
+ * Returns the current process-wide default {@link BackendFactory}, typed as the
+ * caller's concrete backend `B`.
+ */
+function getDefaultBackendFactory() {
+    return defaultBackendFactory;
+}