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;
+}

node_modules/bullmq/dist/cjs/utils/index.js

@@ -0,0 +1,335 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QUEUE_EVENT_SUFFIX = exports.toString = exports.errorToJSON = exports.parseObjectValues = exports.isRedisVersionLowerThan = exports.childSend = exports.asyncSend = exports.DELAY_TIME_1 = exports.DELAY_TIME_5 = exports.clientCommandMessageReg = exports.optsEncodeMap = exports.optsDecodeMap = exports.errorObject = exports.randomUUID = void 0;
+exports.tryCatch = tryCatch;
+exports.lengthInUtf8Bytes = lengthInUtf8Bytes;
+exports.isEmpty = isEmpty;
+exports.array2obj = array2obj;
+exports.objectToFlatArray = objectToFlatArray;
+exports.delay = delay;
+exports.forwardConnectionError = forwardConnectionError;
+exports.increaseMaxListeners = increaseMaxListeners;
+exports.invertObject = invertObject;
+exports.isRedisInstance = isRedisInstance;
+exports.isRedisCluster = isRedisCluster;
+exports.decreaseMaxListeners = decreaseMaxListeners;
+exports.removeAllQueueData = removeAllQueueData;
+exports.getParentKey = getParentKey;
+exports.isNotConnectionError = isNotConnectionError;
+exports.removeUndefinedFields = removeUndefinedFields;
+exports.trace = trace;
+var crypto_1 = require("crypto");
+Object.defineProperty(exports, "randomUUID", { enumerable: true, get: function () { return crypto_1.randomUUID; } });
+const connection_closed_error_1 = require("../classes/errors/connection-closed-error");
+const semver = require("semver");
+const enums_1 = require("../enums");
+exports.errorObject = { value: null };
+function tryCatch(fn, ctx, args) {
+    try {
+        return fn.apply(ctx, args);
+    }
+    catch (e) {
+        exports.errorObject.value = e;
+        return exports.errorObject;
+    }
+}
+/**
+ * Returns the size of a string in UTF-8 bytes (handles multi-byte characters correctly).
+ * @see https://stackoverflow.com/a/23318053/1347170
+ * @param str - The string to measure.
+ * @returns The byte length of the string when encoded as UTF-8.
+ */
+function lengthInUtf8Bytes(str) {
+    return Buffer.byteLength(str, 'utf8');
+}
+function isEmpty(obj) {
+    for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            return false;
+        }
+    }
+    return true;
+}
+function array2obj(arr) {
+    const obj = {};
+    for (let i = 0; i < arr.length; i += 2) {
+        obj[arr[i]] = arr[i + 1];
+    }
+    return obj;
+}
+function objectToFlatArray(obj) {
+    const arr = [];
+    for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key) &&
+            obj[key] !== undefined) {
+            arr[arr.length] = key;
+            arr[arr.length] = obj[key];
+        }
+    }
+    return arr;
+}
+function delay(ms, abortController) {
+    return new Promise(resolve => {
+        // eslint-disable-next-line prefer-const
+        let timeout;
+        const callback = () => {
+            abortController === null || abortController === void 0 ? void 0 : abortController.signal.removeEventListener('abort', callback);
+            clearTimeout(timeout);
+            resolve();
+        };
+        timeout = setTimeout(callback, ms);
+        abortController === null || abortController === void 0 ? void 0 : abortController.signal.addEventListener('abort', callback);
+    });
+}
+/**
+ * Forwards 'error' events from a connection to its owning emitter, but only
+ * when a consumer is listening. Emitting 'error' on an EventEmitter with no
+ * listeners throws, which would turn a transient connection error (e.g. a
+ * failed init handshake before the consumer attached its listener) into an
+ * unhandled rejection.
+ *
+ * @param emitter - The owner emitter (Queue, Worker, FlowProducer, ...).
+ * @param connection - The connection whose 'error' events should be forwarded.
+ */
+function forwardConnectionError(emitter, connection) {
+    connection.on('error', (error) => {
+        if (emitter.listenerCount('error') > 0) {
+            emitter.emit('error', error);
+        }
+    });
+}
+function increaseMaxListeners(emitter, count) {
+    const maxListeners = emitter.getMaxListeners();
+    emitter.setMaxListeners(maxListeners + count);
+}
+function invertObject(obj) {
+    return Object.entries(obj).reduce((result, [key, value]) => {
+        result[value] = key;
+        return result;
+    }, {});
+}
+exports.optsDecodeMap = {
+    de: 'deduplication',
+    fpof: 'failParentOnFailure',
+    cpof: 'continueParentOnFailure',
+    idof: 'ignoreDependencyOnFailure',
+    kl: 'keepLogs',
+    rdof: 'removeDependencyOnFailure',
+};
+exports.optsEncodeMap = Object.assign({}, invertObject(exports.optsDecodeMap));
+function isRedisInstance(obj) {
+    if (!obj) {
+        return false;
+    }
+    const redisApi = ['connect', 'disconnect', 'duplicate'];
+    return redisApi.every(name => typeof obj[name] === 'function');
+}
+function isRedisCluster(obj) {
+    return isRedisInstance(obj) && !!obj.isCluster;
+}
+function decreaseMaxListeners(emitter, count) {
+    increaseMaxListeners(emitter, -count);
+}
+async function removeAllQueueData(client, queueName, prefix = process.env.BULLMQ_TEST_PREFIX || 'bull') {
+    if (client.isCluster) {
+        // scanStream is not cluster-safe across all key slots.
+        // Applies to adapter clients and raw ioredis Cluster clients alike.
+        // @see https://github.com/luin/ioredis/issues/175
+        return false;
+    }
+    const pattern = `${prefix}:${queueName}:*`;
+    const pendingOperations = [];
+    await new Promise((resolve, reject) => {
+        const stream = client.scanStream({
+            match: pattern,
+        });
+        stream.on('data', (keys) => {
+            if (keys.length) {
+                const pipeline = client.pipeline();
+                keys.forEach(key => {
+                    pipeline.del(key);
+                });
+                const execPromise = pipeline.exec().catch(error => {
+                    reject(error);
+                    throw error;
+                });
+                pendingOperations.push(execPromise);
+            }
+        });
+        stream.on('end', () => resolve());
+        stream.on('error', error => reject(error));
+    });
+    // Wait for all pipeline operations to complete before closing the connection
+    await Promise.all(pendingOperations);
+    // Handle connection close with better error handling for Dragonfly
+    try {
+        await client.quit();
+    }
+    catch (error) {
+        if (isNotConnectionError(error)) {
+            throw error;
+        }
+    }
+}
+function getParentKey(opts) {
+    if (opts) {
+        return `${opts.queue}:${opts.id}`;
+    }
+}
+exports.clientCommandMessageReg = /ERR unknown command ['`]\s*client\s*['`]/;
+exports.DELAY_TIME_5 = 5000;
+exports.DELAY_TIME_1 = 100;
+function isNotConnectionError(error) {
+    if (error instanceof connection_closed_error_1.ConnectionClosedError) {
+        return false;
+    }
+    const { code, message: errorMessage } = error;
+    return (errorMessage !== connection_closed_error_1.CONNECTION_CLOSED_ERROR_MSG &&
+        !errorMessage.includes('ECONNREFUSED') &&
+        code !== 'ECONNREFUSED');
+}
+const asyncSend = (proc, msg) => {
+    return new Promise((resolve, reject) => {
+        if (typeof proc.send === 'function') {
+            proc.send(msg, (err) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve();
+                }
+            });
+        }
+        else if (typeof proc.postMessage === 'function') {
+            resolve(proc.postMessage(msg));
+        }
+        else {
+            resolve();
+        }
+    });
+};
+exports.asyncSend = asyncSend;
+const childSend = (proc, msg) => (0, exports.asyncSend)(proc, msg);
+exports.childSend = childSend;
+const isRedisVersionLowerThan = (currentVersion, minimumVersion, currentDatabaseType, desiredDatabaseType = 'redis') => {
+    if (currentDatabaseType === desiredDatabaseType) {
+        const version = semver.valid(semver.coerce(currentVersion));
+        return semver.lt(version, minimumVersion);
+    }
+    return false;
+};
+exports.isRedisVersionLowerThan = isRedisVersionLowerThan;
+const parseObjectValues = (obj) => {
+    const accumulator = {};
+    for (const value of Object.entries(obj)) {
+        accumulator[value[0]] = JSON.parse(value[1]);
+    }
+    return accumulator;
+};
+exports.parseObjectValues = parseObjectValues;
+const getCircularReplacer = (rootReference) => {
+    const references = new WeakSet();
+    references.add(rootReference);
+    return (_, value) => {
+        if (typeof value === 'object' && value !== null) {
+            if (references.has(value)) {
+                return '[Circular]';
+            }
+            references.add(value);
+        }
+        return value;
+    };
+};
+const errorToJSON = (value) => {
+    const error = {};
+    Object.getOwnPropertyNames(value).forEach(function (propName) {
+        error[propName] = value[propName];
+    });
+    return JSON.parse(JSON.stringify(error, getCircularReplacer(value)));
+};
+exports.errorToJSON = errorToJSON;
+const INFINITY = 1 / 0;
+const toString = (value) => {
+    if (value == null) {
+        return '';
+    }
+    // Exit early for strings to avoid a performance hit in some environments.
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        // Recursively convert values (susceptible to call stack limits).
+        return `${value.map(other => (other == null ? other : (0, exports.toString)(other)))}`;
+    }
+    if (typeof value == 'symbol' ||
+        Object.prototype.toString.call(value) == '[object Symbol]') {
+        return value.toString();
+    }
+    const result = `${value}`;
+    return result === '0' && 1 / value === -INFINITY ? '-0' : result;
+};
+exports.toString = toString;
+exports.QUEUE_EVENT_SUFFIX = ':qe';
+function removeUndefinedFields(obj) {
+    const newObj = {};
+    for (const key in obj) {
+        if (obj[key] !== undefined) {
+            newObj[key] = obj[key];
+        }
+    }
+    return newObj;
+}
+/**
+ * Wraps the code with telemetry and provides a span for configuration.
+ *
+ * @param telemetry - telemetry configuration. If undefined, the callback will be executed without telemetry.
+ * @param spanKind - kind of the span: Producer, Consumer, Internal
+ * @param queueName - queue name
+ * @param operation - operation name (such as add, process, etc)
+ * @param destination - destination name (normally the queue name)
+ * @param callback - code to wrap with telemetry
+ * @param srcPropagationMetadata -
+ * @returns
+ */
+async function trace(telemetry, spanKind, queueName, operation, destination, callback, srcPropagationMetadata) {
+    if (!telemetry) {
+        return callback();
+    }
+    else {
+        const { tracer, contextManager } = telemetry;
+        const currentContext = contextManager.active();
+        let parentContext;
+        if (srcPropagationMetadata) {
+            parentContext = contextManager.fromMetadata(currentContext, srcPropagationMetadata);
+        }
+        const spanName = destination ? `${operation} ${destination}` : operation;
+        const span = tracer.startSpan(spanName, {
+            kind: spanKind,
+        }, parentContext);
+        try {
+            span.setAttributes({
+                [enums_1.TelemetryAttributes.QueueName]: queueName,
+                [enums_1.TelemetryAttributes.QueueOperation]: operation,
+            });
+            let messageContext;
+            let dstPropagationMetadata;
+            if (spanKind === enums_1.SpanKind.CONSUMER && parentContext) {
+                messageContext = span.setSpanOnContext(parentContext);
+            }
+            else {
+                messageContext = span.setSpanOnContext(currentContext);
+            }
+            if (callback.length == 2) {
+                dstPropagationMetadata = contextManager.getMetadata(messageContext);
+            }
+            return await contextManager.with(messageContext, () => callback(span, dstPropagationMetadata));
+        }
+        catch (err) {
+            span.recordException(err);
+            throw err;
+        }
+        finally {
+            span.end();
+        }
+    }
+}