lakutata 2.0.81 → 2.0.83

package/vendor/Package.68.mjs

@@ -1,73 +1,27 @@
-import { createClient as t, createSentinel as e, createCluster as s } from "@redis/client";
+import { createClient as t, createCluster as e } from "@redis/client";
 
-export { createClient, createCluster, createSentinel } from "@redis/client";
-
-import r from "cluster-key-slot";
+export { createClient, createCluster } from "@redis/client";
 
 import { H as i } from "./Package.66.mjs";
 
-import { K as n } from "./Package.67.mjs";
+import { K as r } from "./Package.67.mjs";
+
+import s from "cluster-key-slot";
 
 import "buffer";
 
-var o = (t => {
+var n = (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 || {});
+})(n || {});
 
-var a = t => {
+var o = t => {
     const e = Math.min(2 ** t * 100, 2e3);
-    const s = (Math.random() - .5) * 100;
-    return e + s;
+    const i = (Math.random() - .5) * 100;
+    return e + i;
 };
 
-function c(t, e) {
-    t ??= "redis://localhost:6379";
-    const s = new l(t, e);
-    if (e?.namespace) {
-        s.namespace = e.namespace;
-        const t = new n(s, {
-            namespace: e?.namespace,
-            useKeyPrefix: false
-        });
-        if (e?.throwOnConnectError) {
-            t.throwOnErrors = true;
-        }
-        if (e?.throwOnErrors) {
-            t.throwOnErrors = true;
-        }
-        return t;
-    }
-    const r = new n(s, {
-        useKeyPrefix: false
-    });
-    if (e?.throwOnConnectError) {
-        r.throwOnErrors = true;
-    }
-    if (e?.throwOnErrors) {
-        r.throwOnErrors = true;
-    }
-    r.namespace = void 0;
-    return r;
-}
-
-function h(t, e) {
-    const s = c(t, e);
-    const r = s.store;
-    r.throwOnConnectError = false;
-    r.throwOnErrors = false;
-    const i = r.client;
-    if (i.options) {
-        i.options.disableOfflineQueue = true;
-        if (i.options.socket) {
-            i.options.socket.reconnectStrategy = false;
-        }
-    }
-    s.throwOnErrors = false;
-    return s;
-}
-
-var l = class extends i {
+var a = class extends i {
     _client=t();
     _namespace;
     _keyPrefixSeparator="::";
@@ -75,38 +29,26 @@ var l = class extends i {
     _useUnlink=true;
     _noNamespaceAffectsAll=false;
     _throwOnConnectError=true;
-    _throwOnErrors=false;
+    _throwErrors=false;
     _connectionTimeout;
-    constructor(r, i) {
+    constructor(i, r) {
         super();
-        const n = {
-            reconnectStrategy: a
+        const s = {
+            reconnectStrategy: o
         };
-        if (r) {
-            if (typeof r === "string") {
+        if (i) {
+            if (typeof i === "string") {
                 this._client = t({
-                    url: r,
-                    socket: n
+                    url: i,
+                    socket: s
                 });
-            } else if (r.connect !== void 0) {
-                if (this.isClientSentinel(r)) {
-                    this._client = r;
-                } else if (this.isClientCluster(r)) {
-                    this._client = r;
-                } else {
-                    this._client = r;
-                }
-            } else if (r instanceof Object) {
-                if (r.sentinelRootNodes !== void 0) {
-                    this._client = e(r);
-                } else if (r.rootNodes === void 0) {
-                    this._client = t(r);
-                } else {
-                    this._client = s(r);
-                }
+            } else if (i.connect !== void 0) {
+                this._client = this.isClientCluster(i) ? i : i;
+            } else if (i instanceof Object) {
+                this._client = i.rootNodes === void 0 ? t(i) : e(i);
             }
         }
-        this.setOptions(i);
+        this.setOptions(r);
         this.initClient();
     }
     get client() {
@@ -131,7 +73,7 @@ var l = class extends i {
             noNamespaceAffectsAll: this._noNamespaceAffectsAll,
             useUnlink: this._useUnlink,
             throwOnConnectError: this._throwOnConnectError,
-            throwOnErrors: this._throwOnErrors,
+            throwErrors: this._throwErrors,
             connectionTimeout: this._connectionTimeout,
             dialect: "redis",
             url: t
@@ -181,11 +123,11 @@ var l = class extends i {
     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;
@@ -205,80 +147,50 @@ var l = class extends i {
             }
         } 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, s) {
+    async set(t, e, i) {
         const r = await this.getClient();
         try {
             t = this.createKeyPrefix(t, this._namespace);
-            if (s) {
+            if (i) {
                 await r.set(t, e, {
-                    PX: s
+                    PX: i
                 });
             } else {
                 await r.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 s of t) {
-                    const t = this.createKeyPrefix(s.key, this._namespace);
-                    const i = r(t);
-                    const n = e.get(i) ?? [];
-                    n.push(s);
-                    e.set(i, n);
-                }
-                await Promise.all(Array.from(e.entries(), (async ([t, e]) => {
-                    const s = await this.getSlotMaster(t);
-                    const r = s.multi();
-                    for (const {key: t, value: s, ttl: i} of e) {
-                        const e = this.createKeyPrefix(t, this._namespace);
-                        if (i) {
-                            r.set(e, s, {
-                                PX: i
-                            });
-                        } else {
-                            r.set(e, s);
-                        }
-                    }
-                    await r.exec();
-                })));
-            } else {
-                const e = await this.getClient();
-                const s = e.multi();
-                for (const {key: e, value: r, ttl: i} of t) {
-                    const t = this.createKeyPrefix(e, this._namespace);
-                    if (i) {
-                        s.set(t, r, {
-                            PX: i
-                        });
-                    } else {
-                        s.set(t, r);
-                    }
+            const i = e.multi();
+            for (const {key: e, value: r, ttl: s} of t) {
+                const t = this.createKeyPrefix(e, this._namespace);
+                if (s) {
+                    i.set(t, r, {
+                        PX: s
+                    });
+                } else {
+                    i.set(t, r);
                 }
-                await s.exec();
             }
+            await i.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;
             }
         }
@@ -287,49 +199,29 @@ var l = class extends i {
         const e = await this.getClient();
         try {
             t = this.createKeyPrefix(t, this._namespace);
-            const s = await e.exists(t);
-            return s === 1;
+            const i = await e.exists(t);
+            return i === 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 s = new Map;
-                await Promise.all(Array.from(t.entries(), (async ([t, e]) => {
-                    const r = await this.getSlotMaster(t);
-                    const i = r.multi();
-                    for (const t of e) {
-                        i.exists(t);
-                    }
-                    const n = await i.exec();
-                    for (const [t, r] of n.entries()) {
-                        s.set(e[t], typeof r === "number" && r === 1);
-                    }
-                })));
-                return e.map((t => s.get(t) ?? false));
-            } else {
-                const t = await this.getClient();
-                const s = t.multi();
-                for (const t of e) {
-                    s.exists(t);
-                }
-                const r = await s.exec();
-                return r.map((t => typeof t === "number" && t === 1));
+            const i = e.multi();
+            for (const e of t) {
+                const t = this.createKeyPrefix(e, this._namespace);
+                i.exists(t);
             }
+            const r = await i.exec();
+            return r.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({
@@ -341,14 +233,14 @@ var l = class extends i {
         const e = await this.getClient();
         try {
             t = this.createKeyPrefix(t, this._namespace);
-            const s = await e.get(t);
-            if (s === null) {
+            const i = await e.get(t);
+            if (i === null) {
                 return void 0;
             }
-            return s;
+            return i;
         } catch (t) {
             this.emit("error", t);
-            if (this._throwOnErrors) {
+            if (this._throwErrors) {
                 throw t;
             }
             return void 0;
@@ -364,7 +256,7 @@ var l = class extends i {
             return e;
         } catch (e) {
             this.emit("error", e);
-            if (this._throwOnErrors) {
+            if (this._throwErrors) {
                 throw e;
             }
             return Array.from({
@@ -376,12 +268,12 @@ var l = class extends i {
         const e = await this.getClient();
         try {
             t = this.createKeyPrefix(t, this._namespace);
-            let s = 0;
-            s = await (this._useUnlink ? e.unlink(t) : e.del(t));
-            return s > 0;
+            let i = 0;
+            i = await (this._useUnlink ? e.unlink(t) : e.del(t));
+            return i > 0;
         } catch (t) {
             this.emit("error", t);
-            if (this._throwOnErrors) {
+            if (this._throwErrors) {
                 throw t;
             }
             return false;
@@ -389,50 +281,26 @@ var l = class extends i {
     }
     async deleteMany(t) {
         let e = false;
+        const i = await this.getClient();
         try {
-            const s = t.map((t => this.createKeyPrefix(t, this._namespace)));
-            if (this.isCluster()) {
-                const t = this.getSlotMap(s);
-                await Promise.all(Array.from(t.entries(), (async ([t, s]) => {
-                    const r = await this.getSlotMaster(t);
-                    const i = r.multi();
-                    for (const t of s) {
-                        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 r = t.multi();
-                for (const t of s) {
-                    if (this._useUnlink) {
-                        r.unlink(t);
-                    } else {
-                        r.del(t);
-                    }
+            const r = i.multi();
+            for (const e of t) {
+                const t = this.createKeyPrefix(e, this._namespace);
+                if (this._useUnlink) {
+                    r.unlink(t);
+                } else {
+                    r.del(t);
                 }
-                const i = await r.exec();
-                for (const t of i) {
-                    if (typeof t === "number" && t > 0) {
-                        e = true;
-                    }
+            }
+            const s = await r.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;
             }
         }
@@ -440,7 +308,7 @@ var l = class extends i {
     }
     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) {
@@ -458,38 +326,34 @@ var l = class extends i {
     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() ];
     }
     async* iterator(t) {
         const e = await this.getMasterNodes();
-        for (const s of e) {
+        for (const i of e) {
             const e = t ? `${t}${this._keyPrefixSeparator}*` : "*";
             let r = "0";
             do {
-                const i = await s.scan(r, {
+                const s = await i.scan(Number.parseInt(r, 10), {
                     MATCH: e,
                     TYPE: "string"
                 });
-                r = i.cursor.toString();
-                let {keys: n} = i;
+                r = 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 s of n.keys()) {
-                        const r = this.getKeyWithoutPrefix(n[s], t);
-                        const i = e[s];
-                        yield [ r, i ];
+                    for (const i of n.keys()) {
+                        const r = this.getKeyWithoutPrefix(n[i], t);
+                        const s = e[i];
+                        yield [ r, s ];
                     }
                 }
             } while (r !== "0");
@@ -504,13 +368,13 @@ var l = class extends i {
                     return;
                 }
                 let e = "0";
-                const s = this._clearBatchSize;
+                const i = this._clearBatchSize;
                 const r = this._namespace ? `${this._namespace}${this._keyPrefixSeparator}*` : "*";
-                const i = [];
+                const s = [];
                 do {
-                    const n = await t.scan(e, {
+                    const n = await t.scan(Number.parseInt(e, 10), {
                         MATCH: r,
-                        COUNT: s,
+                        COUNT: i,
                         TYPE: "string"
                     });
                     e = n.cursor.toString();
@@ -521,60 +385,52 @@ var l = class extends i {
                     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 s = this.getSlotMap(t);
-            await Promise.all(Array.from(s.entries(), (async ([t, s]) => {
-                const r = await this.getSlotMaster(t);
-                const i = await r.mGet(s);
-                for (const [t, r] of i.entries()) {
-                    e.set(s[t], r ?? void 0);
-                }
-            })));
-        } else {
-            const s = await this.getClient();
-            const r = await s.mGet(t);
-            for (const [s, i] of r.entries()) {
-                e.set(t[s], i ?? void 0);
+        const e = this.getSlotMap(t);
+        const i = new Map;
+        await Promise.all(Array.from(e.entries(), (async ([t, e]) => {
+            const r = await this.getSlotMaster(t);
+            const s = await r.mGet(e);
+            for (const [t, r] of s.entries()) {
+                i.set(e[t], r ?? void 0);
             }
-        }
-        return t.map((t => e.get(t)));
+        })));
+        return t.map((t => i.get(t)));
     }
     async clearWithClusterSupport(t) {
         if (t.length > 0) {
             const e = this.getSlotMap(t);
             await Promise.all(Array.from(e.entries(), (async ([t, e]) => {
-                const s = await this.getSlotMaster(t);
-                return this._useUnlink ? s.unlink(e) : s.del(e);
+                const i = await this.getSlotMaster(t);
+                return this._useUnlink ? i.unlink(e) : i.del(e);
             })));
         }
     }
     async getSlotMaster(t) {
         const e = await this.getClient();
         if (this.isCluster()) {
-            const s = e;
-            const r = s.slots[t].master;
-            return s.nodeClient(r);
+            const i = e;
+            const r = i.slots[t].master;
+            return i.nodeClient(r);
         }
         return e;
     }
     getSlotMap(t) {
         const e = new Map;
         if (this.isCluster()) {
-            for (const s of t) {
-                const t = r(s);
-                const i = e.get(t) ?? [];
-                i.push(s);
-                e.set(t, i);
+            for (const i of t) {
+                const t = s(i);
+                const r = e.get(t) ?? [];
+                r.push(i);
+                e.set(t, r);
             }
         } else {
             e.set(0, t);
@@ -582,10 +438,10 @@ var l = class extends i {
         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) {
@@ -609,8 +465,8 @@ var l = class extends i {
         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;
@@ -628,10 +484,20 @@ var l = class extends i {
         }));
     }
     async createTimeoutPromise(t) {
-        return new Promise(((e, s) => setTimeout((() => {
-            s(new Error(`Redis timed out after ${t}ms`));
+        return new Promise(((e, i) => setTimeout((() => {
+            i(new Error(`Redis timed out after ${t}ms`));
         }), t)));
     }
 };
 
-export { n as Keyv, o as RedisErrorMessages, c as createKeyv, h as createKeyvNonBlocking, l as default, a as defaultReconnectStrategy };
+function c(t, e) {
+    t ??= "redis://localhost:6379";
+    const i = new a(t, e);
+    const s = new r(i, {
+        namespace: e?.namespace,
+        useKeyPrefix: false
+    });
+    return s;
+}
+
+export { r as Keyv, n as RedisErrorMessages, c as createKeyv, a as default, o as defaultReconnectStrategy };