orcaq 1.1.1 → 1.1.3

package/.output/server/node_modules/@redis/client/dist/lib/errors.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenTelemetryError = exports.MultiErrorReply = exports.CommandTimeoutDuringMaintenanceError = exports.SocketTimeoutDuringMaintenanceError = exports.TimeoutError = exports.BlobError = exports.SimpleError = exports.ErrorReply = exports.ReconnectStrategyError = exports.RootNodesUnavailableError = exports.SocketClosedUnexpectedlyError = exports.DisconnectsClientError = exports.ClientOfflineError = exports.ClientClosedError = exports.SocketTimeoutError = exports.ConnectionTimeoutError = exports.WatchError = exports.AbortError = void 0;
+class AbortError extends Error {
+    constructor() {
+        super('The command was aborted');
+    }
+}
+exports.AbortError = AbortError;
+class WatchError extends Error {
+    constructor(message = 'One (or more) of the watched keys has been changed') {
+        super(message);
+    }
+}
+exports.WatchError = WatchError;
+class ConnectionTimeoutError extends Error {
+    constructor() {
+        super('Connection timeout');
+    }
+}
+exports.ConnectionTimeoutError = ConnectionTimeoutError;
+class SocketTimeoutError extends Error {
+    constructor(timeout) {
+        super(`Socket timeout timeout. Expecting data, but didn't receive any in ${timeout}ms.`);
+    }
+}
+exports.SocketTimeoutError = SocketTimeoutError;
+class ClientClosedError extends Error {
+    constructor() {
+        super('The client is closed');
+    }
+}
+exports.ClientClosedError = ClientClosedError;
+class ClientOfflineError extends Error {
+    constructor() {
+        super('The client is offline');
+    }
+}
+exports.ClientOfflineError = ClientOfflineError;
+class DisconnectsClientError extends Error {
+    constructor() {
+        super('Disconnects client');
+    }
+}
+exports.DisconnectsClientError = DisconnectsClientError;
+class SocketClosedUnexpectedlyError extends Error {
+    constructor() {
+        super('Socket closed unexpectedly');
+    }
+}
+exports.SocketClosedUnexpectedlyError = SocketClosedUnexpectedlyError;
+class RootNodesUnavailableError extends Error {
+    constructor() {
+        super('All the root nodes are unavailable');
+    }
+}
+exports.RootNodesUnavailableError = RootNodesUnavailableError;
+class ReconnectStrategyError extends Error {
+    originalError;
+    socketError;
+    constructor(originalError, socketError) {
+        super(originalError.message);
+        this.originalError = originalError;
+        this.socketError = socketError;
+    }
+}
+exports.ReconnectStrategyError = ReconnectStrategyError;
+class ErrorReply extends Error {
+}
+exports.ErrorReply = ErrorReply;
+class SimpleError extends ErrorReply {
+}
+exports.SimpleError = SimpleError;
+class BlobError extends ErrorReply {
+}
+exports.BlobError = BlobError;
+class TimeoutError extends Error {
+}
+exports.TimeoutError = TimeoutError;
+class SocketTimeoutDuringMaintenanceError extends TimeoutError {
+    constructor(timeout) {
+        super(`Socket timeout during maintenance. Expecting data, but didn't receive any in ${timeout}ms.`);
+    }
+}
+exports.SocketTimeoutDuringMaintenanceError = SocketTimeoutDuringMaintenanceError;
+class CommandTimeoutDuringMaintenanceError extends TimeoutError {
+    constructor(timeout) {
+        super(`Command timeout during maintenance. Waited to write command for more than ${timeout}ms.`);
+    }
+}
+exports.CommandTimeoutDuringMaintenanceError = CommandTimeoutDuringMaintenanceError;
+class MultiErrorReply extends ErrorReply {
+    replies;
+    errorIndexes;
+    constructor(replies, errorIndexes) {
+        super(`${errorIndexes.length} commands failed, see .replies and .errorIndexes for more information`);
+        this.replies = replies;
+        this.errorIndexes = errorIndexes;
+    }
+    *errors() {
+        for (const index of this.errorIndexes) {
+            yield this.replies[index];
+        }
+    }
+}
+exports.MultiErrorReply = MultiErrorReply;
+class OpenTelemetryError extends Error {
+}
+exports.OpenTelemetryError = OpenTelemetryError;
+//# sourceMappingURL=errors.js.map

package/.output/server/node_modules/@redis/client/dist/lib/lua-script.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scriptSha1 = exports.defineScript = void 0;
+const node_crypto_1 = require("node:crypto");
+function defineScript(script) {
+    return {
+        ...script,
+        SHA1: scriptSha1(script.SCRIPT)
+    };
+}
+exports.defineScript = defineScript;
+function scriptSha1(script) {
+    return (0, node_crypto_1.createHash)('sha1').update(script).digest('hex');
+}
+exports.scriptSha1 = scriptSha1;
+//# sourceMappingURL=lua-script.js.map

package/.output/server/node_modules/@redis/client/dist/lib/multi-command.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_1 = require("./errors");
+class RedisMultiCommand {
+    typeMapping;
+    constructor(typeMapping) {
+        this.typeMapping = typeMapping;
+    }
+    queue = [];
+    scriptsInUse = new Set();
+    addCommand(args, transformReply) {
+        this.queue.push({
+            args,
+            transformReply
+        });
+    }
+    addScript(script, args, transformReply) {
+        const redisArgs = [];
+        redisArgs.preserve = args.preserve;
+        if (this.scriptsInUse.has(script.SHA1)) {
+            redisArgs.push('EVALSHA', script.SHA1);
+        }
+        else {
+            this.scriptsInUse.add(script.SHA1);
+            redisArgs.push('EVAL', script.SCRIPT);
+        }
+        if (script.NUMBER_OF_KEYS !== undefined) {
+            redisArgs.push(script.NUMBER_OF_KEYS.toString());
+        }
+        redisArgs.push(...args);
+        this.addCommand(redisArgs, transformReply);
+    }
+    transformReplies(rawReplies) {
+        const errorIndexes = [], replies = rawReplies.map((reply, i) => {
+            if (reply instanceof errors_1.ErrorReply) {
+                errorIndexes.push(i);
+                return reply;
+            }
+            const { transformReply, args } = this.queue[i];
+            return transformReply ? transformReply(reply, args.preserve, this.typeMapping) : reply;
+        });
+        if (errorIndexes.length)
+            throw new errors_1.MultiErrorReply(replies, errorIndexes);
+        return replies;
+    }
+}
+exports.default = RedisMultiCommand;
+//# sourceMappingURL=multi-command.js.map

package/.output/server/node_modules/@redis/client/dist/lib/opentelemetry/client-registry.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientRegistry = void 0;
+/**
+ * No-op implementation of the client registry.
+ * Used when OpenTelemetry is not initialized to avoid overhead.
+ */
+class NoOpClientRegistry {
+    register(_handle) {
+        // No-op
+    }
+    unregister(_clientId) {
+        // No-op
+    }
+    getById(_clientId) {
+        return undefined;
+    }
+    getAll() {
+        return [];
+    }
+}
+/**
+ * Real implementation of the client registry.
+ * Tracks all registered clients in a Map keyed by client ID.
+ */
+class ClientRegistryImpl {
+    #clients = new Map();
+    register(handle) {
+        this.#clients.set(handle.identity.id, handle);
+    }
+    unregister(clientId) {
+        this.#clients.delete(clientId);
+    }
+    getById(clientId) {
+        return this.#clients.get(clientId);
+    }
+    getAll() {
+        return this.#clients.values();
+    }
+}
+/**
+ * Singleton manager for the client registry.
+ * Starts with a NoOp registry and can be initialized to use the real implementation.
+ */
+class ClientRegistry {
+    static #instance = new NoOpClientRegistry();
+    static #initialized = false;
+    constructor() { }
+    /**
+     * Initialize the client registry with the real implementation.
+     * Should be called from OpenTelemetry.init().
+     */
+    static init() {
+        if (ClientRegistry.#initialized) {
+            return;
+        }
+        ClientRegistry.#instance = new ClientRegistryImpl();
+        ClientRegistry.#initialized = true;
+    }
+    /**
+     * Get the current registry instance.
+     * Returns NoOp registry if not initialized, real registry otherwise.
+     */
+    static get instance() {
+        return ClientRegistry.#instance;
+    }
+    /**
+     * Check if the registry has been initialized.
+     */
+    static isInitialized() {
+        return ClientRegistry.#initialized;
+    }
+    /**
+     * Reset the registry to its initial state (NoOp).
+     * Only for testing purposes.
+     * @internal
+     */
+    static reset() {
+        ClientRegistry.#instance = new NoOpClientRegistry();
+        ClientRegistry.#initialized = false;
+    }
+}
+exports.ClientRegistry = ClientRegistry;
+//# sourceMappingURL=client-registry.js.map

package/.output/server/node_modules/@redis/client/dist/lib/opentelemetry/index.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientRegistry = exports.OTelMetrics = exports.CSC_EVICTION_REASON = exports.CSC_RESULT = exports.CONNECTION_CLOSE_REASON = exports.OTEL_ATTRIBUTES = exports.OpenTelemetry = void 0;
+const errors_1 = require("../errors");
+const client_registry_1 = require("./client-registry");
+const metrics_1 = require("./metrics");
+class OpenTelemetry {
+    static _instance = null;
+    // Make sure it's a singleton
+    constructor() { }
+    /**
+     * Initializes node-redis OpenTelemetry observability.
+     *
+     * This bootstraps node-redis metrics instrumentation and registers the
+     * internal client registry used by metric collectors.
+     *
+     * Call this once during application startup, before creating Redis clients
+     * you want to observe.
+     *
+     * @param config - Observability configuration.
+     *
+     * @remarks Requires Node.js >= 18.19.0.
+     *
+     * @throws {OpenTelemetryError} If OpenTelemetry is already initialized.
+     * @throws {OpenTelemetryError} If `@opentelemetry/api` is not installed.
+     *
+     * @example
+     * ```ts
+     * import { metrics } from "@opentelemetry/api";
+     * import {
+     *   ConsoleMetricExporter,
+     *   MeterProvider,
+     *   PeriodicExportingMetricReader
+     * } from "@opentelemetry/sdk-metrics";
+     * import { OpenTelemetry } from "redis";
+     *
+     * const reader = new PeriodicExportingMetricReader({
+     *   exporter: new ConsoleMetricExporter()
+     * });
+     *
+     * const provider = new MeterProvider({ readers: [reader] });
+     * metrics.setGlobalMeterProvider(provider);
+     *
+     * OpenTelemetry.init({
+     *   metrics: {
+     *     enabled: true,
+     *     enabledMetricGroups: ["pubsub", "connection-basic", "resiliency"],
+     *     includeCommands: ["GET", "SET"],
+     *     hidePubSubChannelNames: true
+     *   }
+     * });
+     * ```
+     */
+    static init(config) {
+        if (OpenTelemetry._instance) {
+            throw new errors_1.OpenTelemetryError("OpenTelemetry already initialized");
+        }
+        const api = (() => {
+            try {
+                return require("@opentelemetry/api");
+            }
+            catch {
+                throw new errors_1.OpenTelemetryError("@opentelemetry/api not found");
+            }
+        })();
+        OpenTelemetry._instance = new OpenTelemetry();
+        client_registry_1.ClientRegistry.init();
+        metrics_1.OTelMetrics.init({ api, config });
+    }
+}
+exports.OpenTelemetry = OpenTelemetry;
+var types_1 = require("./types");
+Object.defineProperty(exports, "OTEL_ATTRIBUTES", { enumerable: true, get: function () { return types_1.OTEL_ATTRIBUTES; } });
+Object.defineProperty(exports, "CONNECTION_CLOSE_REASON", { enumerable: true, get: function () { return types_1.CONNECTION_CLOSE_REASON; } });
+Object.defineProperty(exports, "CSC_RESULT", { enumerable: true, get: function () { return types_1.CSC_RESULT; } });
+Object.defineProperty(exports, "CSC_EVICTION_REASON", { enumerable: true, get: function () { return types_1.CSC_EVICTION_REASON; } });
+var metrics_2 = require("./metrics");
+Object.defineProperty(exports, "OTelMetrics", { enumerable: true, get: function () { return metrics_2.OTelMetrics; } });
+var client_registry_2 = require("./client-registry");
+Object.defineProperty(exports, "ClientRegistry", { enumerable: true, get: function () { return client_registry_2.ClientRegistry; } });
+//# sourceMappingURL=index.js.map