@devvit/redis 0.11.16-next-2025-05-21-9df7afc74.0

package/RedisClient.js

@@ -0,0 +1,615 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _TxClient_instances, _TxClient_storage, _TxClient_transactionId, _TxClient_txnStartMetadata, _TxClient_metadata_get, _RedisClient_instances, _RedisClient_storage, _RedisClient_metadata_get;
+import { BitfieldOverflowBehavior, RedisKeyScope } from '@devvit/protos';
+import { getContext } from '@devvit/server';
+// Re-export this here, to prevent devs from needing to directly import from the protos package.
+export { RedisKeyScope } from '@devvit/protos';
+// TODO: This code is currently cloned into the Devvit Web world from `@devvit/public-api`. If
+//  you change this code, please make sure to update the other package as well. Eventually, that
+//  copy of the code will be deleted, when we move to a fully Devvit Web world.
+export class TxClient {
+    constructor(storage, transactionId, metadata) {
+        _TxClient_instances.add(this);
+        _TxClient_storage.set(this, void 0);
+        _TxClient_transactionId.set(this, void 0);
+        _TxClient_txnStartMetadata.set(this, void 0);
+        __classPrivateFieldSet(this, _TxClient_storage, storage, "f");
+        __classPrivateFieldSet(this, _TxClient_transactionId, transactionId, "f");
+        __classPrivateFieldSet(this, _TxClient_txnStartMetadata, metadata, "f");
+    }
+    async get(key) {
+        await __classPrivateFieldGet(this, _TxClient_storage, "f").Get({ key: key, transactionId: __classPrivateFieldGet(this, _TxClient_transactionId, "f") }, __classPrivateFieldGet(this, _TxClient_instances, "a", _TxClient_metadata_get));
+        return this;
+    }
+    async multi() {
+        await __classPrivateFieldGet(this, _TxClient_storage, "f").Multi(__classPrivateFieldGet(this, _TxClient_transactionId, "f"), __classPrivateFieldGet(this, _TxClient_instances, "a", _TxClient_metadata_get));
+    }
+    async set(key, value, options) {
+        let expiration;
+        if (options?.expiration) {
+            expiration = Math.floor((options.expiration.getTime() - Date.now()) / 1000); // convert to seconds
+            if (expiration < 1) {
+                expiration = 1; // minimum expiration is 1 second, clock skew can cause issues, so let's set 1 second.
+            }
+        }
+        await __classPrivateFieldGet(this, _TxClient_storage, "f").Set({
+            key,
+            value,
+            nx: options?.nx === true,
+            xx: options?.xx === true,
+            expiration: expiration || 0,
+            transactionId: __classPrivateFieldGet(this, _TxClient_transactionId, "f"),
+        }, __classPrivateFieldGet(this, _TxClient_instances, "a", _TxClient_metadata_get));
+        return this;
+    }
+    async del(...keys) {
+        await __classPrivateFieldGet(this, _TxClient_storage, "f").Del({ keys: keys, transactionId: __classPrivateFieldGet(this, _TxClient_transactionId, "f") }, __classPrivateFieldGet(this, _TxClient_instances, "a", _TxClient_metadata_get));
+        return this;
+    }
+    async type(key) {
+        await __classPrivateFieldGet(this, _TxClient_storage, "f").Type({ key: key, transactionId: __classPrivateFieldGet(this, _TxClient_transactionId, "f") }, __classPrivateFieldGet(this, _TxClient_instances, "a", _TxClient_metadata_get));
+        return this;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async exec() {
+        const response = await __classPrivateFieldGet(this, _TxClient_storage, "f").Exec(__classPrivateFieldGet(this, _TxClient_transactionId, "f"), __classPrivateFieldGet(this, _TxClient_instances, "a", _TxClient_metadata_get));
+        // eslint-disable-next-line
+        let output = [];
+        for (const result of response.response) {
+            if (result.members) {
+                output.push(result.members);
+            }
+            else if (result.nil !== undefined) {
+                output.push(null);
+            }
+            else if (result.num !== undefined) {
+                output.push(result.num);
+            }
+            else if (result.values !== undefined) {
+                output.push(result.values.values);
+            }
+            else if (result.str !== undefined) {
+                output.push(result.str);
+            }
+            else if (result.dbl !== undefined) {
+                output.push(result.dbl);
+            }
+        }
+        return output;
+    }
+    async discard() {
+        await __classPrivateFieldGet(this, _TxClient_storage, "f").Discard(__classPrivateFieldGet(this, _TxClient_transactionId, "f"), __classPrivateFieldGet(this, _TxClient_instances, "a", _TxClient_metadata_get));
+    }
+    async watch(...keys) {
+        await __classPrivateFieldGet(this, _TxClient_storage, "f").Watch({ keys: keys, transactionId: __classPrivateFieldGet(this, _TxClient_transactionId, "f") }, __classPrivateFieldGet(this, _TxClient_instances, "a", _TxClient_metadata_get));
+        return this;
+    }
+    async unwatch() {
+        await __classPrivateFieldGet(this, _TxClient_storage, "f").Unwatch(__classPrivateFieldGet(this, _TxClient_transactionId, "f"), __classPrivateFieldGet(this, _TxClient_instances, "a", _TxClient_metadata_get));
+        return this;
+    }
+    async getrange(key, start, end) {
+        await __classPrivateFieldGet(this, _TxClient_storage, "f").GetRange({ key, start, end, transactionId: __classPrivateFieldGet(this, _TxClient_transactionId, "f") }, __classPrivateFieldGet(this, _TxClient_instances, "a", _TxClient_metadata_get));
+        return this;
+    }
+    async setrange(key, offset, value) {
+        await __classPrivateFieldGet(this, _TxClient_storage, "f").SetRange({ key, offset, value, transactionId: __classPrivateFieldGet(this, _TxClient_transactionId, "f") }, __classPrivateFieldGet(this, _TxClient_instances, "a", _TxClient_metadata_get));
+        return this;
+    }
+    async strlen(key) {
+        await __classPrivateFieldGet(this, _TxClient_storage, "f").Strlen({ key, transactionId: __classPrivateFieldGet(this, _TxClient_transactionId, "f") }, __classPrivateFieldGet(this, _TxClient_instances, "a", _TxClient_metadata_get));
+        return this;
+    }
+    async mget(keys) {
+        await __classPrivateFieldGet(this, _TxClient_storage, "f").MGet({ keys, transactionId: __classPrivateFieldGet(this, _TxClient_transactionId, "f") }, __classPrivateFieldGet(this, _TxClient_instances, "a", _TxClient_metadata_get));
+        return this;
+    }
+    async mset(keyValues) {
+        const kv = Object.entries(keyValues).map(([key, value]) => ({ key, value }));
+        await __classPrivateFieldGet(this, _TxClient_storage, "f").MSet({ kv, transactionId: __classPrivateFieldGet(this, _TxClient_transactionId, "f") }, __classPrivateFieldGet(this, _TxClient_instances, "a", _TxClient_metadata_get));
+        return this;
+    }
+    async incrby(key, value) {
+        await __classPrivateFieldGet(this, _TxClient_storage, "f").IncrBy({ key, value, transactionId: __classPrivateFieldGet(this, _TxClient_transactionId, "f") }, __classPrivateFieldGet(this, _TxClient_instances, "a", _TxClient_metadata_get));
+        return this;
+    }
+    async expire(key, seconds) {
+        await __classPrivateFieldGet(this, _TxClient_storage, "f").Expire({ key, seconds, transactionId: __classPrivateFieldGet(this, _TxClient_transactionId, "f") }, __classPrivateFieldGet(this, _TxClient_instances, "a", _TxClient_metadata_get));
+        return this;
+    }
+    async expiretime(key) {
+        await __classPrivateFieldGet(this, _TxClient_storage, "f").ExpireTime({ key, transactionId: __classPrivateFieldGet(this, _TxClient_transactionId, "f") }, __classPrivateFieldGet(this, _TxClient_instances, "a", _TxClient_metadata_get));
+        return this;
+    }
+    async zadd(key, ...members) {
+        await __classPrivateFieldGet(this, _TxClient_storage, "f").ZAdd({ key, members, transactionId: __classPrivateFieldGet(this, _TxClient_transactionId, "f") }, __classPrivateFieldGet(this, _TxClient_instances, "a", _TxClient_metadata_get));
+        return this;
+    }
+    async zscore(key, member) {
+        await __classPrivateFieldGet(this, _TxClient_storage, "f").ZScore({ key: { key, transactionId: __classPrivateFieldGet(this, _TxClient_transactionId, "f") }, member }, __classPrivateFieldGet(this, _TxClient_instances, "a", _TxClient_metadata_get));
+        return this;
+    }
+    async zrank(key, member) {
+        await __classPrivateFieldGet(this, _TxClient_storage, "f").ZRank({ key: { key, transactionId: __classPrivateFieldGet(this, _TxClient_transactionId, "f") }, member }, __classPrivateFieldGet(this, _TxClient_instances, "a", _TxClient_metadata_get));
+        return this;
+    }
+    async zincrby(key, member, value) {
+        await __classPrivateFieldGet(this, _TxClient_storage, "f").ZIncrBy({ key, member, value, transactionId: __classPrivateFieldGet(this, _TxClient_transactionId, "f") }, __classPrivateFieldGet(this, _TxClient_instances, "a", _TxClient_metadata_get));
+        return this;
+    }
+    async zscan(key, cursor, pattern, count) {
+        const request = {
+            key,
+            cursor,
+            pattern,
+            count,
+            transactionId: __classPrivateFieldGet(this, _TxClient_transactionId, "f"),
+        };
+        await __classPrivateFieldGet(this, _TxClient_storage, "f").ZScan(request, __classPrivateFieldGet(this, _TxClient_instances, "a", _TxClient_metadata_get));
+        return this;
+    }
+    async zcard(key) {
+        await __classPrivateFieldGet(this, _TxClient_storage, "f").ZCard({ key, transactionId: __classPrivateFieldGet(this, _TxClient_transactionId, "f") }, __classPrivateFieldGet(this, _TxClient_instances, "a", _TxClient_metadata_get));
+        return this;
+    }
+    async zrange(key, start, stop, options) {
+        // eslint-disable-next-line
+        let opts = { rev: false, byLex: false, byScore: false, offset: 0, count: 1000 };
+        if (options?.reverse) {
+            opts.rev = options.reverse;
+        }
+        if (options?.by === 'lex') {
+            opts.byLex = true;
+        }
+        else if (options?.by === 'score') {
+            opts.byScore = true;
+        }
+        if (options?.limit) {
+            if (opts.byLex || opts.byScore) {
+                opts.offset = options.limit.offset;
+                opts.count = options.limit.count;
+            }
+            else {
+                throw new Error(`zRange parsing error: 'limit' only allowed when 'options.by' is 'lex' or 'score'`);
+            }
+        }
+        await __classPrivateFieldGet(this, _TxClient_storage, "f").ZRange({
+            key: { key: key, transactionId: __classPrivateFieldGet(this, _TxClient_transactionId, "f") },
+            start: start + '',
+            stop: stop + '',
+            ...opts,
+        }, __classPrivateFieldGet(this, _TxClient_instances, "a", _TxClient_metadata_get));
+        return this;
+    }
+    async zrem(key, members) {
+        await __classPrivateFieldGet(this, _TxClient_storage, "f").ZRem({ key: { key, transactionId: __classPrivateFieldGet(this, _TxClient_transactionId, "f") }, members: members }, __classPrivateFieldGet(this, _TxClient_instances, "a", _TxClient_metadata_get));
+        return this;
+    }
+    async zremrangebylex(key, min, max) {
+        await __classPrivateFieldGet(this, _TxClient_storage, "f").ZRemRangeByLex({ key: { key, transactionId: __classPrivateFieldGet(this, _TxClient_transactionId, "f") }, min: min, max: max }, __classPrivateFieldGet(this, _TxClient_instances, "a", _TxClient_metadata_get));
+        return this;
+    }
+    async zremrangebyrank(key, start, stop) {
+        await __classPrivateFieldGet(this, _TxClient_storage, "f").ZRemRangeByRank({ key: { key, transactionId: __classPrivateFieldGet(this, _TxClient_transactionId, "f") }, start: start, stop: stop }, __classPrivateFieldGet(this, _TxClient_instances, "a", _TxClient_metadata_get));
+        return this;
+    }
+    async zremrangebyscore(key, min, max) {
+        await __classPrivateFieldGet(this, _TxClient_storage, "f").ZRemRangeByScore({ key: { key, transactionId: __classPrivateFieldGet(this, _TxClient_transactionId, "f") }, min: min, max: max }, __classPrivateFieldGet(this, _TxClient_instances, "a", _TxClient_metadata_get));
+        return this;
+    }
+    async hgetall(key) {
+        await __classPrivateFieldGet(this, _TxClient_storage, "f").HGetAll({ key, transactionId: __classPrivateFieldGet(this, _TxClient_transactionId, "f") }, __classPrivateFieldGet(this, _TxClient_instances, "a", _TxClient_metadata_get));
+        return this;
+    }
+    async hget(key, field) {
+        await __classPrivateFieldGet(this, _TxClient_storage, "f").HGet({ key: key, field: field, transactionId: __classPrivateFieldGet(this, _TxClient_transactionId, "f") }, __classPrivateFieldGet(this, _TxClient_instances, "a", _TxClient_metadata_get));
+        return this;
+    }
+    async hmget(key, fields) {
+        await __classPrivateFieldGet(this, _TxClient_storage, "f").HMGet({ key: key, fields: fields, transactionId: __classPrivateFieldGet(this, _TxClient_transactionId, "f") }, __classPrivateFieldGet(this, _TxClient_instances, "a", _TxClient_metadata_get));
+        return this;
+    }
+    async hset(key, fieldValues) {
+        const fv = Object.entries(fieldValues).map(([field, value]) => ({ field, value }));
+        await __classPrivateFieldGet(this, _TxClient_storage, "f").HSet({ key, fv, transactionId: __classPrivateFieldGet(this, _TxClient_transactionId, "f") }, __classPrivateFieldGet(this, _TxClient_instances, "a", _TxClient_metadata_get));
+        return this;
+    }
+    async hincrby(key, field, value) {
+        await __classPrivateFieldGet(this, _TxClient_storage, "f").HIncrBy({ key, field, value, transactionId: __classPrivateFieldGet(this, _TxClient_transactionId, "f") }, __classPrivateFieldGet(this, _TxClient_instances, "a", _TxClient_metadata_get));
+        return this;
+    }
+    async hdel(key, fields) {
+        await __classPrivateFieldGet(this, _TxClient_storage, "f").HDel({ key, fields, transactionId: __classPrivateFieldGet(this, _TxClient_transactionId, "f") }, __classPrivateFieldGet(this, _TxClient_instances, "a", _TxClient_metadata_get));
+        return this;
+    }
+    async hscan(key, cursor, pattern, count) {
+        const request = {
+            key,
+            cursor,
+            pattern,
+            count,
+            transactionId: __classPrivateFieldGet(this, _TxClient_transactionId, "f"),
+        };
+        await __classPrivateFieldGet(this, _TxClient_storage, "f").HScan(request, __classPrivateFieldGet(this, _TxClient_instances, "a", _TxClient_metadata_get));
+        return this;
+    }
+    async hkeys(key) {
+        await __classPrivateFieldGet(this, _TxClient_storage, "f").HKeys({ key, transactionId: __classPrivateFieldGet(this, _TxClient_transactionId, "f") }, __classPrivateFieldGet(this, _TxClient_instances, "a", _TxClient_metadata_get));
+        return this;
+    }
+    async hlen(key) {
+        await __classPrivateFieldGet(this, _TxClient_storage, "f").HLen({ key, transactionId: __classPrivateFieldGet(this, _TxClient_transactionId, "f") }, __classPrivateFieldGet(this, _TxClient_instances, "a", _TxClient_metadata_get));
+        return this;
+    }
+}
+_TxClient_storage = new WeakMap(), _TxClient_transactionId = new WeakMap(), _TxClient_txnStartMetadata = new WeakMap(), _TxClient_instances = new WeakSet(), _TxClient_metadata_get = function _TxClient_metadata_get() {
+    assertTxMetadataIsCurrent(__classPrivateFieldGet(this, _TxClient_txnStartMetadata, "f"));
+    return __classPrivateFieldGet(this, _TxClient_txnStartMetadata, "f");
+};
+/**
+ * This is a subset of the overall Redis API.  You should be able to look up https://redis.io/commands
+ * for more details on each command.
+ *
+ * For the moment, we've implemented a lot of the basic string/number commands, sorted sets, and transactions.
+ * This is the most powerful subset and the safest.
+ */
+export class RedisClient {
+    constructor(storage, scope) {
+        _RedisClient_instances.add(this);
+        _RedisClient_storage.set(this, void 0);
+        __classPrivateFieldSet(this, _RedisClient_storage, storage, "f");
+        this.scope = scope;
+        this.global =
+            scope === RedisKeyScope.INSTALLATION
+                ? new RedisClient(__classPrivateFieldGet(this, _RedisClient_storage, "f"), RedisKeyScope.GLOBAL)
+                : this;
+    }
+    async watch(...keys) {
+        const txId = await __classPrivateFieldGet(this, _RedisClient_storage, "f").Watch({ keys }, __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_metadata_get));
+        return new TxClient(__classPrivateFieldGet(this, _RedisClient_storage, "f"), txId, __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_metadata_get));
+    }
+    async get(key) {
+        try {
+            const response = await __classPrivateFieldGet(this, _RedisClient_storage, "f").Get({ key, scope: this.scope }, {
+                ...__classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_metadata_get),
+                'throw-redis-nil': { values: ['true'] },
+            });
+            return response !== null ? (response.value ?? undefined) : response;
+        }
+        catch (e) {
+            if (isRedisNilError(e)) {
+                return undefined;
+            }
+            throw e;
+        }
+    }
+    async getbuffer(key) {
+        try {
+            const response = await __classPrivateFieldGet(this, _RedisClient_storage, "f").GetBytes({ key, scope: this.scope }, {
+                ...__classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_metadata_get),
+                'throw-redis-nil': { values: ['true'] },
+            });
+            return response !== null ? Buffer.from(response.value) : response;
+        }
+        catch (e) {
+            if (isRedisNilError(e)) {
+                return undefined;
+            }
+            throw e;
+        }
+    }
+    async set(key, value, options) {
+        let expiration;
+        if (options?.expiration) {
+            expiration = Math.floor((options.expiration.getTime() - Date.now()) / 1000); // convert to seconds
+            if (expiration < 1) {
+                expiration = 1; // minimum expiration is 1 second, clock skew can cause issues, so let's set 1 second.
+            }
+        }
+        const response = await __classPrivateFieldGet(this, _RedisClient_storage, "f").Set({
+            key,
+            value,
+            nx: options?.nx === true && !options.xx,
+            xx: options?.xx === true && !options.nx,
+            expiration: expiration || 0,
+            scope: this.scope,
+        }, __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_metadata_get));
+        return response.value;
+    }
+    async exists(...keys) {
+        const response = await __classPrivateFieldGet(this, _RedisClient_storage, "f").Exists({ keys, scope: this.scope }, __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_metadata_get));
+        return response.existingKeys;
+    }
+    async del(...keys) {
+        await __classPrivateFieldGet(this, _RedisClient_storage, "f").Del({ keys, scope: this.scope }, __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_metadata_get));
+    }
+    async incrby(key, value) {
+        const response = await __classPrivateFieldGet(this, _RedisClient_storage, "f").IncrBy({ key, value, scope: this.scope }, __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_metadata_get));
+        return response.value;
+    }
+    async getrange(key, start, end) {
+        const response = await __classPrivateFieldGet(this, _RedisClient_storage, "f").GetRange({ key, start, end, scope: this.scope }, __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_metadata_get));
+        return response !== null ? response.value : response;
+    }
+    async setrange(key, offset, value) {
+        const response = await __classPrivateFieldGet(this, _RedisClient_storage, "f").SetRange({ key, offset, value, scope: this.scope }, __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_metadata_get));
+        return response.value;
+    }
+    async strlen(key) {
+        const response = await __classPrivateFieldGet(this, _RedisClient_storage, "f").Strlen({ key, scope: this.scope }, __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_metadata_get));
+        return response.value;
+    }
+    async expire(key, seconds) {
+        await __classPrivateFieldGet(this, _RedisClient_storage, "f").Expire({ key, seconds, scope: this.scope }, __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_metadata_get));
+    }
+    async expiretime(key) {
+        const response = await __classPrivateFieldGet(this, _RedisClient_storage, "f").ExpireTime({ key, scope: this.scope }, __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_metadata_get));
+        return response.value;
+    }
+    async zadd(key, ...members) {
+        return (await __classPrivateFieldGet(this, _RedisClient_storage, "f").ZAdd({ key, members, scope: this.scope }, __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_metadata_get))).value;
+    }
+    async zrange(key, start, stop, options) {
+        // eslint-disable-next-line
+        let opts = { rev: false, byLex: false, byScore: false, offset: 0, count: 1000 };
+        if (options?.reverse) {
+            opts.rev = options.reverse;
+        }
+        if (options?.by === 'lex') {
+            opts.byLex = true;
+        }
+        else if (options?.by === 'score') {
+            opts.byScore = true;
+        }
+        else {
+            // LIMIT requires BYLEX/BYSCORE
+            opts.offset = 0;
+            opts.count = 0;
+        }
+        if (options?.limit) {
+            if (opts.byLex || opts.byScore) {
+                opts.offset = options.limit.offset;
+                opts.count = options.limit.count;
+            }
+            else {
+                throw new Error(`zRange parsing error: 'limit' only allowed when 'options.by' is 'lex' or 'score'`);
+            }
+        }
+        return (await __classPrivateFieldGet(this, _RedisClient_storage, "f").ZRange({ key: { key: key }, start: start + '', stop: stop + '', ...opts, scope: this.scope }, __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_metadata_get))).members;
+    }
+    async zrem(key, members) {
+        const response = await __classPrivateFieldGet(this, _RedisClient_storage, "f").ZRem({ key: { key }, members, scope: this.scope }, __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_metadata_get));
+        return response.value;
+    }
+    async zremrangebylex(key, min, max) {
+        const response = await __classPrivateFieldGet(this, _RedisClient_storage, "f").ZRemRangeByLex({ key: { key }, min, max, scope: this.scope }, __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_metadata_get));
+        return response.value;
+    }
+    async zremrangebyrank(key, start, stop) {
+        const response = await __classPrivateFieldGet(this, _RedisClient_storage, "f").ZRemRangeByRank({ key: { key }, start, stop, scope: this.scope }, __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_metadata_get));
+        return response.value;
+    }
+    async zremrangebyscore(key, min, max) {
+        const response = await __classPrivateFieldGet(this, _RedisClient_storage, "f").ZRemRangeByScore({ key: { key }, min, max, scope: this.scope }, __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_metadata_get));
+        return response.value;
+    }
+    async zscore(key, member) {
+        try {
+            const response = await __classPrivateFieldGet(this, _RedisClient_storage, "f").ZScore({ key: { key }, member, scope: this.scope }, {
+                ...__classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_metadata_get),
+                'throw-redis-nil': { values: ['true'] },
+            });
+            return response !== null ? response.value : response;
+        }
+        catch (e) {
+            if (isRedisNilError(e)) {
+                return undefined;
+            }
+            throw e;
+        }
+    }
+    async zrank(key, member) {
+        try {
+            const response = await __classPrivateFieldGet(this, _RedisClient_storage, "f").ZRank({ key: { key }, member, scope: this.scope }, {
+                ...__classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_metadata_get),
+                'throw-redis-nil': { values: ['true'] },
+            });
+            return response !== null ? response.value : response;
+        }
+        catch (e) {
+            if (isRedisNilError(e)) {
+                return undefined;
+            }
+            throw e;
+        }
+    }
+    async zincrby(key, member, value) {
+        const response = await __classPrivateFieldGet(this, _RedisClient_storage, "f").ZIncrBy({ key, member, value, scope: this.scope }, __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_metadata_get));
+        return response !== null ? response.value : response;
+    }
+    async mget(keys) {
+        const response = await __classPrivateFieldGet(this, _RedisClient_storage, "f").MGet({ keys, scope: this.scope }, __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_metadata_get));
+        return response !== null ? response.values.map((value) => value || null) : response;
+    }
+    async mset(keyValues) {
+        const kv = Object.entries(keyValues).map(([key, value]) => ({ key, value }));
+        await __classPrivateFieldGet(this, _RedisClient_storage, "f").MSet({ kv, scope: this.scope }, __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_metadata_get));
+    }
+    async zcard(key) {
+        const response = await __classPrivateFieldGet(this, _RedisClient_storage, "f").ZCard({ key, scope: this.scope }, __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_metadata_get));
+        return response !== null ? response.value : response;
+    }
+    async zscan(key, cursor, pattern, count) {
+        const request = { key, cursor, pattern, count, scope: this.scope };
+        return await __classPrivateFieldGet(this, _RedisClient_storage, "f").ZScan(request, __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_metadata_get));
+    }
+    async type(key) {
+        const response = await __classPrivateFieldGet(this, _RedisClient_storage, "f").Type({ key: key, scope: this.scope }, __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_metadata_get));
+        return response !== null ? response.value : response;
+    }
+    async rename(key, newKey) {
+        const response = await __classPrivateFieldGet(this, _RedisClient_storage, "f").Rename({ key, newKey, scope: this.scope }, __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_metadata_get));
+        return response.result;
+    }
+    async hget(key, field) {
+        try {
+            const response = await __classPrivateFieldGet(this, _RedisClient_storage, "f").HGet({ key, field, scope: this.scope }, {
+                ...__classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_metadata_get),
+                'throw-redis-nil': { values: ['true'] },
+            });
+            return response !== null ? (response.value ?? undefined) : response;
+        }
+        catch (e) {
+            if (isRedisNilError(e)) {
+                return undefined;
+            }
+            throw e;
+        }
+    }
+    async hmget(key, fields) {
+        const response = await __classPrivateFieldGet(this, _RedisClient_storage, "f").HMGet({ key, fields, scope: this.scope }, __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_metadata_get));
+        return response !== null ? response.values.map((value) => value || null) : response;
+    }
+    async hset(key, fieldValues) {
+        const fv = Object.entries(fieldValues).map(([field, value]) => ({ field, value }));
+        const response = await __classPrivateFieldGet(this, _RedisClient_storage, "f").HSet({ key, fv, scope: this.scope }, __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_metadata_get));
+        return response.value;
+    }
+    async hsetnx(key, field, value) {
+        const response = await __classPrivateFieldGet(this, _RedisClient_storage, "f").HSetNX({ key, field, value, scope: this.scope }, __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_metadata_get));
+        return response.success;
+    }
+    async hgetall(key) {
+        const response = await __classPrivateFieldGet(this, _RedisClient_storage, "f").HGetAll({ key, scope: this.scope }, __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_metadata_get));
+        return response !== null ? response.fieldValues : response;
+    }
+    async hdel(key, fields) {
+        const response = await __classPrivateFieldGet(this, _RedisClient_storage, "f").HDel({ key, fields, scope: this.scope }, __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_metadata_get));
+        return response.value;
+    }
+    async hscan(key, cursor, pattern, count) {
+        const request = { key, cursor, pattern, count, scope: this.scope };
+        return await __classPrivateFieldGet(this, _RedisClient_storage, "f").HScan(request, __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_metadata_get));
+    }
+    async hkeys(key) {
+        const response = await __classPrivateFieldGet(this, _RedisClient_storage, "f").HKeys({ key, scope: this.scope }, __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_metadata_get));
+        return response !== null ? response.keys : response;
+    }
+    async hincrby(key, field, value) {
+        const response = await __classPrivateFieldGet(this, _RedisClient_storage, "f").HIncrBy({ key, field, value, scope: this.scope }, __classPrivateFieldGet(this, _RedisClient_instances, "a", _RedisClient_metadata_get));
+        return response.value;
+    }
+    async hlen(key) {
+        const response = await __classPrivateFieldGet(this, _RedisClient_storage, "f").HLen({
+            key,
+            scope: this.scope,
+        });
+        return response.value;
+    }
+    async bitfield(key, ...cmds) {
+        const commands = [];
+        for (let argIndex = 0; argIndex < cmds.length;) {
+            const currentArg = cmds[argIndex];
+            const command = {};
+            switch (currentArg) {
+                case 'get': {
+                    if (argIndex + 2 >= cmds.length) {
+                        throw Error(`bitfield command parse failed; not enough arguments for 'get' command`);
+                    }
+                    command.get = {
+                        encoding: cmds[argIndex + 1],
+                        offset: cmds[argIndex + 2].toString(),
+                    };
+                    argIndex += 3;
+                    break;
+                }
+                case 'set': {
+                    if (argIndex + 3 >= cmds.length) {
+                        throw Error(`bitfield command parse failed; not enough arguments for 'set' command`);
+                    }
+                    command.set = {
+                        encoding: cmds[argIndex + 1],
+                        offset: cmds[argIndex + 2].toString(),
+                        value: cmds[argIndex + 3].toString(),
+                    };
+                    argIndex += 4;
+                    break;
+                }
+                case 'incrBy': {
+                    if (argIndex + 3 >= cmds.length) {
+                        throw Error(`bitfield command parse failed; not enough arguments for 'incrBy' command`);
+                    }
+                    command.incrBy = {
+                        encoding: cmds[argIndex + 1],
+                        offset: cmds[argIndex + 2].toString(),
+                        increment: cmds[argIndex + 3].toString(),
+                    };
+                    argIndex += 4;
+                    break;
+                }
+                case 'overflow': {
+                    if (argIndex + 1 >= cmds.length) {
+                        throw Error(`bitfield command parse failed; not enough arguments for 'overflow' command`);
+                    }
+                    const behavior = cmds[argIndex + 1].toString();
+                    command.overflow = {
+                        behavior: toBehaviorProto(behavior),
+                    };
+                    argIndex += 2;
+                    break;
+                }
+                default: {
+                    throw Error(`bitfield command parse failed; ${currentArg} unrecognized (must be 'get', 'set', 'incrBy', or 'overflow')`);
+                }
+            }
+            commands.push(command);
+        }
+        const response = await __classPrivateFieldGet(this, _RedisClient_storage, "f").Bitfield({
+            key,
+            commands,
+        });
+        return response.results;
+    }
+}
+_RedisClient_storage = new WeakMap(), _RedisClient_instances = new WeakSet(), _RedisClient_metadata_get = function _RedisClient_metadata_get() {
+    return getContext().debug.metadata;
+};
+function toBehaviorProto(behavior) {
+    const lowercase = behavior.toLowerCase();
+    switch (lowercase) {
+        case 'wrap':
+            return BitfieldOverflowBehavior.BITFIELD_OVERFLOW_BEHAVIOR_WRAP;
+        case 'sat':
+            return BitfieldOverflowBehavior.BITFIELD_OVERFLOW_BEHAVIOR_SAT;
+        case 'fail':
+            return BitfieldOverflowBehavior.BITFIELD_OVERFLOW_BEHAVIOR_FAIL;
+        default:
+            throw Error(`unknown bitfield overflow behavior: ${lowercase}`);
+    }
+}
+function isRedisNilError(e) {
+    // TODO: Replace with impl in a Gatsby-only world
+    //return e && e.details === 'redis: nil';
+    if (e && typeof e === 'object' && 'message' in e && typeof e.message === 'string') {
+        return e.message.includes('redis: nil');
+    }
+    else {
+        return false;
+    }
+}
+function assertTxMetadataIsCurrent(metadata) {
+    const context = getContext();
+    if (context.debug.metadata !== metadata) {
+        throw new Error(`TxClient: Current metadata does not match what was used to start the transaction. Don't pass clients around between calls!`);
+    }
+}

package/RedisClient.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RedisClient.test.d.ts","sourceRoot":"","sources":["../src/RedisClient.test.ts"],"names":[],"mappings":""}

package/getRedis.d.ts

@@ -0,0 +1,4 @@
+import { RedisKeyScope } from '@devvit/protos';
+import { RedisClient } from './RedisClient.js';
+export declare function getRedis(scope?: RedisKeyScope): RedisClient;
+//# sourceMappingURL=getRedis.d.ts.map

package/getRedis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getRedis.d.ts","sourceRoot":"","sources":["../src/getRedis.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqC,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAGlF,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAI/C,wBAAgB,QAAQ,CAAC,KAAK,GAAE,aAA0C,GAAG,WAAW,CAMvF"}

package/getRedis.js

@@ -0,0 +1,10 @@
+import { RedisAPIDefinition, RedisKeyScope } from '@devvit/protos';
+import { getDevvitConfig } from '@devvit/server/get-devvit-config.js';
+import { RedisClient } from './RedisClient.js';
+let redisApiPlugin;
+export function getRedis(scope = RedisKeyScope.INSTALLATION) {
+    if (!redisApiPlugin) {
+        redisApiPlugin = getDevvitConfig().use(RedisAPIDefinition);
+    }
+    return new RedisClient(redisApiPlugin, scope);
+}

package/index.d.ts

@@ -0,0 +1,4 @@
+export { getRedis } from './getRedis.js';
+export type { RedisClient } from './RedisClient.js';
+export { RedisKeyScope } from './RedisClient.js';
+//# sourceMappingURL=index.d.ts.map

package/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,YAAY,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC"}

package/index.js

@@ -0,0 +1,2 @@
+export { getRedis } from './getRedis.js';
+export { RedisKeyScope } from './RedisClient.js';