orcaq 1.1.1 → 1.1.3

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

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Parse the hotkeys array into HotkeyEntry objects
+ */
+function parseHotkeysList(arr) {
+    const result = [];
+    for (let i = 0; i < arr.length; i += 2) {
+        result.push({
+            key: arr[i].toString(),
+            value: Number(arr[i + 1])
+        });
+    }
+    return result;
+}
+/**
+ * Parse slot ranges from the server response.
+ * Single slots are represented as arrays with one element: [slot]
+ * Slot ranges are represented as arrays with two elements: [start, end]
+ */
+function parseSlotRanges(arr) {
+    return arr.map(range => {
+        const unwrapped = range;
+        if (unwrapped.length === 1) {
+            // Single slot - start and end are the same
+            return {
+                start: Number(unwrapped[0]),
+                end: Number(unwrapped[0])
+            };
+        }
+        // Slot range
+        return {
+            start: Number(unwrapped[0]),
+            end: Number(unwrapped[1])
+        };
+    });
+}
+/**
+ * Transform the raw reply into a structured object
+ */
+function transformHotkeysGetReply(reply) {
+    const result = {};
+    // The reply is wrapped in an extra array, so we need to access reply[0]
+    const data = reply[0];
+    for (let i = 0; i < data.length; i += 2) {
+        const key = data[i].toString();
+        const value = data[i + 1];
+        switch (key) {
+            case 'tracking-active':
+                result.trackingActive = Number(value);
+                break;
+            case 'sample-ratio':
+                result.sampleRatio = Number(value);
+                break;
+            case 'selected-slots':
+                result.selectedSlots = parseSlotRanges(value);
+                break;
+            case 'sampled-commands-selected-slots-us':
+                result.sampledCommandsSelectedSlotsUs = Number(value);
+                break;
+            case 'all-commands-selected-slots-us':
+                result.allCommandsSelectedSlotsUs = Number(value);
+                break;
+            case 'all-commands-all-slots-us':
+                result.allCommandsAllSlotsUs = Number(value);
+                break;
+            case 'net-bytes-sampled-commands-selected-slots':
+                result.netBytesSampledCommandsSelectedSlots = Number(value);
+                break;
+            case 'net-bytes-all-commands-selected-slots':
+                result.netBytesAllCommandsSelectedSlots = Number(value);
+                break;
+            case 'net-bytes-all-commands-all-slots':
+                result.netBytesAllCommandsAllSlots = Number(value);
+                break;
+            case 'collection-start-time-unix-ms':
+                result.collectionStartTimeUnixMs = Number(value);
+                break;
+            case 'collection-duration-ms':
+                result.collectionDurationMs = Number(value);
+                break;
+            case 'total-cpu-time-sys-ms':
+                result.totalCpuTimeSysMs = Number(value);
+                break;
+            case 'total-cpu-time-user-ms':
+                result.totalCpuTimeUserMs = Number(value);
+                break;
+            case 'total-net-bytes':
+                result.totalNetBytes = Number(value);
+                break;
+            case 'by-cpu-time-us':
+                result.byCpuTimeUs = parseHotkeysList(value);
+                break;
+            case 'by-net-bytes':
+                result.byNetBytes = parseHotkeysList(value);
+                break;
+        }
+    }
+    return result;
+}
+/**
+ * HOTKEYS GET command - returns hotkeys tracking data
+ *
+ * State transitions:
+ * - ACTIVE -> returns data (does not stop)
+ * - STOPPED -> returns data
+ * - EMPTY -> returns null
+ */
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Returns the top K hotkeys by CPU time and network bytes.
+     * Returns null if no tracking has been started or tracking was reset.
+     * @param parser - The Redis command parser
+     * @see https://redis.io/commands/hotkeys-get/
+     */
+    parseCommand(parser) {
+        parser.push('HOTKEYS', 'GET');
+    },
+    transformReply: {
+        2: (reply) => {
+            if (reply === null)
+                return null;
+            return transformHotkeysGetReply(reply);
+        },
+        3: undefined
+    },
+    unstableResp3: true
+};
+//# sourceMappingURL=HOTKEYS_GET.js.map

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * HOTKEYS RESET command - releases resources used for hotkey tracking
+ *
+ * State transitions:
+ * - STOPPED -> EMPTY
+ * - EMPTY -> EMPTY
+ * - ACTIVE -> ERROR (must stop first)
+ */
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: false,
+    /**
+     * Releases resources used for hotkey tracking.
+     * Returns error if a session is active (must be stopped first).
+     * @param parser - The Redis command parser
+     * @see https://redis.io/commands/hotkeys-reset/
+     */
+    parseCommand(parser) {
+        parser.push('HOTKEYS', 'RESET');
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=HOTKEYS_RESET.js.map

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

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HOTKEYS_METRICS = void 0;
+/**
+ * Metrics to track for hotkeys
+ */
+exports.HOTKEYS_METRICS = {
+    CPU: 'CPU',
+    NET: 'NET'
+};
+/**
+ * HOTKEYS START command - starts hotkeys tracking
+ *
+ * State transitions:
+ * - EMPTY -> ACTIVE
+ * - STOPPED -> ACTIVE (fresh)
+ * - ACTIVE -> ERROR
+ */
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: false,
+    /**
+     * Starts hotkeys tracking with specified options.
+     * @param parser - The Redis command parser
+     * @param options - Configuration options for hotkeys tracking
+     * @see https://redis.io/commands/hotkeys-start/
+     */
+    parseCommand(parser, options) {
+        parser.push('HOTKEYS', 'START');
+        // METRICS is required with count and at least one metric type
+        parser.push('METRICS', options.METRICS.count.toString());
+        if (options.METRICS.CPU) {
+            parser.push('CPU');
+        }
+        if (options.METRICS.NET) {
+            parser.push('NET');
+        }
+        // COUNT option
+        if (options.COUNT !== undefined) {
+            parser.push('COUNT', options.COUNT.toString());
+        }
+        // DURATION option
+        if (options.DURATION !== undefined) {
+            parser.push('DURATION', options.DURATION.toString());
+        }
+        // SAMPLE option
+        if (options.SAMPLE !== undefined) {
+            parser.push('SAMPLE', options.SAMPLE.toString());
+        }
+        // SLOTS option
+        if (options.SLOTS !== undefined) {
+            parser.push('SLOTS', options.SLOTS.count.toString());
+            for (const slot of options.SLOTS.slots) {
+                parser.push(slot.toString());
+            }
+        }
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=HOTKEYS_START.js.map

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * HOTKEYS STOP command - stops hotkeys tracking but keeps results available for GET
+ *
+ * State transitions:
+ * - ACTIVE -> STOPPED (returns OK)
+ * - STOPPED -> STOPPED (no-op)
+ * - EMPTY -> EMPTY (returns null - no session was started)
+ *
+ * Note: Returns null if no session was started or is already stopped.
+ */
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: false,
+    /**
+     * Stops hotkeys tracking. Results remain available via HOTKEYS GET.
+     * Returns null if no session was started or is already stopped.
+     * @param parser - The Redis command parser
+     * @see https://redis.io/commands/hotkeys-stop/
+     */
+    parseCommand(parser) {
+        parser.push('HOTKEYS', 'STOP');
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=HOTKEYS_STOP.js.map

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    /**
+     * Removes the expiration from the specified fields in a hash.
+     * @param parser - The Redis command parser.
+     * @param key - Key of the hash.
+     * @param fields - Fields to remove expiration from.
+     */
+    parseCommand(parser, key, fields) {
+        parser.push('HPERSIST');
+        parser.pushKey(key);
+        parser.push('FIELDS');
+        parser.pushVariadicWithLength(fields);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=HPERSIST.js.map

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    /**
+     * Parses the arguments for the `HPEXPIRE` command.
+     *
+     * @param parser - The command parser instance.
+     * @param key - The key of the hash.
+     * @param fields - The fields to set the expiration for.
+     * @param ms - The expiration time in milliseconds.
+     * @param mode - Optional mode for the command ('NX', 'XX', 'GT', 'LT').
+     */
+    parseCommand(parser, key, fields, ms, mode) {
+        parser.push('HPEXPIRE');
+        parser.pushKey(key);
+        parser.push(ms.toString());
+        if (mode) {
+            parser.push(mode);
+        }
+        parser.push('FIELDS');
+        parser.pushVariadicWithLength(fields);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=HPEXPIRE.js.map

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const generic_transformers_1 = require("./generic-transformers");
+exports.default = {
+    IS_READ_ONLY: true,
+    /**
+     * Parses the arguments for the `HPEXPIREAT` command.
+     *
+     * @param parser - The command parser instance.
+     * @param key - The key of the hash.
+     * @param fields - The fields to set the expiration for.
+     * @param timestamp - The expiration timestamp (Unix timestamp or Date object).
+     * @param mode - Optional mode for the command ('NX', 'XX', 'GT', 'LT').
+     */
+    parseCommand(parser, key, fields, timestamp, mode) {
+        parser.push('HPEXPIREAT');
+        parser.pushKey(key);
+        parser.push((0, generic_transformers_1.transformPXAT)(timestamp));
+        if (mode) {
+            parser.push(mode);
+        }
+        parser.push('FIELDS');
+        parser.pushVariadicWithLength(fields);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=HPEXPIREAT.js.map

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    IS_READ_ONLY: true,
+    /**
+     * Constructs the HPEXPIRETIME command
+     *
+     * @param parser - The command parser
+     * @param key - The key to retrieve expiration time for
+     * @param fields - The fields to retrieve expiration time for
+     * @see https://redis.io/commands/hpexpiretime/
+     */
+    parseCommand(parser, key, fields) {
+        parser.push('HPEXPIRETIME');
+        parser.pushKey(key);
+        parser.push('FIELDS');
+        parser.pushVariadicWithLength(fields);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=HPEXPIRETIME.js.map

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    IS_READ_ONLY: true,
+    /**
+     * Constructs the HPTTL command
+     *
+     * @param parser - The command parser
+     * @param key - The key to check time-to-live for
+     * @param fields - The fields to check time-to-live for
+     * @see https://redis.io/commands/hpttl/
+     */
+    parseCommand(parser, key, fields) {
+        parser.push('HPTTL');
+        parser.pushKey(key);
+        parser.push('FIELDS');
+        parser.pushVariadicWithLength(fields);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=HPTTL.js.map

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    IS_READ_ONLY: true,
+    /**
+     * Constructs the HRANDFIELD command
+     *
+     * @param parser - The command parser
+     * @param key - The key of the hash to get a random field from
+     * @see https://redis.io/commands/hrandfield/
+     */
+    parseCommand(parser, key) {
+        parser.push('HRANDFIELD');
+        parser.pushKey(key);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=HRANDFIELD.js.map

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    IS_READ_ONLY: true,
+    /**
+     * Constructs the HRANDFIELD command with count parameter
+     *
+     * @param parser - The command parser
+     * @param key - The key of the hash to get random fields from
+     * @param count - The number of fields to return (positive: unique fields, negative: may repeat fields)
+     * @see https://redis.io/commands/hrandfield/
+     */
+    parseCommand(parser, key, count) {
+        parser.push('HRANDFIELD');
+        parser.pushKey(key);
+        parser.push(count.toString());
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=HRANDFIELD_COUNT.js.map

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    IS_READ_ONLY: true,
+    /**
+     * Constructs the HRANDFIELD command with count parameter and WITHVALUES option
+     *
+     * @param parser - The command parser
+     * @param key - The key of the hash to get random fields from
+     * @param count - The number of fields to return (positive: unique fields, negative: may repeat fields)
+     * @see https://redis.io/commands/hrandfield/
+     */
+    parseCommand(parser, key, count) {
+        parser.push('HRANDFIELD');
+        parser.pushKey(key);
+        parser.push(count.toString(), 'WITHVALUES');
+    },
+    transformReply: {
+        2: (rawReply) => {
+            const reply = [];
+            let i = 0;
+            while (i < rawReply.length) {
+                reply.push({
+                    field: rawReply[i++],
+                    value: rawReply[i++]
+                });
+            }
+            return reply;
+        },
+        3: (reply) => {
+            return reply.map(entry => {
+                const [field, value] = entry;
+                return {
+                    field,
+                    value
+                };
+            });
+        }
+    }
+};
+//# sourceMappingURL=HRANDFIELD_COUNT_WITHVALUES.js.map

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const SCAN_1 = require("./SCAN");
+exports.default = {
+    IS_READ_ONLY: true,
+    /**
+     * Constructs the HSCAN command
+     *
+     * @param parser - The command parser
+     * @param key - The key of the hash to scan
+     * @param cursor - The cursor position to start scanning from
+     * @param options - Options for the scan (COUNT, MATCH, TYPE)
+     * @see https://redis.io/commands/hscan/
+     */
+    parseCommand(parser, key, cursor, options) {
+        parser.push('HSCAN');
+        parser.pushKey(key);
+        (0, SCAN_1.parseScanArguments)(parser, cursor, options);
+    },
+    transformReply([cursor, rawEntries]) {
+        const entries = [];
+        let i = 0;
+        while (i < rawEntries.length) {
+            entries.push({
+                field: rawEntries[i++],
+                value: rawEntries[i++]
+            });
+        }
+        return {
+            cursor,
+            entries
+        };
+    }
+};
+//# sourceMappingURL=HSCAN.js.map

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

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const HSCAN_1 = __importDefault(require("./HSCAN"));
+exports.default = {
+    IS_READ_ONLY: true,
+    /**
+     * Constructs the HSCAN command with NOVALUES option
+     *
+     * @param args - The same parameters as HSCAN command
+     * @see https://redis.io/commands/hscan/
+     */
+    parseCommand(...args) {
+        const parser = args[0];
+        HSCAN_1.default.parseCommand(...args);
+        parser.push('NOVALUES');
+    },
+    transformReply([cursor, fields]) {
+        return {
+            cursor,
+            fields
+        };
+    }
+};
+//# sourceMappingURL=HSCAN_NOVALUES.js.map

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    /**
+     * Constructs the HSET command
+     *
+     * @param parser - The command parser
+     * @param key - The key of the hash
+     * @param value - Either the field name (when using single field) or an object/map/array of field-value pairs
+     * @param fieldValue - The value to set (only used with single field variant)
+     * @see https://redis.io/commands/hset/
+     */
+    parseCommand(parser, ...[key, value, fieldValue]) {
+        parser.push('HSET');
+        parser.pushKey(key);
+        if (typeof value === 'string' || typeof value === 'number' || value instanceof Buffer) {
+            parser.push(convertValue(value), convertValue(fieldValue));
+        }
+        else if (value instanceof Map) {
+            pushMap(parser, value);
+        }
+        else if (Array.isArray(value)) {
+            pushTuples(parser, value);
+        }
+        else {
+            pushObject(parser, value);
+        }
+    },
+    transformReply: undefined
+};
+function pushMap(parser, map) {
+    for (const [key, value] of map.entries()) {
+        parser.push(convertValue(key), convertValue(value));
+    }
+}
+function pushTuples(parser, tuples) {
+    for (const tuple of tuples) {
+        if (Array.isArray(tuple)) {
+            pushTuples(parser, tuple);
+            continue;
+        }
+        parser.push(convertValue(tuple));
+    }
+}
+function pushObject(parser, object) {
+    for (const key of Object.keys(object)) {
+        parser.push(convertValue(key), convertValue(object[key]));
+    }
+}
+function convertValue(value) {
+    return typeof value === 'number' ?
+        value.toString() :
+        value;
+}
+//# sourceMappingURL=HSET.js.map

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

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const parser_1 = require("../client/parser");
+exports.default = {
+    /**
+     * Constructs the HSETEX command
+     *
+     * @param parser - The command parser
+     * @param key - The key of the hash
+     * @param fields - Object, Map, or Array of field-value pairs to set
+     * @param options - Optional configuration for expiration and mode settings
+     * @see https://redis.io/commands/hsetex/
+     */
+    parseCommand(parser, key, fields, options) {
+        parser.push('HSETEX');
+        parser.pushKey(key);
+        if (options?.mode) {
+            parser.push(options.mode);
+        }
+        if (options?.expiration) {
+            if (typeof options.expiration === 'string') {
+                parser.push(options.expiration);
+            }
+            else if (options.expiration.type === 'KEEPTTL') {
+                parser.push('KEEPTTL');
+            }
+            else {
+                parser.push(options.expiration.type, options.expiration.value.toString());
+            }
+        }
+        parser.push('FIELDS');
+        if (fields instanceof Map) {
+            pushMap(parser, fields);
+        }
+        else if (Array.isArray(fields)) {
+            pushTuples(parser, fields);
+        }
+        else {
+            pushObject(parser, fields);
+        }
+    },
+    transformReply: undefined
+};
+function pushMap(parser, map) {
+    parser.push(map.size.toString());
+    for (const [key, value] of map.entries()) {
+        parser.push(convertValue(key), convertValue(value));
+    }
+}
+function pushTuples(parser, tuples) {
+    const tmpParser = new parser_1.BasicCommandParser;
+    _pushTuples(tmpParser, tuples);
+    if (tmpParser.redisArgs.length % 2 != 0) {
+        throw Error('invalid number of arguments, expected key value ....[key value] pairs, got key without value');
+    }
+    parser.push((tmpParser.redisArgs.length / 2).toString());
+    parser.push(...tmpParser.redisArgs);
+}
+function _pushTuples(parser, tuples) {
+    for (const tuple of tuples) {
+        if (Array.isArray(tuple)) {
+            _pushTuples(parser, tuple);
+            continue;
+        }
+        parser.push(convertValue(tuple));
+    }
+}
+function pushObject(parser, object) {
+    const len = Object.keys(object).length;
+    if (len == 0) {
+        throw Error('object without keys');
+    }
+    parser.push(len.toString());
+    for (const key of Object.keys(object)) {
+        parser.push(convertValue(key), convertValue(object[key]));
+    }
+}
+function convertValue(value) {
+    return typeof value === 'number' ? value.toString() : value;
+}
+//# sourceMappingURL=HSETEX.js.map

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    IS_READ_ONLY: true,
+    /**
+     * Constructs the HSETNX command
+     *
+     * @param parser - The command parser
+     * @param key - The key of the hash
+     * @param field - The field to set if it does not exist
+     * @param value - The value to set
+     * @see https://redis.io/commands/hsetnx/
+     */
+    parseCommand(parser, key, field, value) {
+        parser.push('HSETNX');
+        parser.pushKey(key);
+        parser.push(field, value);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=HSETNX.js.map