lakutata 2.0.34 → 2.0.36

package/src/components/cacher/Cacher.mjs

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