lakutata/src/components/cacher/Cacher.cjs

An IoC-based universal application framework.

"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("../../lib/core/Component.cjs");

const c = require("../../decorators/di/Configurable.cjs");

const i = require("../../lib/helpers/As.cjs");

const a = require("./adapters/CreateFileCacheAdapter.cjs");

const n = require("./adapters/CreateRedisCacheAdapter.cjs");

const o = require("./adapters/CreateMemcacheCacheAdapter.cjs");

const l = require("./adapters/CreateMongoCacheAdapter.cjs");

const u = require("./adapters/CreateSqliteCacheAdapter.cjs");

const h = require("./adapters/CreatePostgresCacheAdapter.cjs");

const d = require("./adapters/CreateMysqlCacheAdapter.cjs");

const p = require("../../../vendor/Package.2.cjs");

const m = require("./options/FileCacheOptions.cjs");

const y = require("./options/RedisCacheOptions.cjs");

const j = require("./options/MemcacheCacheOptions.cjs");

const q = require("./options/MongoCacheOptions.cjs");

const f = require("./options/SqliteCacheOptions.cjs");

const b = require("./options/PostgresCacheOptions.cjs");

const g = require("./options/MysqlCacheOptions.cjs");

require("buffer");

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("../../../vendor/Package.4.cjs");

require("../../../vendor/Package.5.cjs");

require("../../exceptions/di/LifetimeLockedException.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("../../exceptions/MethodNotFoundException.cjs");

require("../../lib/ioc/DependencyInjectionContainer.cjs");

require("util");

require("../../lib/ioc/Errors.cjs");

require("../../exceptions/di/DependencyInjectionException.cjs");

require("../../lib/base/internal/ConstructorSymbol.cjs");

require("node:crypto");

require("../../lib/base/internal/DataValidator.cjs");

require("node:util/types");

require("../../lib/validation/VLD.cjs");

require("../../../vendor/Package.11.cjs");

require("url");

require("../../../vendor/Package.10.cjs");

require("../../exceptions/dto/InvalidValueException.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("../../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/Expect.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.20.cjs");

require("constants");

require("../../../vendor/Package.18.cjs");

require("assert");

require("../../../vendor/Package.14.cjs");

require("./lib/IsDriverPackageInstalled.cjs");

require("./exceptions/CacheDriverNotFoundException.cjs");

require("../../lib/helpers/URLBuilder.cjs");

const C = e => e && e.__esModule ? e : {
    default: e
};

const v = C(r);

var k = new Map;

function P(e) {
    return k.has(e);
}

function w(e) {
    k.set(e, []);
}

function O(e) {
    k.delete(e);
}

function _(e, r) {
    const t = A(e);
    t.push(r);
    k.set(e, t);
}

function A(e) {
    return k.get(e) ?? [];
}

async function S(e) {
    return new Promise(((r, t) => {
        const s = {
            resolve: r,
            reject: t
        };
        _(e, s);
    }));
}

function M(e) {
    const r = A(e);
    O(e);
    return r;
}

function x(e) {
    const {key: r, error: t, result: s} = e;
    for (const e of M(r)) {
        if (t) {
            e.reject(t);
        } else {
            e.resolve(s);
        }
    }
}

async function I(e, r) {
    if (!P(e)) {
        w(e);
        try {
            const t = await Promise.resolve(r());
            x({
                key: e,
                result: t
            });
            return t;
        } catch (r) {
            x({
                key: e,
                error: r
            });
            throw r;
        }
    }
    return S(e);
}

function T(e) {
    return e !== null && typeof e === "object" && !Array.isArray(e);
}

function D(e, ...r) {
    return typeof e === "function" ? e(...r) : e;
}

function L(e, r) {
    return typeof e === "number" && typeof r === "number" ? e < r : false;
}

var B = 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 = e => {
    const r = new v.default;
    const s = new t.Keyv;
    s.serialize = void 0;
    s.deserialize = void 0;
    const c = e?.stores?.length ? e.stores : [ s ];
    const i = e?.nonBlocking ?? false;
    const a = e?.cacheId ?? Math.random().toString(36).slice(2);
    const n = async e => {
        let t;
        if (i) {
            try {
                t = await Promise.race(c.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 c) {
                try {
                    const c = await s.get(e);
                    if (c !== void 0) {
                        t = c;
                        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 l = async e => {
        let t;
        if (i) {
            try {
                t = await Promise.race(c.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 c) {
                try {
                    const c = await s.get(e, {
                        raw: true
                    });
                    if (c !== void 0) {
                        t = c;
                        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 u = async (t, s, c, a) => {
        try {
            if (i) {
                Promise.all(t.map((async r => r.set(s, c, a ?? e?.ttl))));
                r.emit("set", {
                    key: s,
                    value: c
                });
                return c;
            }
            await Promise.all(t.map((async r => r.set(s, c, a ?? e?.ttl))));
            r.emit("set", {
                key: s,
                value: c
            });
            return c;
        } catch (e) {
            r.emit("set", {
                key: s,
                value: c,
                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 (i) {
                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 (i) {
                Promise.all(c.map((async r => r.delete(e))));
                r.emit("del", {
                    key: e
                });
                return true;
            }
            await Promise.all(c.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(...c.map((async e => e.delete(r))));
            }
            if (i) {
                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 m = async () => {
        try {
            if (i) {
                Promise.all(c.map((async e => e.clear())));
                r.emit("clear");
                return true;
            }
            await Promise.all(c.map((async e => e.clear())));
            r.emit("clear");
            return true;
        } catch (e) {
            r.emit("clear", e);
            return Promise.reject(e);
        }
    };
    const y = async (t, s, i, n) => I(`${a}::${t}`, (async () => {
        let o;
        let l;
        let h = 0;
        let d;
        const {ttl: p, refreshThreshold: m, raw: y} = T(i) ? i : {
            ttl: i,
            refreshThreshold: n
        };
        const j = r => D(p, r) ?? e?.ttl;
        for (;h < c.length; h++) {
            try {
                const e = await c[h].get(t, {
                    raw: true
                });
                if (e !== void 0) {
                    o = e.value;
                    l = 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 u(c, t, e, r);
            return y ? {
                value: e,
                expires: Date.now() + r
            } : e;
        }
        const q = L(d, D(m, o) ?? e?.refreshThreshold);
        if (q) {
            I(`+++${a}__${t}`, s).then((async s => {
                try {
                    await u(e?.refreshAllStores ? c : c.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 u(c.slice(0, h), t, o, j(o));
        }
        return y ? l : o;
    }));
    const j = (e, t) => r.addListener(e, t);
    const q = (e, t) => r.removeListener(e, t);
    const f = async () => {
        try {
            await Promise.all(c.map((async e => e.disconnect())));
        } catch (e) {
            return Promise.reject(e);
        }
    };
    const b = () => a;
    return {
        get: n,
        mget: o,
        ttl: l,
        set: async (e, r, t) => u(c, e, r, t),
        mset: async e => h(c, e),
        del: d,
        mdel: p,
        clear: m,
        wrap: y,
        on: j,
        off: q,
        disconnect: f,
        cacheId: b,
        stores: c
    };
};

const R = e => ({
    class: Cacher,
    stores: e?.stores,
    ttl: e?.ttl,
    refreshThreshold: e?.refreshThreshold,
    refreshAllStores: e?.refreshAllStores,
    nonBlocking: e?.nonBlocking,
    cacheId: e?.cacheId
});

class Cacher extends s.Component {
    async init() {
        const e = this.stores ? Array.isArray(this.stores) ? this.stores : [ this.stores ] : [];
        const r = await Promise.all(e.map((e => {
            switch (e.type) {
              case "file":
                return a.CreateFileCacheAdapter(e);

              case "redis":
                return n.CreateRedisCacheAdapter(e);

              case "memcache":
                return o.CreateMemcacheCacheAdapter(e);

              case "mongo":
                return l.CreateMongoCacheAdapter(e);

              case "sqlite":
                return u.CreateSqliteCacheAdapter(e);

              case "postgres":
                return h.CreatePostgresCacheAdapter(e);

              case "mysql":
                return d.CreateMysqlCacheAdapter(e);

              default:
                return undefined;
            }
        })));
        const t = r.filter((e => !!e));
        this.cache = E({
            stores: t.length ? t : undefined,
            ttl: this.ttl,
            refreshThreshold: this.refreshThreshold,
            refreshAllStores: this.refreshAllStores,
            nonBlocking: this.nonBlocking,
            cacheId: this.cacheId || this.$uuid
        });
        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 i.As(await this.cache.get(e));
    }
    async multipleGet(e) {
        return await this.cache.mget(e);
    }
    async getTTL(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(p.DTO.Alternatives(p.DTO.Array(p.DTO.Alternatives(m.FileCacheOptions.Schema(), y.RedisCacheOptions.Schema(), j.MemcacheCacheOptions.Schema(), q.MongoCacheOptions.Schema(), f.SqliteCacheOptions.Schema(), b.PostgresCacheOptions.Schema(), g.MysqlCacheOptions.Schema())), m.FileCacheOptions.Schema(), y.RedisCacheOptions.Schema(), j.MemcacheCacheOptions.Schema(), q.MongoCacheOptions.Schema(), f.SqliteCacheOptions.Schema(), b.PostgresCacheOptions.Schema(), g.MysqlCacheOptions.Schema()).optional()), e.__metadata("design:type", Object) ], Cacher.prototype, "stores", void 0);

e.__decorate([ c.Configurable(p.DTO.Number().positive().integer().optional()), e.__metadata("design:type", Number) ], Cacher.prototype, "ttl", void 0);

e.__decorate([ c.Configurable(p.DTO.Number().positive().integer().optional()), e.__metadata("design:type", Number) ], Cacher.prototype, "refreshThreshold", void 0);

e.__decorate([ c.Configurable(p.DTO.Boolean().optional()), e.__metadata("design:type", Boolean) ], Cacher.prototype, "refreshAllStores", void 0);

e.__decorate([ c.Configurable(p.DTO.Boolean().optional()), e.__metadata("design:type", Boolean) ], Cacher.prototype, "nonBlocking", void 0);

e.__decorate([ c.Configurable(p.DTO.String().optional()), e.__metadata("design:type", String) ], Cacher.prototype, "cacheId", void 0);

exports.BuildCacherOptions = R;

exports.Cacher = Cacher;