lakutata 2.0.81 → 2.0.83

package/vendor/Package.68.cjs

@@ -6,78 +6,32 @@ Object.defineProperty(exports, Symbol.toStringTag, {
 
 const t = require("@redis/client");
 
-const e = require("cluster-key-slot");
+const e = require("./Package.66.cjs");
 
-const r = require("./Package.66.cjs");
+const r = require("./Package.67.cjs");
 
-const s = require("./Package.67.cjs");
+const i = require("cluster-key-slot");
 
 require("buffer");
 
-const i = t => t && t.__esModule ? t : {
+const s = t => t && t.__esModule ? t : {
     default: t
 };
 
-const n = i(e);
+const n = s(i);
 
 var o = (t => {
     t["RedisClientNotConnectedThrown"] = "Redis client is not connected or has failed to connect. This is thrown because throwOnConnectError is set to true.";
     return t;
 })(o || {});
 
-var c = t => {
+var a = t => {
     const e = Math.min(2 ** t * 100, 2e3);
     const r = (Math.random() - .5) * 100;
     return e + r;
 };
 
-function a(t, e) {
-    t ??= "redis://localhost:6379";
-    const r = new l(t, e);
-    if (e?.namespace) {
-        r.namespace = e.namespace;
-        const t = new s.Keyv(r, {
-            namespace: e?.namespace,
-            useKeyPrefix: false
-        });
-        if (e?.throwOnConnectError) {
-            t.throwOnErrors = true;
-        }
-        if (e?.throwOnErrors) {
-            t.throwOnErrors = true;
-        }
-        return t;
-    }
-    const i = new s.Keyv(r, {
-        useKeyPrefix: false
-    });
-    if (e?.throwOnConnectError) {
-        i.throwOnErrors = true;
-    }
-    if (e?.throwOnErrors) {
-        i.throwOnErrors = true;
-    }
-    i.namespace = void 0;
-    return i;
-}
-
-function h(t, e) {
-    const r = a(t, e);
-    const s = r.store;
-    s.throwOnConnectError = false;
-    s.throwOnErrors = false;
-    const i = s.client;
-    if (i.options) {
-        i.options.disableOfflineQueue = true;
-        if (i.options.socket) {
-            i.options.socket.reconnectStrategy = false;
-        }
-    }
-    r.throwOnErrors = false;
-    return r;
-}
-
-var l = class extends r.Hookified {
+var c = class extends e.Hookified {
     _client=t.createClient();
     _namespace;
     _keyPrefixSeparator="::";
@@ -85,35 +39,23 @@ var l = class extends r.Hookified {
     _useUnlink=true;
     _noNamespaceAffectsAll=false;
     _throwOnConnectError=true;
-    _throwOnErrors=false;
+    _throwErrors=false;
     _connectionTimeout;
     constructor(e, r) {
         super();
-        const s = {
-            reconnectStrategy: c
+        const i = {
+            reconnectStrategy: a
         };
         if (e) {
             if (typeof e === "string") {
                 this._client = t.createClient({
                     url: e,
-                    socket: s
+                    socket: i
                 });
             } else if (e.connect !== void 0) {
-                if (this.isClientSentinel(e)) {
-                    this._client = e;
-                } else if (this.isClientCluster(e)) {
-                    this._client = e;
-                } else {
-                    this._client = e;
-                }
+                this._client = this.isClientCluster(e) ? e : e;
             } else if (e instanceof Object) {
-                if (e.sentinelRootNodes !== void 0) {
-                    this._client = t.createSentinel(e);
-                } else if (e.rootNodes === void 0) {
-                    this._client = t.createClient(e);
-                } else {
-                    this._client = t.createCluster(e);
-                }
+                this._client = e.rootNodes === void 0 ? t.createClient(e) : t.createCluster(e);
             }
         }
         this.setOptions(r);
@@ -141,7 +83,7 @@ var l = class extends r.Hookified {
             noNamespaceAffectsAll: this._noNamespaceAffectsAll,
             useUnlink: this._useUnlink,
             throwOnConnectError: this._throwOnConnectError,
-            throwOnErrors: this._throwOnErrors,
+            throwErrors: this._throwErrors,
             connectionTimeout: this._connectionTimeout,
             dialect: "redis",
             url: t
@@ -191,11 +133,11 @@ var l = class extends r.Hookified {
     set throwOnConnectError(t) {
         this._throwOnConnectError = t;
     }
-    get throwOnErrors() {
-        return this._throwOnErrors;
+    get throwErrors() {
+        return this._throwErrors;
     }
-    set throwOnErrors(t) {
-        this._throwOnErrors = t;
+    set throwErrors(t) {
+        this._throwErrors = t;
     }
     get connectionTimeout() {
         return this._connectionTimeout;
@@ -215,80 +157,50 @@ var l = class extends r.Hookified {
             }
         } catch (t) {
             this.emit("error", t);
-            await this.disconnect(true);
             if (this._throwOnConnectError) {
                 throw new Error("Redis client is not connected or has failed to connect. This is thrown because throwOnConnectError is set to true.");
             }
+            await this.disconnect(true);
         }
         this.initClient();
         return this._client;
     }
     async set(t, e, r) {
-        const s = await this.getClient();
+        const i = await this.getClient();
         try {
             t = this.createKeyPrefix(t, this._namespace);
             if (r) {
-                await s.set(t, e, {
+                await i.set(t, e, {
                     PX: r
                 });
             } else {
-                await s.set(t, e);
+                await i.set(t, e);
             }
         } catch (t) {
             this.emit("error", t);
-            if (this._throwOnErrors) {
+            if (this._throwErrors) {
                 throw t;
             }
         }
     }
     async setMany(t) {
+        const e = await this.getClient();
         try {
-            if (this.isCluster()) {
-                await this.getClient();
-                const e = new Map;
-                for (const r of t) {
-                    const t = this.createKeyPrefix(r.key, this._namespace);
-                    const s = n.default(t);
-                    const i = e.get(s) ?? [];
-                    i.push(r);
-                    e.set(s, i);
-                }
-                await Promise.all(Array.from(e.entries(), (async ([t, e]) => {
-                    const r = await this.getSlotMaster(t);
-                    const s = r.multi();
-                    for (const {key: t, value: r, ttl: i} of e) {
-                        const e = this.createKeyPrefix(t, this._namespace);
-                        if (i) {
-                            s.set(e, r, {
-                                PX: i
-                            });
-                        } else {
-                            s.set(e, r);
-                        }
-                    }
-                    await s.exec();
-                })));
-            } else {
-                const e = await this.getClient();
-                const r = e.multi();
-                for (const {key: e, value: s, ttl: i} of t) {
-                    const t = this.createKeyPrefix(e, this._namespace);
-                    if (i) {
-                        r.set(t, s, {
-                            PX: i
-                        });
-                    } else {
-                        r.set(t, s);
-                    }
+            const r = e.multi();
+            for (const {key: e, value: i, ttl: s} of t) {
+                const t = this.createKeyPrefix(e, this._namespace);
+                if (s) {
+                    r.set(t, i, {
+                        PX: s
+                    });
+                } else {
+                    r.set(t, i);
                 }
-                await r.exec();
             }
+            await r.exec();
         } catch (t) {
             this.emit("error", t);
-            if (this._throwOnConnectError && t.message === "Redis client is not connected or has failed to connect. This is thrown because throwOnConnectError is set to true.") {
-                throw t;
-            }
-            if (this._throwOnErrors) {
+            if (this._throwErrors) {
                 throw t;
             }
         }
@@ -301,45 +213,25 @@ var l = class extends r.Hookified {
             return r === 1;
         } catch (t) {
             this.emit("error", t);
-            if (this._throwOnErrors) {
+            if (this._throwErrors) {
                 throw t;
             }
             return false;
         }
     }
     async hasMany(t) {
+        const e = await this.getClient();
         try {
-            const e = t.map((t => this.createKeyPrefix(t, this._namespace)));
-            if (this.isCluster()) {
-                const t = this.getSlotMap(e);
-                const r = new Map;
-                await Promise.all(Array.from(t.entries(), (async ([t, e]) => {
-                    const s = await this.getSlotMaster(t);
-                    const i = s.multi();
-                    for (const t of e) {
-                        i.exists(t);
-                    }
-                    const n = await i.exec();
-                    for (const [t, s] of n.entries()) {
-                        r.set(e[t], typeof s === "number" && s === 1);
-                    }
-                })));
-                return e.map((t => r.get(t) ?? false));
-            } else {
-                const t = await this.getClient();
-                const r = t.multi();
-                for (const t of e) {
-                    r.exists(t);
-                }
-                const s = await r.exec();
-                return s.map((t => typeof t === "number" && t === 1));
+            const r = e.multi();
+            for (const e of t) {
+                const t = this.createKeyPrefix(e, this._namespace);
+                r.exists(t);
             }
+            const i = await r.exec();
+            return i.map((t => t === 1));
         } catch (e) {
             this.emit("error", e);
-            if (this._throwOnConnectError && e.message === "Redis client is not connected or has failed to connect. This is thrown because throwOnConnectError is set to true.") {
-                throw e;
-            }
-            if (this._throwOnErrors) {
+            if (this._throwErrors) {
                 throw e;
             }
             return Array.from({
@@ -358,7 +250,7 @@ var l = class extends r.Hookified {
             return r;
         } catch (t) {
             this.emit("error", t);
-            if (this._throwOnErrors) {
+            if (this._throwErrors) {
                 throw t;
             }
             return void 0;
@@ -374,7 +266,7 @@ var l = class extends r.Hookified {
             return e;
         } catch (e) {
             this.emit("error", e);
-            if (this._throwOnErrors) {
+            if (this._throwErrors) {
                 throw e;
             }
             return Array.from({
@@ -391,7 +283,7 @@ var l = class extends r.Hookified {
             return r > 0;
         } catch (t) {
             this.emit("error", t);
-            if (this._throwOnErrors) {
+            if (this._throwErrors) {
                 throw t;
             }
             return false;
@@ -399,50 +291,26 @@ var l = class extends r.Hookified {
     }
     async deleteMany(t) {
         let e = false;
+        const r = await this.getClient();
         try {
-            const r = t.map((t => this.createKeyPrefix(t, this._namespace)));
-            if (this.isCluster()) {
-                const t = this.getSlotMap(r);
-                await Promise.all(Array.from(t.entries(), (async ([t, r]) => {
-                    const s = await this.getSlotMaster(t);
-                    const i = s.multi();
-                    for (const t of r) {
-                        if (this._useUnlink) {
-                            i.unlink(t);
-                        } else {
-                            i.del(t);
-                        }
-                    }
-                    const n = await i.exec();
-                    for (const t of n) {
-                        if (typeof t === "number" && t > 0) {
-                            e = true;
-                        }
-                    }
-                })));
-            } else {
-                const t = await this.getClient();
-                const s = t.multi();
-                for (const t of r) {
-                    if (this._useUnlink) {
-                        s.unlink(t);
-                    } else {
-                        s.del(t);
-                    }
+            const i = r.multi();
+            for (const e of t) {
+                const t = this.createKeyPrefix(e, this._namespace);
+                if (this._useUnlink) {
+                    i.unlink(t);
+                } else {
+                    i.del(t);
                 }
-                const i = await s.exec();
-                for (const t of i) {
-                    if (typeof t === "number" && t > 0) {
-                        e = true;
-                    }
+            }
+            const s = await i.exec();
+            for (const t of s) {
+                if (typeof t === "number" && t > 0) {
+                    e = true;
                 }
             }
         } catch (t) {
             this.emit("error", t);
-            if (this._throwOnConnectError && t.message === "Redis client is not connected or has failed to connect. This is thrown because throwOnConnectError is set to true.") {
-                throw t;
-            }
-            if (this._throwOnErrors) {
+            if (this._throwErrors) {
                 throw t;
             }
         }
@@ -450,7 +318,7 @@ var l = class extends r.Hookified {
     }
     async disconnect(t) {
         if (this._client.isOpen) {
-            await (t ? this._client.destroy() : this._client.close());
+            await (t ? this._client.disconnect() : this._client.quit());
         }
     }
     createKeyPrefix(t, e) {
@@ -468,14 +336,10 @@ var l = class extends r.Hookified {
     isCluster() {
         return this.isClientCluster(this._client);
     }
-    isSentinel() {
-        return this.isClientSentinel(this._client);
-    }
     async getMasterNodes() {
         if (this.isCluster()) {
             const t = await this.getClient();
-            const e = t.masters.map((async e => t.nodeClient(e)));
-            return Promise.all(e);
+            return Promise.all(t.masters.map((async e => t.nodeClient(e))));
         }
         return [ await this.getClient() ];
     }
@@ -483,26 +347,26 @@ var l = class extends r.Hookified {
         const e = await this.getMasterNodes();
         for (const r of e) {
             const e = t ? `${t}${this._keyPrefixSeparator}*` : "*";
-            let s = "0";
+            let i = "0";
             do {
-                const i = await r.scan(s, {
+                const s = await r.scan(Number.parseInt(i, 10), {
                     MATCH: e,
                     TYPE: "string"
                 });
-                s = i.cursor.toString();
-                let {keys: n} = i;
+                i = s.cursor.toString();
+                let {keys: n} = s;
                 if (!t && !this._noNamespaceAffectsAll) {
                     n = n.filter((t => !t.includes(this._keyPrefixSeparator)));
                 }
                 if (n.length > 0) {
                     const e = await this.mget(n);
                     for (const r of n.keys()) {
-                        const s = this.getKeyWithoutPrefix(n[r], t);
-                        const i = e[r];
-                        yield [ s, i ];
+                        const i = this.getKeyWithoutPrefix(n[r], t);
+                        const s = e[r];
+                        yield [ i, s ];
                     }
                 }
-            } while (s !== "0");
+            } while (i !== "0");
         }
     }
     async clear() {
@@ -515,11 +379,11 @@ var l = class extends r.Hookified {
                 }
                 let e = "0";
                 const r = this._clearBatchSize;
-                const s = this._namespace ? `${this._namespace}${this._keyPrefixSeparator}*` : "*";
-                const i = [];
+                const i = this._namespace ? `${this._namespace}${this._keyPrefixSeparator}*` : "*";
+                const s = [];
                 do {
-                    const n = await t.scan(e, {
-                        MATCH: s,
+                    const n = await t.scan(Number.parseInt(e, 10), {
+                        MATCH: i,
                         COUNT: r,
                         TYPE: "string"
                     });
@@ -531,33 +395,25 @@ var l = class extends r.Hookified {
                     if (!this._namespace) {
                         o = o.filter((t => !t.includes(this._keyPrefixSeparator)));
                     }
-                    i.push(this.clearWithClusterSupport(o));
+                    s.push(this.clearWithClusterSupport(o));
                 } while (e !== "0");
-                await Promise.all(i);
+                await Promise.all(s);
             })));
         } catch (t) {
             this.emit("error", t);
         }
     }
     async mget(t) {
-        const e = new Map;
-        if (this.isCluster()) {
-            const r = this.getSlotMap(t);
-            await Promise.all(Array.from(r.entries(), (async ([t, r]) => {
-                const s = await this.getSlotMaster(t);
-                const i = await s.mGet(r);
-                for (const [t, s] of i.entries()) {
-                    e.set(r[t], s ?? void 0);
-                }
-            })));
-        } else {
-            const r = await this.getClient();
-            const s = await r.mGet(t);
-            for (const [r, i] of s.entries()) {
-                e.set(t[r], i ?? void 0);
+        const e = this.getSlotMap(t);
+        const r = new Map;
+        await Promise.all(Array.from(e.entries(), (async ([t, e]) => {
+            const i = await this.getSlotMaster(t);
+            const s = await i.mGet(e);
+            for (const [t, i] of s.entries()) {
+                r.set(e[t], i ?? void 0);
             }
-        }
-        return t.map((t => e.get(t)));
+        })));
+        return t.map((t => r.get(t)));
     }
     async clearWithClusterSupport(t) {
         if (t.length > 0) {
@@ -572,8 +428,8 @@ var l = class extends r.Hookified {
         const e = await this.getClient();
         if (this.isCluster()) {
             const r = e;
-            const s = r.slots[t].master;
-            return r.nodeClient(s);
+            const i = r.slots[t].master;
+            return r.nodeClient(i);
         }
         return e;
     }
@@ -582,9 +438,9 @@ var l = class extends r.Hookified {
         if (this.isCluster()) {
             for (const r of t) {
                 const t = n.default(r);
-                const s = e.get(t) ?? [];
-                s.push(r);
-                e.set(t, s);
+                const i = e.get(t) ?? [];
+                i.push(r);
+                e.set(t, i);
             }
         } else {
             e.set(0, t);
@@ -592,10 +448,10 @@ var l = class extends r.Hookified {
         return e;
     }
     isClientCluster(t) {
-        return t.slots !== void 0;
-    }
-    isClientSentinel(t) {
-        return t.getSentinelNode !== void 0;
+        if (t.options === void 0 && t.scan === void 0) {
+            return true;
+        }
+        return false;
     }
     setOptions(t) {
         if (!t) {
@@ -619,8 +475,8 @@ var l = class extends r.Hookified {
         if (t.throwOnConnectError !== void 0) {
             this._throwOnConnectError = t.throwOnConnectError;
         }
-        if (t.throwOnErrors !== void 0) {
-            this._throwOnErrors = t.throwOnErrors;
+        if (t.throwErrors !== void 0) {
+            this._throwErrors = t.throwErrors;
         }
         if (t.connectionTimeout !== void 0) {
             this._connectionTimeout = t.connectionTimeout;
@@ -644,6 +500,16 @@ var l = class extends r.Hookified {
     }
 };
 
+function h(t, e) {
+    t ??= "redis://localhost:6379";
+    const i = new c(t, e);
+    const s = new r.Keyv(i, {
+        namespace: e?.namespace,
+        useKeyPrefix: false
+    });
+    return s;
+}
+
 Object.defineProperty(exports, "createClient", {
     enumerable: true,
     get: () => t.createClient
@@ -654,19 +520,12 @@ Object.defineProperty(exports, "createCluster", {
     get: () => t.createCluster
 });
 
-Object.defineProperty(exports, "createSentinel", {
-    enumerable: true,
-    get: () => t.createSentinel
-});
-
-exports.Keyv = s.Keyv;
+exports.Keyv = r.Keyv;
 
 exports.RedisErrorMessages = o;
 
-exports.createKeyv = a;
-
-exports.createKeyvNonBlocking = h;
+exports.createKeyv = h;
 
-exports.default = l;
+exports.default = c;
 
-exports.defaultReconnectStrategy = c;
+exports.defaultReconnectStrategy = a;