lakutata/src/components/cacher/adapters/CreateFileCacheAdapter.cjs

An IoC-based universal application framework.

/* Build Date: Mon Jan 05 2026 23:52:23 GMT+0800 (China Standard Time) */
"use strict";

Object.defineProperty(exports, Symbol.toStringTag, {
    value: "Module"
});

const e = require("../../../../vendor/Package.internal.524.cjs");

const t = require("../../../../vendor/Package.internal.310.cjs");

const r = require("os");

const i = require("fs");

const s = require("fs/promises");

const a = require("events");

const n = require("buffer");

const o = require("path");

require("../../../../vendor/Package.internal.2.cjs");

require("../../../../vendor/Package.internal.3.cjs");

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

const c = l(r);

const u = l(i);

const d = l(s);

const p = l(a);

const h = l(n);

const f = l(o);

var y = {};

var _;

var v;

function m() {
    if (v) return _;
    v = 1;
    var e = Object.defineProperty;
    var t = Object.getOwnPropertyDescriptor;
    var r = Object.getOwnPropertyNames;
    var i = Object.prototype.hasOwnProperty;
    var s = (t, r) => {
        for (var i in r) e(t, i, {
            get: r[i],
            enumerable: true
        });
    };
    var a = (s, a, n, o) => {
        if (a && typeof a === "object" || typeof a === "function") {
            for (let l of r(a)) if (!i.call(s, l) && l !== n) e(s, l, {
                get: () => a[l],
                enumerable: !(o = t(a, l)) || o.enumerable
            });
        }
        return s;
    };
    var n = t => a(e({}, "__esModule", {
        value: true
    }), t);
    var o = {};
    s(o, {
        defaultDeserialize: () => d,
        defaultSerialize: () => u
    });
    _ = n(o);
    var l = h.default;
    var c = (e, t = true) => {
        if (e === void 0 || e === null) {
            return "null";
        }
        if (typeof e === "string") {
            return JSON.stringify(t && e.startsWith(":") ? `:${e}` : e);
        }
        if (l.Buffer.isBuffer(e)) {
            return JSON.stringify(`:base64:${e.toString("base64")}`);
        }
        if (e?.toJSON) {
            e = e.toJSON();
        }
        if (typeof e === "object") {
            let r = "";
            const i = Array.isArray(e);
            r = i ? "[" : "{";
            let s = true;
            for (const a in e) {
                const n = typeof e[a] === "function" || !i && e[a] === void 0;
                if (!Object.hasOwn(e, a) || n) {
                    continue;
                }
                if (!s) {
                    r += ",";
                }
                s = false;
                if (i) {
                    r += c(e[a], t);
                } else if (e[a] !== void 0) {
                    r += `${c(a, false)}:${c(e[a], t)}`;
                }
            }
            r += i ? "]" : "}";
            return r;
        }
        return JSON.stringify(e);
    };
    var u = e => c(e, true);
    var d = e => JSON.parse(e, (e, t) => {
        if (typeof t === "string") {
            if (t.startsWith(":base64:")) {
                return l.Buffer.from(t.slice(8), "base64");
            }
            return t.startsWith(":") ? t.slice(1) : t;
        }
        return t;
    });
    return _;
}

var g = {};

var F = {};

var k;

function S() {
    if (k) return F;
    k = 1;
    Object.defineProperty(F, "__esModule", {
        value: true
    });
    F.SafeFilenameEncoder = void 0;
    F.SafeFilenameEncoder = {
        encode(e) {
            return e.replace(/[^0-9a-zA-Z]/g, e => {
                const t = e.charCodeAt(0);
                if (t < 0 || t > 126) {
                    return e;
                }
                return "%" + e.charCodeAt(0).toString(16).padStart(2, "0");
            }).replace(/%/g, "_");
        },
        decode(e) {
            return decodeURIComponent(e.replace(/_/g, "%"));
        }
    };
    return F;
}

var w;

function x() {
    if (w) return g;
    w = 1;
    Object.defineProperty(g, "__esModule", {
        value: true
    });
    g.SeparatedFileHelper = void 0;
    g.handleIOError = n;
    const e = t.require$$0;
    const r = e.__importDefault(f.default);
    const i = e.__importStar(u.default);
    const s = e.__importStar(d.default);
    const a = S();
    function n(e) {
        if (e.code === "ENOENT") {
            return;
        } else {
            console.error(e);
        }
    }
    class SeparatedFileHelper {
        opts;
        get lockFile() {
            return r.default.join(this.opts.filename, ".lock");
        }
        get _lastExpireFile() {
            return r.default.join(this.opts.filename, ".lastExpire");
        }
        constructor(e) {
            this.opts = e;
        }
        getLastExpire() {
            try {
                return Number(i.readFileSync(this._lastExpireFile, "utf8"));
            } catch (e) {
                n(e);
            }
            return 0;
        }
        setLastExpire(e) {
            try {
                s.writeFile(this._lastExpireFile, e.toString());
            } catch (e) {
                n(e);
            }
        }
        async get(e) {
            try {
                let t = await s.readFile(this._getKey(e));
                let r = this.opts.deserialize(t);
                return r;
            } catch (e) {
                n(e);
            }
        }
        getSync(e) {
            try {
                let t = i.readFileSync(this._getKey(e));
                let r = this.opts.deserialize(t);
                return r;
            } catch (e) {
                n(e);
            }
        }
        _getKey(e) {
            return r.default.join(this.opts.filename, a.SafeFilenameEncoder.encode(e));
        }
        async set(e, t) {
            try {
                let r = this.opts.serialize(t);
                await s.mkdir(this.opts.filename, {
                    recursive: true
                });
                await s.writeFile(this._getKey(e), r);
            } catch (e) {
                n(e);
            }
        }
        async delete(e) {
            try {
                await s.unlink(this._getKey(e));
                return true;
            } catch (e) {
                n(e);
                return false;
            }
        }
        async clear() {
            await s.rm(this.opts.filename, {
                recursive: true,
                force: true
            });
        }
        async clearExpire(e) {
            try {
                let t = await s.readdir(this.opts.filename);
                for (const r of t) {
                    e(r);
                }
                await s.writeFile(this._lastExpireFile, Date.now().toString());
            } catch (e) {
                n(e);
            }
        }
        async entries() {
            return s.readdir(this.opts.filename).then(e => Promise.all(e.map(async e => {
                e = a.SafeFilenameEncoder.decode(e);
                return [ e, await this.get(e) ];
            })));
        }
    }
    g.SeparatedFileHelper = SeparatedFileHelper;
    return g;
}

var E = {};

var O;

function P() {
    if (O) return E;
    O = 1;
    Object.defineProperty(E, "__esModule", {
        value: true
    });
    E.Field = void 0;
    E.makeField = e;
    class Field {
        kv;
        key;
        defaults;
        constructor(e, t, r) {
            this.kv = e;
            this.key = t;
            this.defaults = r;
        }
        async get(e = this.defaults) {
            return await this.kv.get(this.key) ?? e;
        }
        getSync(e = this.defaults) {
            if (this.kv instanceof Map) {
                return this.kv.get(this.key) ?? e;
            } else if ("getSync" in this.kv) {
                return this.kv.getSync(this.key) ?? e;
            }
            throw new Error("kv does not support getSync");
        }
        set(e, t) {
            return this.kv.set(this.key, e, t);
        }
        delete() {
            return this.kv.delete(this.key);
        }
    }
    E.Field = Field;
    function e(e, t, r) {
        return new Field(e, t, r);
    }
    return E;
}

(function(e) {
    Object.defineProperty(e, "__esModule", {
        value: true
    });
    e.KeyvFile = e.defaultOpts = void 0;
    const r = t.require$$0;
    const i = r.__importStar(c.default);
    const s = r.__importStar(u.default);
    const a = r.__importStar(d.default);
    const n = r.__importDefault(p.default);
    const o = m();
    const l = r.__importDefault(f.default);
    const h = x();
    r.__exportStar(P(), e);
    e.defaultOpts = {
        deserialize: e => (0, o.defaultDeserialize)(e.toString()),
        dialect: "redis",
        expiredCheckDelay: 24 * 3600 * 1e3,
        filename: `${i.tmpdir()}/keyv-file/default.json`,
        serialize: o.defaultSerialize,
        writeDelay: 100,
        checkFileLock: false,
        separatedFile: false
    };
    function y(e) {
        return typeof e === "number";
    }
    class KeyvFile extends n.default {
        ttlSupport=true;
        namespace;
        opts;
        _data=new Map;
        _lastExpire=0;
        _separated;
        constructor(t) {
            super();
            this.opts = Object.assign({}, e.defaultOpts, t);
            this._separated = new h.SeparatedFileHelper(this.opts);
            if (this.opts.checkFileLock) {
                this.acquireFileLock();
            }
            if (this.opts.separatedFile) {
                s.mkdirSync(this.opts.filename, {
                    recursive: true
                });
                this._lastExpire = this._separated.getLastExpire();
            } else {
                this._loadDataSync();
            }
        }
        _loadDataSync() {
            try {
                const e = this.opts.deserialize(s.readFileSync(this.opts.filename));
                if (!Array.isArray(e.cache)) {
                    const t = e.cache;
                    e.cache = [];
                    for (const r in t) {
                        if (t.hasOwnProperty(r)) {
                            e.cache.push([ r, t[r] ]);
                        }
                    }
                }
                this._data = new Map(e.cache);
                this._lastExpire = e.lastExpire;
            } catch (e) {
                (0, h.handleIOError)(e);
                this._data = new Map;
                this._lastExpire = Date.now();
            }
        }
        get _lockFile() {
            if (this.opts.separatedFile) {
                return this._separated.lockFile;
            }
            return this.opts.filename + ".lock";
        }
        acquireFileLock() {
            try {
                let e = s.openSync(this._lockFile, "wx");
                s.closeSync(e);
                process.on("SIGINT", () => {
                    this.releaseFileLock();
                    process.exit(0);
                });
                process.on("exit", () => {
                    this.releaseFileLock();
                });
            } catch (e) {
                console.error(`[keyv-file] There is another process using this file`);
                throw e;
            }
        }
        releaseFileLock() {
            try {
                s.unlinkSync(this._lockFile);
            } catch (e) {
                (0, h.handleIOError)(e);
            }
        }
        async get(e) {
            if (this.opts.separatedFile) {
                let t = await this._separated.get(e);
                return this._getWithExpire(e, t);
            }
            return this.getSync(e);
        }
        getSync(e) {
            if (this.opts.separatedFile) {
                let t = this._separated.getSync(e);
                return this._getWithExpire(e, t);
            }
            let t = void 0;
            try {
                const t = this._data.get(e);
                return this._getWithExpire(e, t);
            } catch (e) {
                (0, h.handleIOError)(e);
            }
            return t;
        }
        async getMany(e) {
            if (this.opts.separatedFile) {
                return Promise.all(e.map(e => this.get(e)));
            }
            return e.map(e => this.getSync(e));
        }
        async set(e, t, r) {
            if (r === 0) {
                r = undefined;
            }
            t = {
                expire: y(r) ? Date.now() + r : undefined,
                value: t
            };
            this.clearExpire();
            if (this.opts.separatedFile) {
                return this._separated.set(e, t);
            }
            this._data.set(e, t);
            return this.save();
        }
        async delete(e) {
            if (this.opts.separatedFile) {
                return this._separated.delete(e);
            }
            const t = this._data.delete(e);
            await this.save();
            return t;
        }
        async deleteMany(e) {
            if (this.opts.separatedFile) {
                let t = await Promise.all(e.map(e => this.delete(e)));
                return t.every(e => e);
            }
            let t = e.every(e => this._data.delete(e));
            await this.save();
            return t;
        }
        async clear() {
            if (this.opts.separatedFile) {
                await this._separated.clear();
                this._lastExpire = 0;
                return true;
            }
            this._data = new Map;
            this._lastExpire = Date.now();
            return this.save();
        }
        async has(e) {
            const t = await this.get(e);
            return t !== undefined;
        }
        isExpired(e) {
            return y(e.expire) && e.expire <= Date.now();
        }
        _getWithExpire(e, t) {
            if (!t) {
                return;
            }
            if (this.isExpired(t)) {
                this.delete(e);
                return;
            }
            return t.value;
        }
        clearExpire() {
            const e = Date.now();
            if (e - this._lastExpire <= this.opts.expiredCheckDelay) {
                return;
            }
            this._lastExpire = e;
            if (this.opts.separatedFile) {
                this._separated.clearExpire(e => this.get(e));
                return;
            }
            for (const e of this._data.keys()) {
                const t = this._data.get(e);
                this._getWithExpire(e, t);
            }
        }
        async saveToDisk() {
            const e = [];
            for (const [t, r] of this._data) {
                e.push([ t, r ]);
            }
            const t = this.opts.serialize({
                cache: e,
                lastExpire: this._lastExpire
            });
            await a.mkdir(l.default.dirname(this.opts.filename), {
                recursive: true
            });
            return a.writeFile(this.opts.filename, t);
        }
        _savePromise;
        save() {
            this.clearExpire();
            if (this._savePromise) {
                return this._savePromise;
            }
            this._savePromise = new Promise((e, t) => {
                setTimeout(() => {
                    this.saveToDisk().then(e, t).finally(() => {
                        this._savePromise = void 0;
                    });
                }, this.opts.writeDelay);
            });
            return this._savePromise;
        }
        disconnect() {
            return Promise.resolve();
        }
        async* iterator(e) {
            let t = this.opts.separatedFile ? await this._separated.entries() : this._data.entries();
            for (const [r, i] of t) {
                if (r === undefined || i === undefined) {
                    continue;
                }
                if (!e || r.includes(e)) {
                    yield [ r, i.value ];
                }
            }
        }
    }
    e.KeyvFile = KeyvFile;
    e.default = KeyvFile;
})(y);

async function b(t) {
    return new e.index_default({
        store: new y.KeyvFile({
            filename: t.filename,
            expiredCheckDelay: t.expiredCheckDelay,
            writeDelay: t.writeDelay
        }),
        namespace: t.namespace
    });
}

exports.CreateFileCacheAdapter = b;