lakutata/vendor/Package.611.cjs

An IoC-based universal application framework.

"use strict";

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

const t = require("events");

const e = require("mysql2");

const s = t => t && t.__esModule ? t : {
    default: t
};

const a = s(t);

const o = s(e);

var n;

var i;

var r = t => {
    t = t.replace(/#/g, "%23");
    const e = new URL(t);
    const s = {
        user: decodeURIComponent(e.username),
        password: decodeURIComponent(e.password) || void 0,
        host: e.hostname,
        port: e.port ? Number.parseInt(e.port, 10) : void 0,
        database: decodeURIComponent(e.pathname.slice(1))
    };
    for (const t of Object.keys(s)) {
        if (s[t] === void 0) {
            delete s[t];
        }
    }
    return s;
};

var c = (t, e = {}) => {
    if (i !== t) {
        n = void 0;
        i = t;
    }
    const s = r(t);
    const a = {
        ...s,
        ...e
    };
    n ??= o.default.createPool(a);
    return n.promise();
};

var E = () => {
    if (n) {
        n.end();
    }
    i = void 0;
};

var l = new Set([ "adapter", "compression", "connect", "dialect", "keySize", "table", "ttl", "uri" ]);

var u = class extends a.default {
    ttlSupport=false;
    opts;
    namespace;
    query;
    constructor(t) {
        super();
        let e = {
            dialect: "mysql",
            uri: "mysql://localhost"
        };
        if (typeof t === "string") {
            e.uri = t;
        } else {
            e = {
                ...e,
                ...t
            };
        }
        if (e.intervalExpiration !== void 0 && e.intervalExpiration > 0) {
            this.ttlSupport = true;
        }
        const s = Object.fromEntries(Object.entries(e).filter((([t]) => !l.has(t))));
        delete s.namespace;
        delete s.serialize;
        delete s.deserialize;
        const a = async () => {
            const t = c(e.uri, s);
            return async e => {
                const s = await t.query(e);
                return s[0];
            };
        };
        this.opts = {
            table: "keyv",
            keySize: 255,
            ...e
        };
        const o = `CREATE TABLE IF NOT EXISTS ${this.opts.table}(id VARCHAR(${Number(this.opts.keySize)}) PRIMARY KEY, value TEXT)`;
        const n = a().then((async t => {
            await t(o);
            if (this.opts.intervalExpiration !== void 0 && this.opts.intervalExpiration > 0) {
                await t("SET GLOBAL event_scheduler = ON;");
                await t("DROP EVENT IF EXISTS keyv_delete_expired_keys;");
                await t(`CREATE EVENT IF NOT EXISTS keyv_delete_expired_keys ON SCHEDULE EVERY ${this.opts.intervalExpiration} SECOND\n\t\t\t\t\tDO DELETE FROM ${this.opts.table}\n\t\t\t\t\tWHERE CAST(value->'$.expires' AS UNSIGNED) BETWEEN 1 AND UNIX_TIMESTAMP(NOW(3)) * 1000;`);
            }
            return t;
        })).catch((t => this.emit("error", t)));
        this.query = async t => {
            const e = await n;
            return e(t);
        };
    }
    async get(t) {
        const e = `SELECT * FROM ${this.opts.table} WHERE id = ?`;
        const s = o.default.format(e, [ t ]);
        const a = await this.query(s);
        const n = a[0];
        return n?.value;
    }
    async getMany(t) {
        const e = `SELECT * FROM ${this.opts.table} WHERE id IN (?)`;
        const s = o.default.format(e, [ t ]);
        const a = await this.query(s);
        const n = [];
        for (const e of t) {
            const t = a.findIndex((t => t.id === e));
            n.push(t === -1 ? void 0 : a[t].value);
        }
        return n;
    }
    async set(t, e) {
        const s = `INSERT INTO ${this.opts.table} (id, value)\n\t\t\tVALUES(?, ?) \n\t\t\tON DUPLICATE KEY UPDATE value=?;`;
        const a = [ t, e, e ];
        const n = o.default.format(s, a);
        return this.query(n);
    }
    async delete(t) {
        const e = `SELECT * FROM ${this.opts.table} WHERE id = ?`;
        const s = o.default.format(e, [ t ]);
        const a = `DELETE FROM ${this.opts.table} WHERE id = ?`;
        const n = o.default.format(a, [ t ]);
        const i = await this.query(s);
        const r = i[0];
        if (r === void 0) {
            return false;
        }
        await this.query(n);
        return true;
    }
    async deleteMany(t) {
        const e = `DELETE FROM ${this.opts.table} WHERE id IN (?)`;
        const s = o.default.format(e, [ t ]);
        const a = await this.query(s);
        return a.affectedRows !== 0;
    }
    async clear() {
        const t = `DELETE FROM ${this.opts.table} WHERE id LIKE ?`;
        const e = o.default.format(t, [ this.namespace ? `${this.namespace}:%` : "%" ]);
        await this.query(e);
    }
    async* iterator(t) {
        const e = Number.parseInt(this.opts.iterationLimit, 10) || 10;
        async function* s(a, n, i) {
            const r = `SELECT * FROM ${n.table} WHERE id LIKE ? LIMIT ? OFFSET ?`;
            const c = o.default.format(r, [ `${t ? t + ":" : ""}%`, e, a ]);
            const E = await i(c);
            if (E.length === 0) {
                return;
            }
            for (const t of E) {
                a += 1;
                yield [ t.id, t.value ];
            }
            yield* s(a, n, i);
        }
        yield* s(0, this.opts, this.query);
    }
    async has(t) {
        const e = `SELECT EXISTS ( SELECT * FROM ${this.opts.table} WHERE id = '${t}' )`;
        const s = await this.query(e);
        return Object.values(s[0])[0] === 1;
    }
    async disconnect() {
        E();
    }
};

var d = u;

exports.KeyvMysql = u;

exports.default = d;