orcaq 1.1.1 → 1.1.3

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

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GEO_REPLY_WITH = void 0;
+const GEOSEARCH_1 = __importDefault(require("./GEOSEARCH"));
+exports.GEO_REPLY_WITH = {
+    DISTANCE: 'WITHDIST',
+    HASH: 'WITHHASH',
+    COORDINATES: 'WITHCOORD'
+};
+exports.default = {
+    IS_READ_ONLY: GEOSEARCH_1.default.IS_READ_ONLY,
+    /**
+     * Queries members inside an area of a geospatial index with additional information
+     * @param parser - The Redis command parser
+     * @param key - Key of the geospatial index
+     * @param from - Center point of the search (member name or coordinates)
+     * @param by - Search area specification (radius or box dimensions)
+     * @param replyWith - Information to include with each returned member
+     * @param options - Additional search options
+     */
+    parseCommand(parser, key, from, by, replyWith, options) {
+        GEOSEARCH_1.default.parseCommand(parser, key, from, by, options);
+        parser.push(...replyWith);
+        parser.preserve = replyWith;
+    },
+    transformReply(reply, replyWith) {
+        const replyWithSet = new Set(replyWith);
+        let index = 0;
+        const distanceIndex = replyWithSet.has(exports.GEO_REPLY_WITH.DISTANCE) && ++index, hashIndex = replyWithSet.has(exports.GEO_REPLY_WITH.HASH) && ++index, coordinatesIndex = replyWithSet.has(exports.GEO_REPLY_WITH.COORDINATES) && ++index;
+        return reply.map(raw => {
+            const unwrapped = raw;
+            const item = {
+                member: unwrapped[0]
+            };
+            if (distanceIndex) {
+                item.distance = unwrapped[distanceIndex];
+            }
+            if (hashIndex) {
+                item.hash = unwrapped[hashIndex];
+            }
+            if (coordinatesIndex) {
+                const [longitude, latitude] = unwrapped[coordinatesIndex];
+                item.coordinates = {
+                    longitude,
+                    latitude
+                };
+            }
+            return item;
+        });
+    }
+};
+//# sourceMappingURL=GEOSEARCH_WITH.js.map

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    CACHEABLE: true,
+    IS_READ_ONLY: true,
+    /**
+     * Gets the value of a key
+     * @param parser - The Redis command parser
+     * @param key - Key to get the value of
+     */
+    parseCommand(parser, key) {
+        parser.push('GET');
+        parser.pushKey(key);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=GET.js.map

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    CACHEABLE: true,
+    IS_READ_ONLY: true,
+    /**
+     * Returns the bit value at a given offset in a string value
+     * @param parser - The Redis command parser
+     * @param key - Key to retrieve the bit from
+     * @param offset - Bit offset
+     */
+    parseCommand(parser, key, offset) {
+        parser.push('GETBIT');
+        parser.pushKey(key);
+        parser.push(offset.toString());
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=GETBIT.js.map

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    IS_READ_ONLY: true,
+    /**
+     * Gets the value of a key and deletes the key
+     * @param parser - The Redis command parser
+     * @param key - Key to get and delete
+     */
+    parseCommand(parser, key) {
+        parser.push('GETDEL');
+        parser.pushKey(key);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=GETDEL.js.map

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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const generic_transformers_1 = require("./generic-transformers");
+exports.default = {
+    IS_READ_ONLY: true,
+    /**
+     * Gets the value of a key and optionally sets its expiration
+     * @param parser - The Redis command parser
+     * @param key - Key to get value from
+     * @param options - Options for setting expiration
+     */
+    parseCommand(parser, key, options) {
+        parser.push('GETEX');
+        parser.pushKey(key);
+        if ('type' in options) {
+            switch (options.type) {
+                case 'EX':
+                case 'PX':
+                    parser.push(options.type, options.value.toString());
+                    break;
+                case 'EXAT':
+                case 'PXAT':
+                    parser.push(options.type, (0, generic_transformers_1.transformEXAT)(options.value));
+                    break;
+                case 'PERSIST':
+                    parser.push('PERSIST');
+                    break;
+            }
+        }
+        else {
+            if ('EX' in options) {
+                parser.push('EX', options.EX.toString());
+            }
+            else if ('PX' in options) {
+                parser.push('PX', options.PX.toString());
+            }
+            else if ('EXAT' in options) {
+                parser.push('EXAT', (0, generic_transformers_1.transformEXAT)(options.EXAT));
+            }
+            else if ('PXAT' in options) {
+                parser.push('PXAT', (0, generic_transformers_1.transformPXAT)(options.PXAT));
+            }
+            else { // PERSIST
+                parser.push('PERSIST');
+            }
+        }
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=GETEX.js.map

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    CACHEABLE: true,
+    IS_READ_ONLY: true,
+    /**
+     * Returns a substring of the string stored at a key
+     * @param parser - The Redis command parser
+     * @param key - Key to get substring from
+     * @param start - Start position of the substring
+     * @param end - End position of the substring
+     */
+    parseCommand(parser, key, start, end) {
+        parser.push('GETRANGE');
+        parser.pushKey(key);
+        parser.push(start.toString(), end.toString());
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=GETRANGE.js.map

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    IS_READ_ONLY: true,
+    /**
+     * Sets a key to a new value and returns its old value
+     * @param parser - The Redis command parser
+     * @param key - Key to set
+     * @param value - Value to set
+     */
+    parseCommand(parser, key, value) {
+        parser.push('GETSET');
+        parser.pushKey(key);
+        parser.push(value);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=GETSET.js.map

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    /**
+     * Removes one or more fields from a hash
+     * @param parser - The Redis command parser
+     * @param key - Key of the hash
+     * @param field - Field(s) to remove
+     */
+    parseCommand(parser, key, field) {
+        parser.push('HDEL');
+        parser.pushKey(key);
+        parser.pushVariadic(field);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=HDEL.js.map

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    /**
+     * Handshakes with the Redis server and switches to the specified protocol version
+     * @param parser - The Redis command parser
+     * @param protover - Protocol version to use
+     * @param options - Additional options for authentication and connection naming
+     */
+    parseCommand(parser, protover, options) {
+        parser.push('HELLO');
+        if (protover) {
+            parser.push(protover.toString());
+            if (options?.AUTH) {
+                parser.push('AUTH', options.AUTH.username, options.AUTH.password);
+            }
+            if (options?.SETNAME) {
+                parser.push('SETNAME', options.SETNAME);
+            }
+        }
+    },
+    transformReply: {
+        2: (reply) => ({
+            server: reply[1],
+            version: reply[3],
+            proto: reply[5],
+            id: reply[7],
+            mode: reply[9],
+            role: reply[11],
+            modules: reply[13]
+        }),
+        3: undefined
+    }
+};
+//# sourceMappingURL=HELLO.js.map

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    CACHEABLE: true,
+    IS_READ_ONLY: true,
+    /**
+     * Determines whether a field exists in a hash
+     * @param parser - The Redis command parser
+     * @param key - Key of the hash
+     * @param field - Field to check
+     */
+    parseCommand(parser, key, field) {
+        parser.push('HEXISTS');
+        parser.pushKey(key);
+        parser.push(field);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=HEXISTS.js.map

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HASH_EXPIRATION = void 0;
+exports.HASH_EXPIRATION = {
+    /** The field does not exist */
+    FIELD_NOT_EXISTS: -2,
+    /** Specified NX | XX | GT | LT condition not met */
+    CONDITION_NOT_MET: 0,
+    /** Expiration time was set or updated */
+    UPDATED: 1,
+    /** Field deleted because the specified expiration time is in the past */
+    DELETED: 2
+};
+exports.default = {
+    /**
+     * Sets a timeout on hash fields. After the timeout has expired, the fields will be automatically deleted
+     * @param parser - The Redis command parser
+     * @param key - Key of the hash
+     * @param fields - Fields to set expiration on
+     * @param seconds - Number of seconds until field expiration
+     * @param mode - Expiration mode: NX (only if field has no expiry), XX (only if field has existing expiry), GT (only if new expiry is greater than current), LT (only if new expiry is less than current)
+     */
+    parseCommand(parser, key, fields, seconds, mode) {
+        parser.push('HEXPIRE');
+        parser.pushKey(key);
+        parser.push(seconds.toString());
+        if (mode) {
+            parser.push(mode);
+        }
+        parser.push('FIELDS');
+        parser.pushVariadicWithLength(fields);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=HEXPIRE.js.map

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const generic_transformers_1 = require("./generic-transformers");
+exports.default = {
+    /**
+     * Sets the expiration for hash fields at a specific Unix timestamp
+     * @param parser - The Redis command parser
+     * @param key - Key of the hash
+     * @param fields - Fields to set expiration on
+     * @param timestamp - Unix timestamp (seconds since January 1, 1970) or Date object
+     * @param mode - Expiration mode: NX (only if field has no expiry), XX (only if field has existing expiry), GT (only if new expiry is greater than current), LT (only if new expiry is less than current)
+     */
+    parseCommand(parser, key, fields, timestamp, mode) {
+        parser.push('HEXPIREAT');
+        parser.pushKey(key);
+        parser.push((0, generic_transformers_1.transformEXAT)(timestamp));
+        if (mode) {
+            parser.push(mode);
+        }
+        parser.push('FIELDS');
+        parser.pushVariadicWithLength(fields);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=HEXPIREAT.js.map

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HASH_EXPIRATION_TIME = void 0;
+exports.HASH_EXPIRATION_TIME = {
+    /** The field does not exist */
+    FIELD_NOT_EXISTS: -2,
+    /** The field exists but has no associated expire */
+    NO_EXPIRATION: -1,
+};
+exports.default = {
+    IS_READ_ONLY: true,
+    /**
+     * Returns the absolute Unix timestamp (since January 1, 1970) at which the given hash fields will expire
+     * @param parser - The Redis command parser
+     * @param key - Key of the hash
+     * @param fields - Fields to check expiration time
+     */
+    parseCommand(parser, key, fields) {
+        parser.push('HEXPIRETIME');
+        parser.pushKey(key);
+        parser.push('FIELDS');
+        parser.pushVariadicWithLength(fields);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=HEXPIRETIME.js.map

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    CACHEABLE: true,
+    IS_READ_ONLY: true,
+    /**
+     * Gets the value of a field in a hash
+     * @param parser - The Redis command parser
+     * @param key - Key of the hash
+     * @param field - Field to get the value of
+     */
+    parseCommand(parser, key, field) {
+        parser.push('HGET');
+        parser.pushKey(key);
+        parser.push(field);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=HGET.js.map

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const generic_transformers_1 = require("./generic-transformers");
+exports.default = {
+    CACHEABLE: true,
+    IS_READ_ONLY: true,
+    /**
+     * Gets all fields and values in a hash
+     * @param parser - The Redis command parser
+     * @param key - Key of the hash
+     */
+    parseCommand(parser, key) {
+        parser.push('HGETALL');
+        parser.pushKey(key);
+    },
+    TRANSFORM_LEGACY_REPLY: true,
+    transformReply: {
+        2: (generic_transformers_1.transformTuplesReply),
+        3: undefined
+    }
+};
+//# sourceMappingURL=HGETALL.js.map

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

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

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    /**
+     * Gets the values of the specified fields in a hash and optionally sets their expiration
+     * @param parser - The Redis command parser
+     * @param key - Key of the hash
+     * @param fields - Fields to get values from
+     * @param options - Options for setting expiration
+     */
+    parseCommand(parser, key, fields, options) {
+        parser.push('HGETEX');
+        parser.pushKey(key);
+        if (options?.expiration) {
+            if (typeof options.expiration === 'string') {
+                parser.push(options.expiration);
+            }
+            else if (options.expiration.type === 'PERSIST') {
+                parser.push('PERSIST');
+            }
+            else {
+                parser.push(options.expiration.type, options.expiration.value.toString());
+            }
+        }
+        parser.push('FIELDS');
+        parser.pushVariadicWithLength(fields);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=HGETEX.js.map

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    /**
+     * Increments the integer value of a field in a hash by the given number
+     * @param parser - The Redis command parser
+     * @param key - Key of the hash
+     * @param field - Field to increment
+     * @param increment - Increment amount
+     */
+    parseCommand(parser, key, field, increment) {
+        parser.push('HINCRBY');
+        parser.pushKey(key);
+        parser.push(field, increment.toString());
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=HINCRBY.js.map

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    /**
+     * Increments the float value of a field in a hash by the given amount
+     * @param parser - The Redis command parser
+     * @param key - Key of the hash
+     * @param field - Field to increment
+     * @param increment - Increment amount (float)
+     */
+    parseCommand(parser, key, field, increment) {
+        parser.push('HINCRBYFLOAT');
+        parser.pushKey(key);
+        parser.push(field, increment.toString());
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=HINCRBYFLOAT.js.map

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    CACHEABLE: true,
+    IS_READ_ONLY: true,
+    /**
+     * Gets all field names in a hash
+     * @param parser - The Redis command parser
+     * @param key - Key of the hash
+     */
+    parseCommand(parser, key) {
+        parser.push('HKEYS');
+        parser.pushKey(key);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=HKEYS.js.map

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    CACHEABLE: true,
+    IS_READ_ONLY: true,
+    /**
+     * Gets the number of fields in a hash.
+     * @param parser - The Redis command parser.
+     * @param key - Key of the hash.
+     */
+    parseCommand(parser, key) {
+        parser.push('HLEN');
+        parser.pushKey(key);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=HLEN.js.map

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    CACHEABLE: true,
+    IS_READ_ONLY: true,
+    /**
+     * Gets the values of all the specified fields in a hash.
+     * @param parser - The Redis command parser.
+     * @param key - Key of the hash.
+     * @param fields - Fields to get from the hash.
+     */
+    parseCommand(parser, key, fields) {
+        parser.push('HMGET');
+        parser.pushKey(key);
+        parser.pushVariadic(fields);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=HMGET.js.map