lakutata 2.0.65 → 2.0.67

package/vendor/Package.610.mjs

@@ -1,139 +1,327 @@
 import t from "events";
 
-import { promisify as e } from "util";
+import { Buffer as e } from "buffer";
 
-import { i as s } from "./Package.66.mjs";
+import { MongoClient as n, GridFSBucket as s, MongoServerError as a } from "mongodb";
 
-import a from "sqlite3";
+var o = new Set([ "url", "collection", "namespace", "serialize", "deserialize", "uri", "useGridFS", "dialect", "db" ]);
 
-import "buffer";
-
-var i = t => String(t).search(/^[a-zA-Z]+$/) < 0 ? "_" + t : t;
-
-var n = class extends t {
-    ttlSupport;
+var i = class extends t {
+    ttlSupport=false;
     opts;
+    connect;
     namespace;
-    close;
-    query;
-    constructor(t) {
+    constructor(t, e) {
         super();
-        this.ttlSupport = false;
-        let s = {
-            dialect: "sqlite",
-            uri: "sqlite://:memory:"
-        };
+        t ??= {};
         if (typeof t === "string") {
-            s.uri = t;
-        } else {
-            s = {
-                ...s,
+            t = {
+                url: t
+            };
+        }
+        if (t.uri) {
+            t = {
+                url: t.uri,
                 ...t
             };
         }
-        s.db = s.uri.replace(/^sqlite:\/\//, "");
-        s.connect = async () => new Promise(((t, e) => {
-            const i = new a.Database(s.db, (a => {
-                if (a) {
-                    e(a);
+        this.opts = {
+            url: "mongodb://127.0.0.1:27017",
+            collection: "keyv",
+            ...t,
+            ...e
+        };
+        delete this.opts.emitErrors;
+        const a = Object.fromEntries(Object.entries(this.opts).filter((([t]) => !o.has(t))));
+        this.opts = Object.fromEntries(Object.entries(this.opts).filter((([t]) => o.has(t))));
+        this.connect = new Promise((async (t, e) => {
+            try {
+                let e = "";
+                if (this.opts.url) {
+                    e = this.opts.url;
+                }
+                const o = new n(e, a);
+                await o.connect();
+                const i = o.db(this.opts.db);
+                if (this.opts.useGridFS) {
+                    const e = new s(i, {
+                        readPreference: this.opts.readPreference,
+                        bucketName: this.opts.collection
+                    });
+                    const n = i.collection(`${this.opts.collection}.files`);
+                    await n.createIndex({
+                        uploadDate: -1
+                    });
+                    await n.createIndex({
+                        "metadata.expiresAt": 1
+                    });
+                    await n.createIndex({
+                        "metadata.lastAccessed": 1
+                    });
+                    await n.createIndex({
+                        "metadata.filename": 1
+                    });
+                    t({
+                        bucket: e,
+                        store: n,
+                        db: i,
+                        mongoClient: o
+                    });
                 } else {
-                    if (s.busyTimeout) {
-                        i.configure("busyTimeout", s.busyTimeout);
+                    let e = "keyv";
+                    if (this.opts.collection) {
+                        e = this.opts.collection;
                     }
-                    t(i);
+                    const n = i.collection(e);
+                    await n.createIndex({
+                        key: 1
+                    }, {
+                        unique: true,
+                        background: true
+                    });
+                    await n.createIndex({
+                        expiresAt: 1
+                    }, {
+                        expireAfterSeconds: 0,
+                        background: true
+                    });
+                    t({
+                        store: n,
+                        mongoClient: o
+                    });
                 }
-            }));
-        })).then((t => ({
-            query: e(t.all).bind(t),
-            close: e(t.close).bind(t)
-        })));
-        this.opts = {
-            table: "keyv",
-            keySize: 255,
-            ...s
-        };
-        this.opts.table = i(this.opts.table);
-        const n = `CREATE TABLE IF NOT EXISTS ${this.opts.table}(key VARCHAR(${Number(this.opts.keySize)}) PRIMARY KEY, value TEXT )`;
-        const o = this.opts.connect().then((async t => t.query(n).then((() => t)))).catch((t => this.emit("error", t)));
-        this.query = async (t, ...e) => o.then((async s => s.query(t, ...e)));
-        this.close = async () => o.then((t => t.close()));
+            } catch (t) {
+                this.emit("error", t);
+            }
+        }));
     }
     async get(t) {
-        const e = `SELECT * FROM ${this.opts.table} WHERE key = ?`;
-        const s = await this.query(e, t);
-        const a = s[0];
-        if (a === void 0) {
+        const n = await this.connect;
+        if (this.opts.useGridFS) {
+            await n.store.updateOne({
+                filename: t
+            }, {
+                $set: {
+                    "metadata.lastAccessed": new Date
+                }
+            });
+            const s = n.bucket.openDownloadStreamByName(t);
+            return new Promise((t => {
+                const n = [];
+                s.on("error", (() => {
+                    t(void 0);
+                }));
+                s.on("end", (() => {
+                    const s = e.concat(n).toString("utf8");
+                    t(s);
+                }));
+                s.on("data", (t => {
+                    n.push(t);
+                }));
+            }));
+        }
+        const s = await n.store.findOne({
+            key: {
+                $eq: t
+            }
+        });
+        if (!s) {
             return void 0;
         }
-        return a.value;
+        return s.value;
     }
     async getMany(t) {
-        const e = `SELECT * FROM ${this.opts.table} WHERE key IN (SELECT value FROM json_each(?))`;
-        const s = await this.query(e, JSON.stringify(t));
-        return t.map((t => {
-            const e = s.find((e => e.key === t));
-            return e ? e.value : void 0;
-        }));
+        if (this.opts.useGridFS) {
+            const e = [];
+            for (const n of t) {
+                e.push(this.get(n));
+            }
+            const n = await Promise.allSettled(e);
+            const s = [];
+            for (const t of n) {
+                s.push(t.value);
+            }
+            return s;
+        }
+        const e = await this.connect;
+        const n = await e.store.s.db.collection(this.opts.collection).find({
+            key: {
+                $in: t
+            }
+        }).project({
+            _id: 0,
+            value: 1,
+            key: 1
+        }).toArray();
+        const s = [ ...t ];
+        let a = 0;
+        for (const e of t) {
+            const t = n.findIndex((t => t.key === e));
+            s[a] = t > -1 ? n[t].value : void 0;
+            a++;
+        }
+        return s;
     }
-    async set(t, e) {
-        const s = `INSERT INTO ${this.opts.table} (key, value)\n\t\t\tVALUES(?, ?) \n\t\t\tON CONFLICT(key) \n\t\t\tDO UPDATE SET value=excluded.value;`;
-        return this.query(s, t, e);
+    async set(t, e, n) {
+        const s = typeof n === "number" ? new Date(Date.now() + n) : null;
+        if (this.opts.useGridFS) {
+            const n = await this.connect;
+            const a = n.bucket.openUploadStream(t, {
+                metadata: {
+                    expiresAt: s,
+                    lastAccessed: new Date
+                }
+            });
+            return new Promise((t => {
+                a.on("finish", (() => {
+                    t(a);
+                }));
+                a.end(e);
+            }));
+        }
+        const a = await this.connect;
+        await a.store.updateOne({
+            key: {
+                $eq: t
+            }
+        }, {
+            $set: {
+                key: t,
+                value: e,
+                expiresAt: s
+            }
+        }, {
+            upsert: true
+        });
     }
     async delete(t) {
-        const e = `SELECT * FROM ${this.opts.table} WHERE key = ?`;
-        const s = `DELETE FROM ${this.opts.table} WHERE key = ?`;
-        const a = await this.query(e, t);
-        const i = a[0];
-        if (i === void 0) {
+        if (typeof t !== "string") {
             return false;
         }
-        await this.query(s, t);
-        return true;
+        const e = await this.connect;
+        if (this.opts.useGridFS) {
+            try {
+                const n = e.db;
+                const a = new s(n, {
+                    bucketName: this.opts.collection
+                });
+                const o = await a.find({
+                    filename: t
+                }).toArray();
+                await e.bucket.delete(o[0]._id);
+                return true;
+            } catch {
+                return false;
+            }
+        }
+        const n = await e.store.deleteOne({
+            key: {
+                $eq: t
+            }
+        });
+        return n.deletedCount > 0;
     }
     async deleteMany(t) {
-        const e = `DELETE FROM ${this.opts.table} WHERE key IN (SELECT value FROM json_each(?))`;
-        const s = await this.getMany(t);
-        if (s.every((t => t === void 0))) {
-            return false;
+        const e = await this.connect;
+        if (this.opts.useGridFS) {
+            const n = e.db;
+            const a = new s(n, {
+                bucketName: this.opts.collection
+            });
+            const o = await a.find({
+                filename: {
+                    $in: t
+                }
+            }).toArray();
+            if (o.length === 0) {
+                return false;
+            }
+            await Promise.all(o.map((async t => e.bucket.delete(t._id))));
+            return true;
         }
-        await this.query(e, JSON.stringify(t));
-        return true;
+        const n = await e.store.deleteMany({
+            key: {
+                $in: t
+            }
+        });
+        return n.deletedCount > 0;
     }
     async clear() {
-        const t = `DELETE FROM ${this.opts.table} WHERE key LIKE ?`;
-        await this.query(t, this.namespace ? `${this.namespace}:%` : "%");
-    }
-    async* iterator(t) {
-        const e = Number.parseInt(this.opts.iterationLimit, 10) || 10;
-        async function* s(a, i, n) {
-            const o = `SELECT * FROM ${i.table} WHERE key LIKE ? LIMIT ? OFFSET ?`;
-            const r = await n(o, [ `${t ? t + ":" : ""}%`, e, a ]);
-            const c = [ ...r ];
-            if (c.length === 0) {
-                return;
+        const t = await this.connect;
+        if (this.opts.useGridFS) {
+            try {
+                await t.bucket.drop();
+            } catch (t) {
+                if (!(t instanceof a && t.code === 26)) {
+                    throw t;
+                }
             }
-            for (const t of c) {
-                a += 1;
-                yield [ t.key, t.value ];
+        }
+        await t.store.deleteMany({
+            key: {
+                $regex: this.namespace ? `^${this.namespace}:*` : ""
             }
-            yield* s(a, i, n);
+        });
+    }
+    async clearExpired() {
+        if (!this.opts.useGridFS) {
+            return false;
         }
-        yield* s(0, this.opts, this.query);
+        return this.connect.then((async t => {
+            const e = t.db;
+            const n = new s(e, {
+                bucketName: this.opts.collection
+            });
+            return n.find({
+                "metadata.expiresAt": {
+                    $lte: new Date(Date.now())
+                }
+            }).toArray().then((async e => Promise.all(e.map((async e => t.bucket.delete(e._id)))).then((() => true))));
+        }));
+    }
+    async clearUnusedFor(t) {
+        if (!this.opts.useGridFS) {
+            return false;
+        }
+        const e = await this.connect;
+        const n = e.db;
+        const a = new s(n, {
+            bucketName: this.opts.collection
+        });
+        const o = await a.find({
+            "metadata.lastAccessed": {
+                $lte: new Date(Date.now() - t * 1e3)
+            }
+        }).toArray();
+        await Promise.all(o.map((async t => e.bucket.delete(t._id))));
+        return true;
+    }
+    async* iterator(t) {
+        const e = await this.connect;
+        const n = new RegExp(`^${t ? t + ":" : ".*"}`);
+        const s = this.opts.useGridFS ? e.store.find({
+            filename: n
+        }).map((async t => [ t.filename, await this.get(t.filename) ])) : e.store.find({
+            key: n
+        }).map((t => [ t.key, t.value ]));
+        yield* s;
     }
     async has(t) {
-        const e = `SELECT EXISTS ( SELECT * FROM ${this.opts.table} WHERE key = ? )`;
-        const s = await this.query(e, t);
-        return Object.values(s[0])[0] === 1;
+        const e = await this.connect;
+        const n = {
+            [this.opts.useGridFS ? "filename" : "key"]: {
+                $eq: t
+            }
+        };
+        const s = await e.store.count(n);
+        return s !== 0;
     }
     async disconnect() {
-        await this.close();
+        const t = await this.connect;
+        await t.mongoClient.close();
     }
 };
 
-var o = t => new s({
-    store: new n(t)
-});
-
-var r = n;
+var c = i;
 
-export { n as KeyvSqlite, o as createKeyv, r as default };
+export { i as KeyvMongo, c as default };

package/vendor/Package.611.cjs

@@ -6,9 +6,11 @@ Object.defineProperty(exports, Symbol.toStringTag, {
 
 const t = require("events");
 
-const e = require("./Package.66.cjs");
+const e = require("util");
 
-const s = require("pg");
+const s = require("./Package.67.cjs");
+
+const i = require("sqlite3");
 
 require("buffer");
 
@@ -16,160 +18,140 @@ const a = t => t && t.__esModule ? t : {
     default: t
 };
 
-const i = a(t);
-
-const o = a(s);
-
-var r;
+const n = a(t);
 
-var n;
-
-var c = (t, e = {}) => {
-    if (n !== t) {
-        r = void 0;
-        n = t;
-    }
-    r ??= new o.default.Pool({
-        connectionString: t,
-        ...e
-    });
-    return r;
-};
+const r = a(i);
 
-var h = async () => {
-    await r.end();
-    n = void 0;
-};
+var o = t => String(t).search(/^[a-zA-Z]+$/) < 0 ? "_" + t : t;
 
-var u = class extends i.default {
+var c = class extends n.default {
     ttlSupport;
     opts;
-    query;
     namespace;
+    close;
+    query;
     constructor(t) {
         super();
         this.ttlSupport = false;
+        let s = {
+            dialect: "sqlite",
+            uri: "sqlite://:memory:"
+        };
         if (typeof t === "string") {
-            const e = t;
-            t = {
-                dialect: "postgres",
-                uri: e
-            };
+            s.uri = t;
         } else {
-            t = {
-                dialect: "postgres",
-                uri: "postgresql://localhost:5432",
+            s = {
+                ...s,
                 ...t
             };
         }
-        const e = async () => {
-            const e = c(t.uri, t);
-            return async (t, s) => {
-                const a = await e.query(t, s);
-                return a.rows;
-            };
-        };
+        s.db = s.uri.replace(/^sqlite:\/\//, "");
+        s.connect = async () => new Promise(((t, e) => {
+            const i = new r.default.Database(s.db, (a => {
+                if (a) {
+                    e(a);
+                } else {
+                    if (s.busyTimeout) {
+                        i.configure("busyTimeout", s.busyTimeout);
+                    }
+                    t(i);
+                }
+            }));
+        })).then((t => ({
+            query: e.promisify(t.all).bind(t),
+            close: e.promisify(t.close).bind(t)
+        })));
         this.opts = {
             table: "keyv",
-            schema: "public",
             keySize: 255,
-            ...t
+            ...s
         };
-        let s = `CREATE${this.opts.useUnloggedTable ? " UNLOGGED " : " "}TABLE IF NOT EXISTS ${this.opts.schema}.${this.opts.table}(key VARCHAR(${Number(this.opts.keySize)}) PRIMARY KEY, value TEXT )`;
-        if (this.opts.schema !== "public") {
-            s = `CREATE SCHEMA IF NOT EXISTS ${this.opts.schema}; ${s}`;
-        }
-        const a = e().then((async t => {
-            try {
-                await t(s);
-            } catch (e) {
-                if (e.code !== "23505") {
-                    this.emit("error", e);
-                }
-                return t;
-            }
-            return t;
-        })).catch((t => this.emit("error", t)));
-        this.query = async (t, e) => a.then((s => s(t, e)));
+        this.opts.table = o(this.opts.table);
+        const i = `CREATE TABLE IF NOT EXISTS ${this.opts.table}(key VARCHAR(${Number(this.opts.keySize)}) PRIMARY KEY, value TEXT )`;
+        const a = this.opts.connect().then((async t => t.query(i).then((() => t)))).catch((t => this.emit("error", t)));
+        this.query = async (t, ...e) => a.then((async s => s.query(t, ...e)));
+        this.close = async () => a.then((t => t.close()));
     }
     async get(t) {
-        const e = `SELECT * FROM ${this.opts.schema}.${this.opts.table} WHERE key = $1`;
-        const s = await this.query(e, [ t ]);
-        const a = s[0];
-        return a === void 0 ? void 0 : a.value;
+        const e = `SELECT * FROM ${this.opts.table} WHERE key = ?`;
+        const s = await this.query(e, t);
+        const i = s[0];
+        if (i === void 0) {
+            return void 0;
+        }
+        return i.value;
     }
     async getMany(t) {
-        const e = `SELECT * FROM ${this.opts.schema}.${this.opts.table} WHERE key = ANY($1)`;
-        const s = await this.query(e, [ t ]);
-        const a = [];
-        for (const e of t) {
-            const t = s?.findIndex((t => t.key === e));
-            a.push(t > -1 ? s[t].value : void 0);
-        }
-        return a;
+        const e = `SELECT * FROM ${this.opts.table} WHERE key IN (SELECT value FROM json_each(?))`;
+        const s = await this.query(e, JSON.stringify(t));
+        return t.map((t => {
+            const e = s.find((e => e.key === t));
+            return e ? e.value : void 0;
+        }));
     }
     async set(t, e) {
-        const s = `INSERT INTO ${this.opts.schema}.${this.opts.table} (key, value)\n      VALUES($1, $2) \n      ON CONFLICT(key) \n      DO UPDATE SET value=excluded.value;`;
-        await this.query(s, [ t, e ]);
+        const s = `INSERT INTO ${this.opts.table} (key, value)\n\t\t\tVALUES(?, ?) \n\t\t\tON CONFLICT(key) \n\t\t\tDO UPDATE SET value=excluded.value;`;
+        return this.query(s, t, e);
     }
     async delete(t) {
-        const e = `SELECT * FROM ${this.opts.schema}.${this.opts.table} WHERE key = $1`;
-        const s = `DELETE FROM ${this.opts.schema}.${this.opts.table} WHERE key = $1`;
-        const a = await this.query(e, [ t ]);
-        if (a[0] === void 0) {
+        const e = `SELECT * FROM ${this.opts.table} WHERE key = ?`;
+        const s = `DELETE FROM ${this.opts.table} WHERE key = ?`;
+        const i = await this.query(e, t);
+        const a = i[0];
+        if (a === void 0) {
             return false;
         }
-        await this.query(s, [ t ]);
+        await this.query(s, t);
         return true;
     }
     async deleteMany(t) {
-        const e = `SELECT * FROM ${this.opts.schema}.${this.opts.table} WHERE key = ANY($1)`;
-        const s = `DELETE FROM ${this.opts.schema}.${this.opts.table} WHERE key = ANY($1)`;
-        const a = await this.query(e, [ t ]);
-        if (a[0] === void 0) {
+        const e = `DELETE FROM ${this.opts.table} WHERE key IN (SELECT value FROM json_each(?))`;
+        const s = await this.getMany(t);
+        if (s.every((t => t === void 0))) {
             return false;
         }
-        await this.query(s, [ t ]);
+        await this.query(e, JSON.stringify(t));
         return true;
     }
     async clear() {
-        const t = `DELETE FROM ${this.opts.schema}.${this.opts.table} WHERE key LIKE $1`;
-        await this.query(t, [ this.namespace ? `${this.namespace}:%` : "%" ]);
+        const t = `DELETE FROM ${this.opts.table} WHERE key LIKE ?`;
+        await this.query(t, this.namespace ? `${this.namespace}:%` : "%");
     }
     async* iterator(t) {
-        const e = Number.parseInt(String(this.opts.iterationLimit), 10) || 10;
-        async function* s(a, i, o) {
-            const r = `SELECT * FROM ${i.schema}.${i.table} WHERE key LIKE $1 LIMIT $2 OFFSET $3`;
-            const n = await o(r, [ `${t ? t + ":" : ""}%`, e, a ]);
-            if (n.length === 0) {
+        const e = Number.parseInt(this.opts.iterationLimit, 10) || 10;
+        async function* s(i, a, n) {
+            const r = `SELECT * FROM ${a.table} WHERE key LIKE ? LIMIT ? OFFSET ?`;
+            const o = await n(r, [ `${t ? t + ":" : ""}%`, e, i ]);
+            const c = [ ...o ];
+            if (c.length === 0) {
                 return;
             }
-            for (const t of n) {
-                a += 1;
+            for (const t of c) {
+                i += 1;
                 yield [ t.key, t.value ];
             }
-            yield* s(a, i, o);
+            yield* s(i, a, n);
         }
         yield* s(0, this.opts, this.query);
     }
     async has(t) {
-        const e = `SELECT EXISTS ( SELECT * FROM ${this.opts.schema}.${this.opts.table} WHERE key = $1 )`;
-        const s = await this.query(e, [ t ]);
-        return s[0].exists;
+        const e = `SELECT EXISTS ( SELECT * FROM ${this.opts.table} WHERE key = ? )`;
+        const s = await this.query(e, t);
+        return Object.values(s[0])[0] === 1;
     }
     async disconnect() {
-        await h();
+        await this.close();
     }
 };
 
-var E = t => new e.index_default({
-    store: new u(t)
+var u = t => new s.index_default({
+    store: new c(t)
 });
 
-var y = u;
+var l = c;
 
-exports.KeyvPostgres = u;
+exports.KeyvSqlite = c;
 
-exports.createKeyv = E;
+exports.createKeyv = u;
 
-exports.default = y;
+exports.default = l;