@devvit/shared-types 0.10.21-next-2024-05-11-bfded257b.0 → 0.10.21-next-2024-05-13-e62a4282b.0

package/Actor.d.ts

@@ -0,0 +1,31 @@
+/**
+ * All Bundle programs are Actor subclasses. Actor instances are expected to
+ * populate the passed in Config which is used by the builder to compile and
+ * link the programs. Bundle programs are expected to export their subclass
+ * constructor, either their own Actor subclass or Devvit.
+ *
+ * Devvit is an Actor subclass singleton with a non-class-based API.
+ *
+ * `instanceof` and `isPrototypeOf()` tests fail because Devvit and Actor
+ * are multiply defined.
+ *
+ * Developers will, for now, implement this class and
+ * utilize the the `cfg.use/provide` api for both:
+ *
+ * 1. specifying their `DependencySpec` (proto: devvit/runtime/bundle)
+ *      Build packs will, for now, create an instance of the Actor and use the
+ *      result of `config.export` for linking
+ *
+ * 2. When running within the overall system, `Bootstrap` actor will
+ *      inject a config that is used to setup links within the runtime.
+ */
+import type { Config } from './Config.js';
+/**
+ * Subclasses are expected to call config.init(), provides(), and uses(). It
+ * is erroneous to not override the constructor. Override, invoke
+ * `super(config)`, and call the Config APIs.
+ */
+export declare abstract class Actor {
+    constructor(config: Config);
+}
+//# sourceMappingURL=Actor.d.ts.map

package/Actor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Actor.d.ts","sourceRoot":"","sources":["../src/Actor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C;;;;GAIG;AACH,8BAAsB,KAAK;gBAGvB,MAAM,EAAE,MAAM;CAEjB"}

package/Actor.js

@@ -0,0 +1,31 @@
+/**
+ * All Bundle programs are Actor subclasses. Actor instances are expected to
+ * populate the passed in Config which is used by the builder to compile and
+ * link the programs. Bundle programs are expected to export their subclass
+ * constructor, either their own Actor subclass or Devvit.
+ *
+ * Devvit is an Actor subclass singleton with a non-class-based API.
+ *
+ * `instanceof` and `isPrototypeOf()` tests fail because Devvit and Actor
+ * are multiply defined.
+ *
+ * Developers will, for now, implement this class and
+ * utilize the the `cfg.use/provide` api for both:
+ *
+ * 1. specifying their `DependencySpec` (proto: devvit/runtime/bundle)
+ *      Build packs will, for now, create an instance of the Actor and use the
+ *      result of `config.export` for linking
+ *
+ * 2. When running within the overall system, `Bootstrap` actor will
+ *      inject a config that is used to setup links within the runtime.
+ */
+/**
+ * Subclasses are expected to call config.init(), provides(), and uses(). It
+ * is erroneous to not override the constructor. Override, invoke
+ * `super(config)`, and call the Config APIs.
+ */
+export class Actor {
+    constructor(
+    // @ts-expect-error
+    config) { }
+}

package/Config.d.ts

@@ -0,0 +1,26 @@
+import type { Definition, DependencySpec, PackageQuery } from '@devvit/protos';
+import type { AssetMap } from './Assets.js';
+import type { DeepPartial } from './BuiltinTypes.js';
+import type { Namespace } from './Namespace.js';
+/**
+ * Bundle configuration for code about to be built (eg, dependencies). All
+ * Bundle config state that impacts building should be recorded in the
+ * implementation. See Actor subclass constructors.
+ *
+ * This type is = kind of like a builder pattern where export() is the build
+ * method. Devvit almost implements this class.
+ */
+export type Config = {
+    assets: Readonly<AssetMap>;
+    providedDefinitions: Readonly<Definition>[];
+    export(namespace: Readonly<Namespace>): DependencySpec;
+    provides(definition: Readonly<Definition>): void;
+    use<T>(definition: Readonly<Definition>, options?: Readonly<DeepPartial<PackageQuery>>): T;
+    /**
+     * Check if a previous call to `use` was made. This is useful for allowing polyfills
+     * to ensure that they can provide functionality in terms of a plugin, or fallback to
+     * default functionality if not
+     */
+    uses(definition: Readonly<Definition>): boolean;
+};
+//# sourceMappingURL=Config.d.ts.map

package/Config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Config.d.ts","sourceRoot":"","sources":["../src/Config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC/E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEhD;;;;;;;GAOG;AACH,MAAM,MAAM,MAAM,GAAG;IACnB,MAAM,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAC;IAE3B,mBAAmB,EAAE,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC;IAE5C,MAAM,CAAC,SAAS,EAAE,QAAQ,CAAC,SAAS,CAAC,GAAG,cAAc,CAAC;IAEvD,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,UAAU,CAAC,GAAG,IAAI,CAAC;IAEjD,GAAG,CAAC,CAAC,EAAE,UAAU,EAAE,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC,EAAE,QAAQ,CAAC,WAAW,CAAC,YAAY,CAAC,CAAC,GAAG,CAAC,CAAC;IAE3F;;;;OAIG;IACH,IAAI,CAAC,UAAU,EAAE,QAAQ,CAAC,UAAU,CAAC,GAAG,OAAO,CAAC;CACjD,CAAC"}

package/Config.js

@@ -0,0 +1 @@
+export {};

package/Namespace.d.ts

@@ -0,0 +1,12 @@
+export type Namespace = {
+    /**
+     * Nonnullish address when bound. Set when bound but may be set sooner. May
+     * not be unset when unbound.
+     *
+     * Hostnames are not necessarily unique. Clients always have the same hostname
+     * as their EnvelopeDispatcher. Stream IDs are used to distinguish duplicate
+     * hostnames.
+     */
+    hostname: string | undefined;
+};
+//# sourceMappingURL=Namespace.d.ts.map

package/Namespace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Namespace.d.ts","sourceRoot":"","sources":["../src/Namespace.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,GAAG;IACtB;;;;;;;OAOG;IACH,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;CAC9B,CAAC"}

package/Namespace.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devvit/shared-types",
-  "version": "0.10.21-next-2024-05-11-bfded257b.0",
+  "version": "0.10.21-next-2024-05-13-e62a4282b.0",
   "license": "BSD-3-Clause",
   "repository": {
     "type": "git",
@@ -23,14 +23,17 @@
   },
   "types": "./index.d.ts",
   "dependencies": {
-    "@devvit/protos": "0.10.21-next-2024-05-11-bfded257b.0"
+    "@devvit/protos": "0.10.21-next-2024-05-13-e62a4282b.0"
   },
   "devDependencies": {
     "@devvit/eslint-config": "0.10.20",
     "@devvit/repo-tools": "0.10.20",
-    "@devvit/tsconfig": "0.10.21-next-2024-05-11-bfded257b.0",
+    "@devvit/tsconfig": "0.10.21-next-2024-05-13-e62a4282b.0",
+    "@types/redis-mock": "0.17.1",
     "eslint": "8.9.0",
     "lit": "2.2.8",
+    "redis": "4.6.6",
+    "redis-mock": "0.56.3",
     "typescript": "5.3.2",
     "vitest": "0.31.0"
   },
@@ -38,5 +41,5 @@
     "directory": "dist"
   },
   "source": "./src/index.ts",
-  "gitHead": "8d3e9e2b35030b7ef99c86acfe8a8093aed7db34"
+  "gitHead": "93cd2af8a1943e6b3416c82906891de040277b45"
 }

package/test/LocalRedis.d.ts

@@ -0,0 +1,49 @@
+import type { ExpireRequest, HIncrByRequest, IncrByRequest, KeyValuesRequest, KeysRequest, Metadata, RedisAPI, SetRangeRequest, TransactionId, TransactionResponses, WatchRequest, ZIncrByRequest, ZRankRequest, ZScanRequest, ZScanResponse } from '@devvit/protos';
+import { DoubleValue, Empty, Int64Value, RedisFieldValues, RedisValues, StringValue } from '@devvit/protos';
+import type { RedisClientType, RedisDefaultModules } from 'redis';
+import type { HDelRequest, HGetRequest, HScanRequest, HScanResponse, HSetRequest, KeyRangeRequest, KeyRequest, KeysResponse, SetRequest, ZAddRequest, ZRangeRequest, ZRemRangeByLexRequest, ZRemRangeByRankRequest, ZRemRangeByScoreRequest, ZRemRequest, ZScoreRequest } from '@devvit/protos';
+import { ZMembers } from '@devvit/protos';
+type RedisClient = RedisClientType<RedisDefaultModules>;
+export declare class LocalRedis implements RedisAPI {
+    #private;
+    static create(url?: string): Promise<LocalRedis>;
+    constructor(redis: RedisClient);
+    Del(request: KeysRequest, metadata: Metadata | undefined): Promise<Int64Value>;
+    Type(request: KeyRequest, metadata: Metadata | undefined): Promise<StringValue>;
+    Multi(request: TransactionId, _metadata: Metadata | undefined): Promise<Empty>;
+    Exec(request: TransactionId, _metadata: Metadata | undefined): Promise<TransactionResponses>;
+    Discard(request: TransactionId, _metadata: Metadata | undefined): Promise<Empty>;
+    Unwatch(request: TransactionId, _metadata: Metadata | undefined): Promise<Empty>;
+    Watch(request: WatchRequest, metadata: Metadata | undefined): Promise<TransactionId>;
+    GetRange(request: KeyRangeRequest, metadata: Metadata | undefined): Promise<StringValue>;
+    IncrBy(request: IncrByRequest, metadata: Metadata | undefined): Promise<Int64Value>;
+    SetRange(request: SetRangeRequest, metadata: Metadata | undefined): Promise<Int64Value>;
+    Strlen(request: KeyRequest, metadata: Metadata | undefined): Promise<Int64Value>;
+    MGet(request: KeysRequest, metadata: Metadata | undefined): Promise<RedisValues>;
+    MSet(request: KeyValuesRequest, metadata: Metadata | undefined): Promise<Empty>;
+    Get(request: KeyRequest, metadata: Metadata | undefined): Promise<StringValue>;
+    Set(request: SetRequest, metadata: Metadata | undefined): Promise<StringValue>;
+    Expire(request: ExpireRequest, metadata: Metadata | undefined): Promise<Empty>;
+    ExpireTime(request: KeyRequest, metadata: Metadata | undefined): Promise<Int64Value>;
+    ZCard(request: KeyRequest, metadata: Metadata | undefined): Promise<Int64Value>;
+    ZAdd(request: ZAddRequest, metadata: Metadata | undefined): Promise<Int64Value>;
+    ZRem(request: ZRemRequest, metadata: Metadata | undefined): Promise<Int64Value>;
+    ZRange(request: ZRangeRequest, metadata: Metadata | undefined): Promise<ZMembers>;
+    ZRemRangeByLex(request: ZRemRangeByLexRequest, metadata: Metadata | undefined): Promise<Int64Value>;
+    ZRemRangeByRank(request: ZRemRangeByRankRequest, metadata: Metadata | undefined): Promise<Int64Value>;
+    ZRemRangeByScore(request: ZRemRangeByScoreRequest, metadata: Metadata | undefined): Promise<Int64Value>;
+    HGet(_request: HGetRequest, _metadata: Metadata | undefined): Promise<StringValue>;
+    HSet(_request: HSetRequest, _metadata: Metadata | undefined): Promise<Int64Value>;
+    HGetAll(_request: KeyRequest, _metadata: Metadata | undefined): Promise<RedisFieldValues>;
+    HDel(_request: HDelRequest, _metadata: Metadata | undefined): Promise<Int64Value>;
+    ZScore(_request: ZScoreRequest, _metadata: Metadata | undefined): Promise<DoubleValue>;
+    ZRank(_request: ZRankRequest, _metadata: Metadata | undefined): Promise<Int64Value>;
+    ZScan(_request: ZScanRequest, _metadata: Metadata | undefined): Promise<ZScanResponse>;
+    ZIncrBy(_request: ZIncrByRequest, _metadata: Metadata | undefined): Promise<DoubleValue>;
+    HKeys(_request: KeyRequest, _metadata?: Metadata): Promise<KeysResponse>;
+    HScan(_request: HScanRequest, _metadata?: Metadata): Promise<HScanResponse>;
+    HIncrBy(_request: HIncrByRequest, _metadata?: Metadata): Promise<Int64Value>;
+    HLen(_request: KeyRequest, _metadata?: Metadata): Promise<Int64Value>;
+}
+export {};
+//# sourceMappingURL=LocalRedis.d.ts.map

package/test/LocalRedis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LocalRedis.d.ts","sourceRoot":"","sources":["../../src/test/LocalRedis.ts"],"names":[],"mappings":"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"}

package/test/LocalRedis.js

@@ -0,0 +1,443 @@
+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 _LocalRedis_instances, _LocalRedis_redis, _LocalRedis_transactions, _LocalRedis_tx, _LocalRedis_newtx;
+import { DoubleValue, Empty, Int64Value, RedisFieldValues, RedisValues, StringValue, } from '@devvit/protos';
+import { createClient } from 'redis';
+import { ZMembers } from '@devvit/protos';
+import { Header } from '../Header.js';
+const MaxResults = 1000;
+const localRuntimeError = 'Please use devvit playtest to verify your app in a test subreddit.';
+function namespacedKey(metadata, key) {
+    const installation = metadata?.[Header.Installation]?.values[0] || '';
+    const app = metadata?.[Header.App]?.values[0] || '';
+    return `${installation}:${app}:${key}`;
+}
+export class LocalRedis {
+    static async create(url) {
+        if (!url) {
+            if (process.env.CI === 'true') {
+                url = 'redis://redis:6379';
+            }
+            else {
+                url = 'redis://localhost:6379';
+            }
+        }
+        const redis = createClient({ url });
+        console.log(`connecting to ${url} ...`);
+        await redis.connect();
+        await redis.flushAll();
+        return new LocalRedis(redis);
+    }
+    constructor(redis) {
+        _LocalRedis_instances.add(this);
+        _LocalRedis_redis.set(this, void 0);
+        _LocalRedis_transactions.set(this, {});
+        __classPrivateFieldSet(this, _LocalRedis_redis, redis, "f");
+    }
+    async Del(request, metadata) {
+        const keys = request.keys.map((key) => namespacedKey(metadata, key));
+        if (request.transactionId) {
+            await __classPrivateFieldGet(this, _LocalRedis_instances, "m", _LocalRedis_tx).call(this, request.transactionId).del(keys);
+            return { value: 0 };
+        }
+        else {
+            const count = await __classPrivateFieldGet(this, _LocalRedis_redis, "f").del(keys);
+            return { value: count };
+        }
+    }
+    async Type(request, metadata) {
+        const type = await __classPrivateFieldGet(this, _LocalRedis_redis, "f").type(namespacedKey(metadata, request.key));
+        return { value: type };
+    }
+    async Multi(request, _metadata) {
+        const transaction = __classPrivateFieldGet(this, _LocalRedis_transactions, "f")[request.id];
+        if (!transaction) {
+            throw new Error('Transaction not found');
+        }
+        if (transaction.multi) {
+            throw new Error('Transaction already multi');
+        }
+        transaction.multi = transaction.isoClient.multi();
+        return {};
+    }
+    async Exec(request, _metadata) {
+        const transaction = __classPrivateFieldGet(this, _LocalRedis_transactions, "f")[request.id];
+        if (!transaction) {
+            throw new Error('Transaction not found');
+        }
+        if (!transaction.multi) {
+            await transaction.close();
+            throw new Error('Transaction not multi');
+        }
+        const responses = await transaction.multi.exec();
+        console.log(responses);
+        delete __classPrivateFieldGet(this, _LocalRedis_transactions, "f")[request.id];
+        const values = (responses || []).map((value) => {
+            if (typeof value === 'string') {
+                return { str: value };
+            }
+            else if (value === null) {
+                return { nil: {} };
+            }
+            else if (typeof value === 'number') {
+                return { num: value };
+            }
+            else if (Array.isArray(value)) {
+                const strings = value.map((v) => v + '');
+                return { values: { values: strings } };
+            }
+            else {
+                throw new Error('Unsupported value type');
+            }
+        });
+        await transaction.close();
+        return { response: values };
+    }
+    async Discard(request, _metadata) {
+        const transaction = __classPrivateFieldGet(this, _LocalRedis_transactions, "f")[request.id];
+        if (!transaction) {
+            throw new Error('Transaction not found');
+        }
+        if (!transaction.multi) {
+            await transaction.close();
+            throw new Error('Multi not found');
+        }
+        transaction.multi.discard();
+        await transaction.close();
+        delete __classPrivateFieldGet(this, _LocalRedis_transactions, "f")[request.id];
+        return Empty.fromPartial({});
+    }
+    async Unwatch(request, _metadata) {
+        await __classPrivateFieldGet(this, _LocalRedis_instances, "m", _LocalRedis_tx).call(this, request).unwatch();
+        return Empty.fromPartial({});
+    }
+    async Watch(request, metadata) {
+        let id = request.transactionId;
+        if (!id) {
+            const tx = await __classPrivateFieldGet(this, _LocalRedis_instances, "m", _LocalRedis_newtx).call(this);
+            id = { id: tx.id };
+        }
+        if (request.keys.length > 0) {
+            const keys = request.keys.map((key) => namespacedKey(metadata, key));
+            await __classPrivateFieldGet(this, _LocalRedis_instances, "m", _LocalRedis_tx).call(this, id).watch(keys);
+        }
+        return id;
+    }
+    async GetRange(request, metadata) {
+        const key = namespacedKey(metadata, request.key);
+        if (request.transactionId) {
+            await __classPrivateFieldGet(this, _LocalRedis_instances, "m", _LocalRedis_tx).call(this, request.transactionId).getRange(key, request.start, request.end);
+            return StringValue.fromPartial({});
+        }
+        else {
+            const value = await __classPrivateFieldGet(this, _LocalRedis_redis, "f").getRange(key, request.start, request.end);
+            return value ? { value: value } : StringValue.fromPartial({});
+        }
+    }
+    async IncrBy(request, metadata) {
+        const key = namespacedKey(metadata, request.key);
+        if (request.transactionId) {
+            await __classPrivateFieldGet(this, _LocalRedis_instances, "m", _LocalRedis_tx).call(this, request.transactionId).incrBy(key, request.value);
+            return Int64Value.fromPartial({});
+        }
+        else {
+            const value = await __classPrivateFieldGet(this, _LocalRedis_redis, "f").incrBy(key, request.value);
+            return { value };
+        }
+    }
+    async SetRange(request, metadata) {
+        const key = namespacedKey(metadata, request.key);
+        if (request.transactionId) {
+            await __classPrivateFieldGet(this, _LocalRedis_instances, "m", _LocalRedis_tx).call(this, request.transactionId).setRange(key, request.offset, request.value);
+            return Int64Value.fromPartial({});
+        }
+        else {
+            const length = await __classPrivateFieldGet(this, _LocalRedis_redis, "f").setRange(key, request.offset, request.value);
+            return { value: length };
+        }
+    }
+    async Strlen(request, metadata) {
+        const key = namespacedKey(metadata, request.key);
+        if (request.transactionId) {
+            await __classPrivateFieldGet(this, _LocalRedis_instances, "m", _LocalRedis_tx).call(this, request.transactionId).strLen(key);
+            return Int64Value.fromPartial({});
+        }
+        else {
+            const length = await __classPrivateFieldGet(this, _LocalRedis_redis, "f").strLen(key);
+            return { value: length };
+        }
+    }
+    async MGet(request, metadata) {
+        const keys = request.keys.map((key) => namespacedKey(metadata, key));
+        if (request.transactionId) {
+            await __classPrivateFieldGet(this, _LocalRedis_instances, "m", _LocalRedis_tx).call(this, request.transactionId).mGet(keys);
+            return RedisValues.fromPartial({});
+        }
+        else {
+            const values = await __classPrivateFieldGet(this, _LocalRedis_redis, "f").mGet(keys);
+            return RedisValues.fromPartial({ values: values.map((value) => (value ? value : '')) });
+        }
+    }
+    async MSet(request, metadata) {
+        const keyValues = request.kv.reduce((obj, item) => {
+            obj[namespacedKey(metadata, item.key)] = item.value;
+            return obj;
+        }, {});
+        if (request.transactionId) {
+            await __classPrivateFieldGet(this, _LocalRedis_instances, "m", _LocalRedis_tx).call(this, request.transactionId).mSet(keyValues);
+        }
+        else {
+            await __classPrivateFieldGet(this, _LocalRedis_redis, "f").mSet(keyValues);
+        }
+        return Empty.fromPartial({});
+    }
+    async Get(request, metadata) {
+        const key = namespacedKey(metadata, request.key);
+        if (request.transactionId) {
+            await __classPrivateFieldGet(this, _LocalRedis_instances, "m", _LocalRedis_tx).call(this, request.transactionId).get(key);
+            return StringValue.fromPartial({});
+        }
+        else {
+            const value = await __classPrivateFieldGet(this, _LocalRedis_redis, "f").get(key);
+            return { value: value ?? '' };
+        }
+    }
+    async Set(request, metadata) {
+        const key = namespacedKey(metadata, request.key);
+        if (request.transactionId) {
+            await __classPrivateFieldGet(this, _LocalRedis_instances, "m", _LocalRedis_tx).call(this, request.transactionId).set(key, request.value);
+            return StringValue.fromPartial({});
+        }
+        else {
+            if (request.nx) {
+                const value = await __classPrivateFieldGet(this, _LocalRedis_redis, "f").setNX(key, request.value);
+                return { value: value ? 'OK' : '' };
+            }
+            else {
+                const value = await __classPrivateFieldGet(this, _LocalRedis_redis, "f").set(key, request.value);
+                return { value: value ?? '' };
+            }
+        }
+    }
+    async Expire(request, metadata) {
+        const key = namespacedKey(metadata, request.key);
+        if (request.transactionId) {
+            await __classPrivateFieldGet(this, _LocalRedis_instances, "m", _LocalRedis_tx).call(this, request.transactionId).expire(key, request.seconds);
+        }
+        else {
+            await __classPrivateFieldGet(this, _LocalRedis_redis, "f").expire(key, request.seconds);
+        }
+        return Empty.fromPartial({});
+    }
+    async ExpireTime(request, metadata) {
+        const key = namespacedKey(metadata, request.key);
+        if (request.transactionId) {
+            await __classPrivateFieldGet(this, _LocalRedis_instances, "m", _LocalRedis_tx).call(this, request.transactionId).ttl(key);
+            return Int64Value.fromPartial({});
+        }
+        else {
+            const ttl = await __classPrivateFieldGet(this, _LocalRedis_redis, "f").ttl(key);
+            return { value: ttl };
+        }
+    }
+    async ZCard(request, metadata) {
+        const key = namespacedKey(metadata, request.key);
+        if (request.transactionId) {
+            await __classPrivateFieldGet(this, _LocalRedis_instances, "m", _LocalRedis_tx).call(this, request.transactionId).zCard(key);
+            return Int64Value.fromPartial({});
+        }
+        else {
+            const length = await __classPrivateFieldGet(this, _LocalRedis_redis, "f").zCard(key);
+            return { value: length };
+        }
+    }
+    async ZAdd(request, metadata) {
+        const key = namespacedKey(metadata, request.key);
+        const zaddArgs = request.members.flatMap((member) => ({
+            score: member.score,
+            value: member.member,
+        }));
+        if (request.transactionId) {
+            await __classPrivateFieldGet(this, _LocalRedis_instances, "m", _LocalRedis_tx).call(this, request.transactionId).zAdd(key, zaddArgs);
+            return Int64Value.fromPartial({});
+        }
+        else {
+            const changed = await __classPrivateFieldGet(this, _LocalRedis_redis, "f").zAdd(key, zaddArgs);
+            return { value: changed };
+        }
+    }
+    async ZRem(request, metadata) {
+        const key = namespacedKey(metadata, request.key.key);
+        if (request.key?.transactionId) {
+            await __classPrivateFieldGet(this, _LocalRedis_instances, "m", _LocalRedis_tx).call(this, request.key?.transactionId).zRem(key, request.members);
+            return Int64Value.fromPartial({});
+        }
+        else {
+            const count = await __classPrivateFieldGet(this, _LocalRedis_redis, "f").zRem(key, request.members);
+            return { value: count };
+        }
+    }
+    async ZRange(request, metadata) {
+        const key = namespacedKey(metadata, request.key.key);
+        const count = Math.min(request.count, MaxResults); // Define MaxResults constant somewhere in your code
+        // eslint-disable-next-line
+        let opts = {};
+        if (!request.byLex && !request.byScore) {
+            let stop = parseInt(request.stop);
+            const start = parseInt(request.start);
+            stop = Math.min(stop, start + MaxResults);
+            if (stop < 0)
+                stop = start + MaxResults;
+            request.stop = stop.toString();
+        }
+        else {
+            opts.LIMIT = {
+                offset: request.offset,
+                count: count,
+            };
+        }
+        if (request.rev) {
+            throw new Error('unsupported');
+        }
+        if (request.byLex)
+            opts.BY = 'LEX';
+        if (request.byScore)
+            opts.BY = 'SCORE';
+        if (request.rev)
+            opts.REV = true;
+        if (request.key?.transactionId) {
+            await __classPrivateFieldGet(this, _LocalRedis_instances, "m", _LocalRedis_tx).call(this, request.key?.transactionId).zRangeWithScores(key, request.start, request.stop, opts);
+            return ZMembers.fromPartial({});
+        }
+        else {
+            const rsp = await __classPrivateFieldGet(this, _LocalRedis_redis, "f").zRangeWithScores(key, request.start, request.stop, opts);
+            return { members: rsp.map(({ score, value }) => ({ score, member: value })) };
+        }
+    }
+    async ZRemRangeByLex(request, metadata) {
+        const key = namespacedKey(metadata, request.key.key);
+        if (request.key?.transactionId) {
+            await __classPrivateFieldGet(this, _LocalRedis_instances, "m", _LocalRedis_tx).call(this, request.key?.transactionId).zRemRangeByLex(key, request.min, request.max);
+            return Int64Value.fromPartial({});
+        }
+        else {
+            const count = await __classPrivateFieldGet(this, _LocalRedis_redis, "f").zRemRangeByLex(key, request.min, request.max);
+            return { value: count };
+        }
+    }
+    async ZRemRangeByRank(request, metadata) {
+        const key = namespacedKey(metadata, request.key.key);
+        if (request.key?.transactionId) {
+            await __classPrivateFieldGet(this, _LocalRedis_instances, "m", _LocalRedis_tx).call(this, request.key?.transactionId).zRemRangeByRank(key, request.start, request.stop);
+            return Int64Value.fromPartial({});
+        }
+        else {
+            const count = await __classPrivateFieldGet(this, _LocalRedis_redis, "f").zRemRangeByRank(key, request.start, request.stop);
+            return { value: count };
+        }
+    }
+    async ZRemRangeByScore(request, metadata) {
+        const key = namespacedKey(metadata, request.key.key);
+        if (request.key?.transactionId) {
+            await __classPrivateFieldGet(this, _LocalRedis_instances, "m", _LocalRedis_tx).call(this, request.key?.transactionId).zRemRangeByScore(key, request.min.toString(), request.max.toString());
+            return Int64Value.fromPartial({});
+        }
+        else {
+            const count = await __classPrivateFieldGet(this, _LocalRedis_redis, "f").zRemRangeByScore(key, request.min.toString(), request.max.toString());
+            return { value: count };
+        }
+    }
+    async HGet(_request, _metadata) {
+        console.error('HGET is not supported in Node Runtime. ' + localRuntimeError);
+        return StringValue.fromPartial({});
+    }
+    async HSet(_request, _metadata) {
+        console.error('HSET is not supported in Node Runtime. ' + localRuntimeError);
+        return Int64Value.fromPartial({});
+    }
+    async HGetAll(_request, _metadata) {
+        console.error('HGETAll is not supported in Node Runtime. ' + localRuntimeError);
+        return RedisFieldValues.fromPartial({});
+    }
+    async HDel(_request, _metadata) {
+        console.error('HDel is not supported in Node Runtime. ' + localRuntimeError);
+        return Int64Value.fromPartial({});
+    }
+    async ZScore(_request, _metadata) {
+        console.error('ZScore is not supported in Node Runtime. ' + localRuntimeError);
+        return DoubleValue.fromPartial({});
+    }
+    async ZRank(_request, _metadata) {
+        console.error('ZRank is not supported in Node Runtime. ' + localRuntimeError);
+        return Int64Value.fromPartial({});
+    }
+    async ZScan(_request, _metadata) {
+        console.error('ZScan is not supported in Node Runtime. ' + localRuntimeError);
+        return { cursor: 0, members: [] };
+    }
+    async ZIncrBy(_request, _metadata) {
+        console.error('ZIncrBy is not supported in Node Runtime. ' + localRuntimeError);
+        return DoubleValue.fromPartial({});
+    }
+    async HKeys(_request, _metadata) {
+        console.error('HKeys is not supported in Node Runtime. ' + localRuntimeError);
+        return { keys: [] };
+    }
+    async HScan(_request, _metadata) {
+        console.error('HScan is not supported in Node Runtime. ' + localRuntimeError);
+        return { cursor: 0, fieldValues: [] };
+    }
+    async HIncrBy(_request, _metadata) {
+        console.error('HIncrBy is not supported in Node Runtime. ' + localRuntimeError);
+        return Int64Value.fromPartial({});
+    }
+    async HLen(_request, _metadata) {
+        console.error('HLen is not supported in Node Runtime. ' + localRuntimeError);
+        return Int64Value.fromPartial({});
+    }
+}
+_LocalRedis_redis = new WeakMap(), _LocalRedis_transactions = new WeakMap(), _LocalRedis_instances = new WeakSet(), _LocalRedis_tx = function _LocalRedis_tx(txId) {
+    const tx = __classPrivateFieldGet(this, _LocalRedis_transactions, "f")[txId.id];
+    if (!tx) {
+        throw new Error('Transaction not found');
+    }
+    if (tx.multi) {
+        return tx.multi;
+    }
+    return tx.isoClient;
+}, _LocalRedis_newtx = async function _LocalRedis_newtx() {
+    const id = Math.random().toString(36).substring(7);
+    let close;
+    let ready;
+    const closePromise = new Promise((resolve) => {
+        close = resolve;
+    });
+    const readyPromise = new Promise((resolve) => {
+        ready = resolve;
+    });
+    __classPrivateFieldGet(this, _LocalRedis_redis, "f")
+        .executeIsolated(async (isoClient) => {
+        __classPrivateFieldGet(this, _LocalRedis_transactions, "f")[id] = {
+            isoClient,
+            close,
+            multi: undefined,
+            id,
+        };
+        ready();
+        await closePromise;
+    })
+        .catch((err) => {
+        console.error(err);
+    });
+    await readyPromise;
+    return __classPrivateFieldGet(this, _LocalRedis_transactions, "f")[id];
+};

package/test/LocalRedis.test.d.ts.map

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