lakutata 2.0.34 → 2.0.36

package/src/components/cacher/Cacher.cjs

@@ -0,0 +1,734 @@
+"use strict";
+
+Object.defineProperty(exports, Symbol.toStringTag, {
+    value: "Module"
+});
+
+const e = require("../../../vendor/Package.1.cjs");
+
+const r = require("events");
+
+const t = require("../../../vendor/Package.65.cjs");
+
+const s = require("./options/CacherOptions.cjs");
+
+const i = require("../../lib/core/Component.cjs");
+
+const c = require("../../decorators/di/Configurable.cjs");
+
+const a = require("../../lib/helpers/As.cjs");
+
+const n = require("./adapters/CreateFileCacheAdapter.cjs");
+
+const o = require("./adapters/CreateRedisCacheAdapter.cjs");
+
+const u = require("./adapters/CreateMemcacheCacheAdapter.cjs");
+
+const l = require("./adapters/CreateMongoCacheAdapter.cjs");
+
+const h = require("./adapters/CreateSqliteCacheAdapter.cjs");
+
+const d = require("./adapters/CreatePostgresCacheAdapter.cjs");
+
+const p = require("./adapters/CreateMysqlCacheAdapter.cjs");
+
+require("buffer");
+
+require("../../../vendor/Package.2.cjs");
+
+require("../../lib/base/internal/DataValidator.cjs");
+
+require("../../../vendor/Package.4.cjs");
+
+require("../../../vendor/Package.5.cjs");
+
+require("node:util/types");
+
+require("../../lib/validation/VLD.cjs");
+
+require("../../../vendor/Package.11.cjs");
+
+require("url");
+
+require("../../../vendor/Package.10.cjs");
+
+require("util");
+
+require("../../exceptions/dto/InvalidValueException.cjs");
+
+require("../../lib/base/abstracts/Exception.cjs");
+
+require("../../lib/base/internal/BasicInfo.cjs");
+
+require("../../../vendor/Package.6.cjs");
+
+require("../../../vendor/Package.7.cjs");
+
+require("../../lib/base/internal/ThrowWarning.cjs");
+
+require("../../lib/helpers/Templating.cjs");
+
+require("../../lib/base/internal/CamelCase.cjs");
+
+require("../../lib/helpers/NoCase.cjs");
+
+require("../../../vendor/Package.9.cjs");
+
+require("../../lib/helpers/IsHtml.cjs");
+
+require("../../lib/helpers/IsXML.cjs");
+
+require("../../constants/DTOMetadataKey.cjs");
+
+require("../../lib/helpers/ObjectConstructor.cjs");
+
+require("../../lib/helpers/ObjectParentConstructors.cjs");
+
+require("../../lib/helpers/ObjectParentConstructor.cjs");
+
+require("../../lib/helpers/ObjectPrototype.cjs");
+
+require("../../decorators/dto/Expect.cjs");
+
+require("./options/FileCacheOptions.cjs");
+
+require("./options/MemcacheCacheOptions.cjs");
+
+require("./options/MongoCacheOptions.cjs");
+
+require("./options/PostgresCacheOptions.cjs");
+
+require("./options/MysqlCacheOptions.cjs");
+
+require("./options/SqliteCacheOptions.cjs");
+
+require("./options/RedisCacheOptions.cjs");
+
+require("../../../vendor/Package.3.cjs");
+
+require("../../lib/base/async-constructor/AsyncConstructor.cjs");
+
+require("../../lib/base/async-constructor/Append.cjs");
+
+require("../../lib/helpers/IsPromiseLike.cjs");
+
+require("../../lib/helpers/IsPromise.cjs");
+
+require("util/types");
+
+require("../../decorators/di/Lifetime.cjs");
+
+require("../../lib/base/internal/ObjectLifetime.cjs");
+
+require("../../constants/DIMetadataKey.cjs");
+
+require("../../exceptions/di/LifetimeLockedException.cjs");
+
+require("../../exceptions/MethodNotFoundException.cjs");
+
+require("../../lib/ioc/DependencyInjectionContainer.cjs");
+
+require("../../lib/ioc/Errors.cjs");
+
+require("../../exceptions/di/DependencyInjectionException.cjs");
+
+require("../../lib/base/internal/ConstructorSymbol.cjs");
+
+require("node:crypto");
+
+require("../../lib/ioc/InjectionMode.cjs");
+
+require("../../lib/ioc/Lifetime.cjs");
+
+require("../../lib/ioc/ListModules.cjs");
+
+require("../../../vendor/Package.8.cjs");
+
+require("os");
+
+require("path");
+
+require("stream");
+
+require("fs");
+
+require("../../lib/ioc/Utils.cjs");
+
+require("../../lib/ioc/FunctionTokenizer.cjs");
+
+require("../../lib/ioc/LoadModules.cjs");
+
+require("../../lib/ioc/Resolvers.cjs");
+
+require("../../lib/ioc/ParamParser.cjs");
+
+require("../../lib/base/internal/ObjectWeakRefs.cjs");
+
+require("../../lib/base/internal/ConfigurableRecordsInjection.cjs");
+
+require("../../lib/base/internal/ObjectConfiguration.cjs");
+
+require("../../lib/base/internal/ObjectInjection.cjs");
+
+require("../../lib/base/internal/ObjectContainer.cjs");
+
+require("../../lib/helpers/DevNull.cjs");
+
+require("../../decorators/dto/IndexSignature.cjs");
+
+require("../../decorators/dto/Accept.cjs");
+
+require("../../lib/base/internal/MethodValidation.cjs");
+
+require("../../exceptions/dto/InvalidMethodAcceptException.cjs");
+
+require("../../exceptions/dto/InvalidMethodReturnException.cjs");
+
+require("../../lib/helpers/IsEmptyObject.cjs");
+
+require("../../lib/base/EventEmitter.cjs");
+
+require("../../lib/core/Provider.cjs");
+
+require("../../../vendor/Package.13.cjs");
+
+require("../../../vendor/Package.19.cjs");
+
+require("constants");
+
+require("../../../vendor/Package.17.cjs");
+
+require("assert");
+
+require("../../../vendor/Package.14.cjs");
+
+require("../../lib/helpers/URLBuilder.cjs");
+
+const y = e => e && e.__esModule ? e : {
+    default: e
+};
+
+const m = y(r);
+
+var j = new Map;
+
+function q(e) {
+    return j.has(e);
+}
+
+function f(e) {
+    j.set(e, []);
+}
+
+function b(e) {
+    j.delete(e);
+}
+
+function v(e, r) {
+    const t = C(e);
+    t.push(r);
+    j.set(e, t);
+}
+
+function C(e) {
+    return j.get(e) ?? [];
+}
+
+async function g(e) {
+    return new Promise(((r, t) => {
+        const s = {
+            resolve: r,
+            reject: t
+        };
+        v(e, s);
+    }));
+}
+
+function P(e) {
+    const r = C(e);
+    b(e);
+    return r;
+}
+
+function k(e) {
+    const {key: r, error: t, result: s} = e;
+    for (const e of P(r)) {
+        if (t) {
+            e.reject(t);
+        } else {
+            e.resolve(s);
+        }
+    }
+}
+
+async function w(e, r) {
+    if (!q(e)) {
+        f(e);
+        try {
+            const t = await Promise.resolve(r());
+            k({
+                key: e,
+                result: t
+            });
+            return t;
+        } catch (r) {
+            k({
+                key: e,
+                error: r
+            });
+            throw r;
+        }
+    }
+    return g(e);
+}
+
+function M(e) {
+    return e !== null && typeof e === "object" && !Array.isArray(e);
+}
+
+function x(e, ...r) {
+    return typeof e === "function" ? e(...r) : e;
+}
+
+function A(e, r) {
+    return typeof e === "number" && typeof r === "number" ? e < r : false;
+}
+
+var O = class {
+    opts;
+    namespace;
+    _cache;
+    constructor(e) {
+        this._cache = e;
+    }
+    async get(e) {
+        const r = await this._cache.get(e);
+        if (r !== void 0 && r !== null) {
+            return r;
+        }
+        return void 0;
+    }
+    async set(e, r, t) {
+        await this._cache.set(e, r, t);
+        return true;
+    }
+    async delete(e) {
+        await this._cache.del(e);
+        return true;
+    }
+    async clear() {
+        return this._cache.reset?.();
+    }
+    async has(e) {
+        const r = await this._cache.get(e);
+        if (r) {
+            return true;
+        }
+        return false;
+    }
+    async getMany(e) {
+        return this._cache.mget(...e).then((e => e.map((e => e))));
+    }
+    async deleteMany(e) {
+        await this._cache.mdel(...e);
+        return true;
+    }
+    on(e, r) {
+        this._cache.on?.(e, r);
+        return this;
+    }
+    async disconnect() {
+        await (this._cache.disconnect?.());
+    }
+};
+
+var _ = e => {
+    const r = new m.default;
+    const s = new t.Keyv;
+    s.serialize = void 0;
+    s.deserialize = void 0;
+    const i = e?.stores?.length ? e.stores : [ s ];
+    const c = e?.nonBlocking ?? false;
+    const a = e?.cacheId ?? Math.random().toString(36).slice(2);
+    const n = async e => {
+        let t;
+        if (c) {
+            try {
+                t = await Promise.race(i.map((async r => r.get(e))));
+                if (t === void 0) {
+                    return void 0;
+                }
+            } catch (t) {
+                r.emit("get", {
+                    key: e,
+                    error: t
+                });
+            }
+        } else {
+            for (const s of i) {
+                try {
+                    const i = await s.get(e);
+                    if (i !== void 0) {
+                        t = i;
+                        r.emit("get", {
+                            key: e,
+                            value: t
+                        });
+                        break;
+                    }
+                } catch (t) {
+                    r.emit("get", {
+                        key: e,
+                        error: t
+                    });
+                }
+            }
+        }
+        return t;
+    };
+    const o = async e => {
+        const r = [];
+        for (const t of e) {
+            const e = await n(t);
+            r.push(e);
+        }
+        return r;
+    };
+    const u = async e => {
+        let t;
+        if (c) {
+            try {
+                t = await Promise.race(i.map((async r => r.get(e, {
+                    raw: true
+                }))));
+                if (t === void 0) {
+                    return void 0;
+                }
+            } catch (t) {
+                r.emit("ttl", {
+                    key: e,
+                    error: t
+                });
+            }
+        } else {
+            for (const s of i) {
+                try {
+                    const i = await s.get(e, {
+                        raw: true
+                    });
+                    if (i !== void 0) {
+                        t = i;
+                        r.emit("ttl", {
+                            key: e,
+                            value: t
+                        });
+                        break;
+                    }
+                } catch (t) {
+                    r.emit("ttl", {
+                        key: e,
+                        error: t
+                    });
+                }
+            }
+        }
+        if (t?.expires) {
+            return t.expires;
+        }
+        return void 0;
+    };
+    const l = async (t, s, i, a) => {
+        try {
+            if (c) {
+                Promise.all(t.map((async r => r.set(s, i, a ?? e?.ttl))));
+                r.emit("set", {
+                    key: s,
+                    value: i
+                });
+                return i;
+            }
+            await Promise.all(t.map((async r => r.set(s, i, a ?? e?.ttl))));
+            r.emit("set", {
+                key: s,
+                value: i
+            });
+            return i;
+        } catch (e) {
+            r.emit("set", {
+                key: s,
+                value: i,
+                error: e
+            });
+            return Promise.reject(e);
+        }
+    };
+    const h = async (e, t) => {
+        const s = t.map((({key: e, value: r, ttl: t}) => ({
+            key: e,
+            value: r,
+            ttl: t
+        })));
+        try {
+            const s = [];
+            for (const r of t) {
+                s.push(...e.map((async e => e.set(r.key, r.value, r.ttl))));
+            }
+            if (c) {
+                Promise.all(s);
+                r.emit("mset", {
+                    list: t
+                });
+                return t;
+            }
+            await Promise.all(s);
+            r.emit("mset", {
+                list: t
+            });
+            return t;
+        } catch (e) {
+            r.emit("mset", {
+                list: t,
+                error: e
+            });
+            return Promise.reject(e);
+        }
+    };
+    const d = async e => {
+        try {
+            if (c) {
+                Promise.all(i.map((async r => r.delete(e))));
+                r.emit("del", {
+                    key: e
+                });
+                return true;
+            }
+            await Promise.all(i.map((async r => r.delete(e))));
+            r.emit("del", {
+                key: e
+            });
+            return true;
+        } catch (t) {
+            r.emit("del", {
+                key: e,
+                error: t
+            });
+            return Promise.reject(t);
+        }
+    };
+    const p = async e => {
+        try {
+            const t = [];
+            for (const r of e) {
+                t.push(...i.map((async e => e.delete(r))));
+            }
+            if (c) {
+                Promise.all(t);
+                r.emit("mdel", {
+                    keys: e
+                });
+                return true;
+            }
+            await Promise.all(t);
+            r.emit("mdel", {
+                keys: e
+            });
+            return true;
+        } catch (t) {
+            r.emit("mdel", {
+                keys: e,
+                error: t
+            });
+            return Promise.reject(t);
+        }
+    };
+    const y = async () => {
+        try {
+            if (c) {
+                Promise.all(i.map((async e => e.clear())));
+                r.emit("clear");
+                return true;
+            }
+            await Promise.all(i.map((async e => e.clear())));
+            r.emit("clear");
+            return true;
+        } catch (e) {
+            r.emit("clear", e);
+            return Promise.reject(e);
+        }
+    };
+    const j = async (t, s, c, n) => w(`${a}::${t}`, (async () => {
+        let o;
+        let u;
+        let h = 0;
+        let d;
+        const {ttl: p, refreshThreshold: y, raw: m} = M(c) ? c : {
+            ttl: c,
+            refreshThreshold: n
+        };
+        const j = r => x(p, r) ?? e?.ttl;
+        for (;h < i.length; h++) {
+            try {
+                const e = await i[h].get(t, {
+                    raw: true
+                });
+                if (e !== void 0) {
+                    o = e.value;
+                    u = e;
+                    if (typeof e.expires === "number") {
+                        d = Math.max(0, e.expires - Date.now());
+                    }
+                    break;
+                }
+            } catch {}
+        }
+        if (o === void 0) {
+            const e = await s();
+            const r = j(e);
+            await l(i, t, e, r);
+            return m ? {
+                value: e,
+                expires: Date.now() + r
+            } : e;
+        }
+        const q = A(d, x(y, o) ?? e?.refreshThreshold);
+        if (q) {
+            w(`+++${a}__${t}`, s).then((async s => {
+                try {
+                    await l(e?.refreshAllStores ? i : i.slice(0, h + 1), t, s, j(s));
+                    r.emit("refresh", {
+                        key: t,
+                        value: s
+                    });
+                } catch (e) {
+                    r.emit("refresh", {
+                        key: t,
+                        value: o,
+                        error: e
+                    });
+                }
+            })).catch((e => {
+                r.emit("refresh", {
+                    key: t,
+                    value: o,
+                    error: e
+                });
+            }));
+        }
+        if (!q && h > 0) {
+            await l(i.slice(0, h), t, o, j(o));
+        }
+        return m ? u : o;
+    }));
+    const q = (e, t) => r.addListener(e, t);
+    const f = (e, t) => r.removeListener(e, t);
+    const b = async () => {
+        try {
+            await Promise.all(i.map((async e => e.disconnect())));
+        } catch (e) {
+            return Promise.reject(e);
+        }
+    };
+    const v = () => a;
+    return {
+        get: n,
+        mget: o,
+        ttl: u,
+        set: async (e, r, t) => l(i, e, r, t),
+        mset: async e => h(i, e),
+        del: d,
+        mdel: p,
+        clear: y,
+        wrap: j,
+        on: q,
+        off: f,
+        disconnect: b,
+        cacheId: v,
+        stores: i
+    };
+};
+
+const I = e => ({
+    class: Cacher,
+    options: e
+});
+
+class Cacher extends i.Component {
+    async init() {
+        const e = this.options?.stores ? Array.isArray(this.options.stores) ? this.options.stores : [ this.options.stores ] : [];
+        const r = await Promise.all(e.map((e => {
+            switch (e.type) {
+              case "file":
+                return n.CreateFileCacheAdapter(e);
+
+              case "redis":
+                return o.CreateRedisCacheAdapter(e);
+
+              case "memcache":
+                return u.CreateMemcacheCacheAdapter(e);
+
+              case "mongo":
+                return l.CreateMongoCacheAdapter(e);
+
+              case "sqlite":
+                return h.CreateSqliteCacheAdapter(e);
+
+              case "postgres":
+                return d.CreatePostgresCacheAdapter(e);
+
+              case "mysql":
+                return p.CreateMysqlCacheAdapter(e);
+
+              default:
+                return undefined;
+            }
+        })));
+        let t = r.filter((e => !!e));
+        if (!t.length) t = undefined;
+        this.cache = _({
+            ...this.options,
+            stores: t
+        });
+        this.cache.on("set", (e => this.emit("set", e)));
+        this.cache.on("del", (e => this.emit("del", e)));
+        this.cache.on("clear", (e => this.emit("clear", e)));
+        this.cache.on("refresh", (e => this.emit("refresh", e)));
+    }
+    async destroy() {
+        await this.cache.disconnect();
+    }
+    async set(e, r, t) {
+        return await this.cache.set(e, r, t);
+    }
+    async multipleSet(e) {
+        return await this.cache.mset(e);
+    }
+    async get(e) {
+        return a.As(await this.cache.get(e));
+    }
+    async multipleGet(e) {
+        return await this.cache.mget(e);
+    }
+    async ttl(e) {
+        const r = await this.cache.ttl(e);
+        if (r === undefined) return -1;
+        return r;
+    }
+    async del(e) {
+        return await this.cache.del(e);
+    }
+    async multipleDel(e) {
+        return await this.cache.mdel(e);
+    }
+    async clear() {
+        return await this.cache.clear();
+    }
+    on(e, r) {
+        return super.on(e, r);
+    }
+}
+
+e.__decorate([ c.Configurable(s.CacherOptions.optional()), e.__metadata("design:type", s.CacherOptions) ], Cacher.prototype, "options", void 0);
+
+exports.BuildCacherOptions = I;
+
+exports.Cacher = Cacher;