lakutata 2.0.81 → 2.0.82

package/src/components/cacher/Cacher.mjs

@@ -22,9 +22,9 @@ import { CreateMongoCacheAdapter as m } from "./adapters/CreateMongoCacheAdapter
 
 import { CreateSqliteCacheAdapter as u } from "./adapters/CreateSqliteCacheAdapter.mjs";
 
-import { CreatePostgresCacheAdapter as f } from "./adapters/CreatePostgresCacheAdapter.mjs";
+import { CreatePostgresCacheAdapter as d } from "./adapters/CreatePostgresCacheAdapter.mjs";
 
-import { CreateMysqlCacheAdapter as d } from "./adapters/CreateMysqlCacheAdapter.mjs";
+import { CreateMysqlCacheAdapter as f } from "./adapters/CreateMysqlCacheAdapter.mjs";
 
 import { D as p } from "../../../vendor/Package.2.mjs";
 
@@ -306,7 +306,7 @@ var x = class {
     }
 };
 
-var P = class {
+var C = class {
     _seed;
     constructor(e = 0) {
         this._seed = e >>> 0;
@@ -388,7 +388,7 @@ var P = class {
     }
 };
 
-var z = class {
+var P = class {
     _providers=new Map;
     _getFuzzy=true;
     constructor(e) {
@@ -435,10 +435,10 @@ var z = class {
     }
 };
 
-var C = class extends s {
+var z = class extends s {
     _parse=JSON.parse;
     _stringify=JSON.stringify;
-    _providers=new z;
+    _providers=new P;
     _defaultAlgorithm="SHA-256";
     _defaultAlgorithmSync="djb2";
     constructor(e) {
@@ -599,12 +599,12 @@ var C = class extends s {
             this.providers.add(new S);
             this.providers.add(new k);
             this.providers.add(new x);
-            this.providers.add(new P);
+            this.providers.add(new C);
         }
     }
 };
 
-var H = e => {
+var shorthandToMilliseconds = e => {
     let t;
     if (e === void 0) {
         return void 0;
@@ -673,58 +673,58 @@ var H = e => {
     return t;
 };
 
-var O = (e, t) => {
+var shorthandToTime = (e, t) => {
     t ??= new Date;
-    const r = H(e);
+    const r = shorthandToMilliseconds(e);
     if (r === void 0) {
         return t.getTime();
     }
     return t.getTime() + r;
 };
 
-var L = new Map;
+var H = new Map;
 
-function M(e) {
-    return L.has(e);
+function hasKey(e) {
+    return H.has(e);
 }
 
-function I(e) {
-    L.set(e, []);
+function addKey(e) {
+    H.set(e, []);
 }
 
-function N(e) {
-    L.delete(e);
+function removeKey(e) {
+    H.delete(e);
 }
 
-function E(e, t) {
-    const r = U(e);
+function addCallbackToKey(e, t) {
+    const r = getCallbacksByKey(e);
     r.push(t);
-    L.set(e, r);
+    H.set(e, r);
 }
 
-function U(e) {
-    return L.get(e) ?? [];
+function getCallbacksByKey(e) {
+    return H.get(e) ?? [];
 }
 
-async function B(e) {
+async function enqueue(e) {
     return new Promise(((t, r) => {
         const s = {
             resolve: t,
             reject: r
         };
-        E(e, s);
+        addCallbackToKey(e, s);
     }));
 }
 
-function D(e) {
-    const t = U(e);
-    N(e);
+function dequeue(e) {
+    const t = getCallbacksByKey(e);
+    removeKey(e);
     return t;
 }
 
-function $(e) {
+function coalesce(e) {
     const {key: t, error: r, result: s} = e;
-    for (const e of D(t)) {
+    for (const e of dequeue(t)) {
         if (r) {
             e.reject(r);
         } else {
@@ -733,28 +733,28 @@ function $(e) {
     }
 }
 
-async function T(e, t) {
-    if (!M(e)) {
-        I(e);
+async function coalesceAsync(e, t) {
+    if (!hasKey(e)) {
+        addKey(e);
         try {
             const r = await Promise.resolve(t());
-            $({
+            coalesce({
                 key: e,
                 result: r
             });
             return r;
         } catch (t) {
-            $({
+            coalesce({
                 key: e,
                 error: t
             });
             throw t;
         }
     }
-    return B(e);
+    return enqueue(e);
 }
 
-var F = (e => {
+var O = (e => {
     e["SHA256"] = "SHA-256";
     e["SHA384"] = "SHA-384";
     e["SHA512"] = "SHA-512";
@@ -763,35 +763,35 @@ var F = (e => {
     e["MURMER"] = "murmer";
     e["CRC32"] = "crc32";
     return e;
-})(F || {});
+})(O || {});
 
-async function V(e, t = {
+async function hash(e, t = {
     algorithm: "SHA-256",
     serialize: JSON.stringify
 }) {
     const r = t?.algorithm ?? "SHA-256";
     const s = t?.serialize ?? JSON.stringify;
     const i = s(e);
-    const n = new C;
+    const n = new z;
     return n.toHash(i, {
         algorithm: r
     });
 }
 
-function J(e, t = {
+function hashSync(e, t = {
     algorithm: "djb2",
     serialize: JSON.stringify
 }) {
     const r = t?.algorithm ?? "djb2";
     const s = t?.serialize ?? JSON.stringify;
     const i = s(e);
-    const n = new C;
+    const n = new z;
     return n.toHashSync(i, {
         algorithm: r
     });
 }
 
-async function R(e, t = {
+async function hashToNumber(e, t = {
     min: 0,
     max: 10,
     algorithm: "SHA-256",
@@ -806,7 +806,7 @@ async function R(e, t = {
         throw new Error(`Invalid range: min (${r}) must be less than max (${s})`);
     }
     const a = n(e);
-    const c = new C;
+    const c = new z;
     return c.toNumber(a, {
         algorithm: i,
         min: r,
@@ -815,7 +815,7 @@ async function R(e, t = {
     });
 }
 
-function K(e, t = {
+function hashToNumberSync(e, t = {
     min: 0,
     max: 10,
     algorithm: "djb2",
@@ -830,7 +830,7 @@ function K(e, t = {
         throw new Error(`Invalid range: min (${r}) must be less than max (${s})`);
     }
     const a = n(e);
-    const c = new C;
+    const c = new z;
     return c.toNumberSync(a, {
         algorithm: i,
         min: r,
@@ -839,7 +839,7 @@ function K(e, t = {
     });
 }
 
-function q(e) {
+function isKeyvInstance(e) {
     if (e === null || e === void 0) {
         return false;
     }
@@ -850,18 +850,18 @@ function q(e) {
     return t.every((t => typeof e[t] === "function"));
 }
 
-function G(e) {
+function isObject(e) {
     return e !== null && typeof e === "object" && !Array.isArray(e);
 }
 
-function W(e, t) {
+function lessThan(e, t) {
     return typeof e === "number" && typeof t === "number" ? e < t : false;
 }
 
-function X(e, t) {
+function wrapSync(e, t) {
     const {ttl: r, keyPrefix: s, cache: i, serialize: n} = t;
     return (...o) => {
-        let a = Z(e, o, {
+        let a = createWrapKey(e, o, {
             keyPrefix: s,
             serialize: n
         });
@@ -884,13 +884,13 @@ function X(e, t) {
     };
 }
 
-async function Q(e, t, r) {
+async function getOrSet(e, t, r) {
     const s = typeof e === "function" ? e(r) : e;
     let i = await r.cache.get(s);
     if (i === void 0) {
         const e = r.cacheId ?? "default";
         const n = `${e}::${s}`;
-        i = await T(n, (async () => {
+        i = await coalesceAsync(n, (async () => {
             try {
                 const e = await t();
                 await r.cache.set(s, e, r.ttl);
@@ -909,39 +909,39 @@ async function Q(e, t, r) {
     return i;
 }
 
-function Y(e, t) {
+function wrap(e, t) {
     const {keyPrefix: r, serialize: s} = t;
     return async (...i) => {
-        let n = Z(e, i, {
+        let n = createWrapKey(e, i, {
             keyPrefix: r,
             serialize: s
         });
         if (t.createKey) {
             n = t.createKey(e, i, t);
         }
-        return Q(n, (async () => e(...i)), t);
+        return getOrSet(n, (async () => e(...i)), t);
     };
 }
 
-function Z(e, t, r) {
+function createWrapKey(e, t, r) {
     const {keyPrefix: s, serialize: i} = r || {};
     if (!s) {
-        return `${e.name}::${J(t, {
+        return `${e.name}::${hashSync(t, {
             serialize: i
         })}`;
     }
-    return `${s}::${e.name}::${J(t, {
+    return `${s}::${e.name}::${hashSync(t, {
         serialize: i
     })}`;
 }
 
-function ee(e, ...t) {
+function runIfFn(e, ...t) {
     return typeof e === "function" ? e(...t) : e;
 }
 
-var te = async e => new Promise((t => setTimeout(t, e)));
+var sleep = async e => new Promise((t => setTimeout(t, e)));
 
-var re = class {
+var L = class {
     _hits=0;
     _misses=0;
     _gets=0;
@@ -1118,7 +1118,7 @@ var re = class {
     }
 };
 
-function se(e) {
+function getTtlFromExpires(e) {
     if (e === void 0 || e === null) {
         return void 0;
     }
@@ -1129,12 +1129,12 @@ function se(e) {
     return e - t;
 }
 
-function ie(e, t, r) {
-    return r ?? t ?? H(e);
+function getCascadingTtl(e, t, r) {
+    return r ?? t ?? shorthandToMilliseconds(e);
 }
 
-function ne(e, t) {
-    const r = se(t);
+function calculateTtlFromExpiration(e, t) {
+    const r = getTtlFromExpires(t);
     const s = e ? Date.now() + e : void 0;
     if (r === void 0) {
         return e;
@@ -1148,7 +1148,7 @@ function ne(e, t) {
     return r;
 }
 
-var oe = class {
+var I = class {
     opts;
     namespace;
     _cache;
@@ -1196,9 +1196,9 @@ var oe = class {
     }
 };
 
-var ae = e => e === 0 ? "primary" : `secondary:${e - 1}`;
+var _storeLabel = e => e === 0 ? "primary" : `secondary:${e - 1}`;
 
-var ce = e => {
+var createCache = e => {
     const t = new r;
     const s = new i;
     s.serialize = void 0;
@@ -1206,7 +1206,7 @@ var ce = e => {
     const n = e?.stores?.length ? e.stores : [ s ];
     const o = e?.nonBlocking ?? false;
     const a = e?.cacheId ?? Math.random().toString(36).slice(2);
-    const c = async e => {
+    const get = async e => {
         let r;
         if (o) {
             try {
@@ -1230,7 +1230,7 @@ var ce = e => {
                         t.emit("get", {
                             key: e,
                             value: r,
-                            store: ae(s)
+                            store: _storeLabel(s)
                         });
                         break;
                     }
@@ -1238,14 +1238,14 @@ var ce = e => {
                     t.emit("get", {
                         key: e,
                         error: r,
-                        store: ae(s)
+                        store: _storeLabel(s)
                     });
                 }
             }
         }
         return r;
     };
-    const l = async e => {
+    const mget = async e => {
         let r = e.map((() => void 0));
         if (o) {
             try {
@@ -1289,7 +1289,7 @@ var ce = e => {
         });
         return r;
     };
-    const h = async e => {
+    const ttl = async e => {
         let r;
         if (o) {
             try {
@@ -1332,14 +1332,14 @@ var ce = e => {
         }
         return void 0;
     };
-    const m = async (r, s, i, n) => {
+    const set = async (r, s, i, n) => {
         try {
             const a = r.map((async (r, o) => {
                 await r.set(s, i, n ?? e?.ttl);
                 t.emit("set", {
                     key: s,
                     value: i,
-                    store: ae(o)
+                    store: _storeLabel(o)
                 });
             }));
             if (o) {
@@ -1365,7 +1365,7 @@ var ce = e => {
             return Promise.reject(e);
         }
     };
-    const u = async (r, s) => {
+    const mset = async (r, s) => {
         const i = s.map((({key: t, value: r, ttl: s}) => ({
             key: t,
             value: r,
@@ -1393,7 +1393,7 @@ var ce = e => {
             return Promise.reject(e);
         }
     };
-    const f = async e => {
+    const del = async e => {
         try {
             if (o) {
                 Promise.all(n.map((async t => t.delete(e))));
@@ -1415,7 +1415,7 @@ var ce = e => {
             return Promise.reject(r);
         }
     };
-    const d = async e => {
+    const mdel = async e => {
         try {
             const r = [];
             for (const t of e) {
@@ -1441,7 +1441,7 @@ var ce = e => {
             return Promise.reject(r);
         }
     };
-    const p = async () => {
+    const clear = async () => {
         try {
             if (o) {
                 Promise.all(n.map((async e => e.clear())));
@@ -1456,16 +1456,16 @@ var ce = e => {
             return Promise.reject(e);
         }
     };
-    const y = async (r, s, i, o) => T(`${a}::${r}`, (async () => {
+    const wrap = async (r, s, i, o) => coalesceAsync(`${a}::${r}`, (async () => {
         let c;
         let l;
         let h = 0;
-        let u;
-        const {ttl: f, refreshThreshold: d, raw: p} = G(i) ? i : {
+        let m;
+        const {ttl: u, refreshThreshold: d, raw: f} = isObject(i) ? i : {
             ttl: i,
             refreshThreshold: o
         };
-        const y = t => ee(f, t) ?? e?.ttl;
+        const resolveTtl = t => runIfFn(u, t) ?? e?.ttl;
         for (;h < n.length; h++) {
             try {
                 const e = await n[h].get(r, {
@@ -1475,7 +1475,7 @@ var ce = e => {
                     c = e.value;
                     l = e;
                     if (typeof e.expires === "number") {
-                        u = Math.max(0, e.expires - Date.now());
+                        m = Math.max(0, e.expires - Date.now());
                     }
                     break;
                 }
@@ -1483,18 +1483,18 @@ var ce = e => {
         }
         if (c === void 0) {
             const e = await s();
-            const t = y(e);
-            await m(n, r, e, t);
-            return p ? {
+            const t = resolveTtl(e);
+            await set(n, r, e, t);
+            return f ? {
                 value: e,
                 expires: Date.now() + t
             } : e;
         }
-        const g = W(u, ee(d, c) ?? e?.refreshThreshold);
-        if (g) {
-            T(`+++${a}__${r}`, s).then((async s => {
+        const p = lessThan(m, runIfFn(d, c) ?? e?.refreshThreshold);
+        if (p) {
+            coalesceAsync(`+++${a}__${r}`, s).then((async s => {
                 try {
-                    await m(e?.refreshAllStores ? n : n.slice(0, h + 1), r, s, y(s));
+                    await set(e?.refreshAllStores ? n : n.slice(0, h + 1), r, s, resolveTtl(s));
                     t.emit("refresh", {
                         key: r,
                         value: s
@@ -1514,40 +1514,40 @@ var ce = e => {
                 });
             }));
         }
-        if (!g && h > 0) {
-            await m(n.slice(0, h), r, c, y(c));
+        if (!p && h > 0) {
+            await set(n.slice(0, h), r, c, resolveTtl(c));
         }
-        return p ? l : c;
+        return f ? l : c;
     }));
-    const g = (e, r) => t.addListener(e, r);
-    const b = (e, r) => t.removeListener(e, r);
-    const v = async () => {
+    const on = (e, r) => t.addListener(e, r);
+    const off = (e, r) => t.removeListener(e, r);
+    const disconnect = async () => {
         try {
             await Promise.all(n.map((async e => e.disconnect())));
         } catch (e) {
             return Promise.reject(e);
         }
     };
-    const _ = () => a;
+    const cacheId = () => a;
     return {
-        get: c,
-        mget: l,
-        ttl: h,
-        set: async (e, t, r) => m(n, e, t, r),
-        mset: async e => u(n, e),
-        del: f,
-        mdel: d,
-        clear: p,
-        wrap: y,
-        on: g,
-        off: b,
-        disconnect: v,
-        cacheId: _,
+        get,
+        mget,
+        ttl,
+        set: async (e, t, r) => set(n, e, t, r),
+        mset: async e => mset(n, e),
+        del,
+        mdel,
+        clear,
+        wrap,
+        on,
+        off,
+        disconnect,
+        cacheId,
         stores: n
     };
 };
 
-const le = e => ({
+const BuildCacherOptions = e => ({
     class: Cacher,
     stores: e?.stores,
     ttl: e?.ttl,
@@ -1578,17 +1578,17 @@ class Cacher extends n {
                 return u(e);
 
               case "postgres":
-                return f(e);
+                return d(e);
 
               case "mysql":
-                return d(e);
+                return f(e);
 
               default:
                 return undefined;
             }
         })));
         const r = t.filter((e => !!e));
-        this.cache = ce({
+        this.cache = createCache({
             stores: r.length ? r : undefined,
             ttl: this.ttl,
             refreshThreshold: this.refreshThreshold,
@@ -1647,4 +1647,4 @@ e([ o(p.Boolean().optional()), t("design:type", Boolean) ], Cacher.prototype, "n
 
 e([ o(p.String().optional()), t("design:type", String) ], Cacher.prototype, "cacheId", void 0);
 
-export { le as BuildCacherOptions, Cacher };
+export { BuildCacherOptions, Cacher };