lakutata 2.0.66 → 2.0.68

package/vendor/Package.69.mjs

@@ -1,327 +1,127 @@
-import t from "events";
+import e from "events";
 
-import { Buffer as e } from "buffer";
+import t from "memjs";
 
-import { MongoClient as n, GridFSBucket as s, MongoServerError as a } from "mongodb";
+import { d as s } from "./Package.67.mjs";
 
-var o = new Set([ "url", "collection", "namespace", "serialize", "deserialize", "uri", "useGridFS", "dialect", "db" ]);
+import "buffer";
 
-var i = class extends t {
-    ttlSupport=false;
-    opts;
-    connect;
+var r = class extends e {
+    ttlSupport=true;
     namespace;
-    constructor(t, e) {
+    client;
+    opts;
+    constructor(e, s) {
         super();
-        t ??= {};
-        if (typeof t === "string") {
-            t = {
-                url: t
-            };
+        s = {
+            ...typeof e === "string" ? {
+                uri: e
+            } : e,
+            ...s
+        };
+        if (s.uri && s.url === void 0) {
+            s.url = s.uri;
         }
-        if (t.uri) {
-            t = {
-                url: t.uri,
-                ...t
-            };
+        if (e === void 0) {
+            e = "localhost:11211";
+            s.url = s.uri = e;
         }
-        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
-                    });
+        this.opts = s;
+        this.client = t.Client.create(e, s);
+    }
+    _getNamespace() {
+        return `namespace:${this.namespace}`;
+    }
+    async get(e) {
+        return new Promise(((t, r) => {
+            this.client.get(this.formatKey(e), ((e, i) => {
+                if (e) {
+                    this.emit("error", e);
+                    r(e);
                 } else {
-                    let e = "keyv";
-                    if (this.opts.collection) {
-                        e = this.opts.collection;
+                    let e;
+                    if (i === null) {
+                        e = {
+                            value: void 0,
+                            expires: 0
+                        };
+                    } else {
+                        e = this.opts.deserialize ? this.opts.deserialize(i) : s(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
-                    });
+                    t(e);
                 }
-            } catch (t) {
-                this.emit("error", t);
-            }
+            }));
         }));
     }
-    async get(t) {
-        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);
-                }));
-            }));
+    async getMany(e) {
+        const t = [];
+        for (const s of e) {
+            t.push(this.get(s));
         }
-        const s = await n.store.findOne({
-            key: {
-                $eq: t
+        return Promise.allSettled(t).then((e => {
+            const t = [];
+            for (const s of e) {
+                t.push(s.value);
             }
-        });
-        if (!s) {
-            return void 0;
-        }
-        return s.value;
+            return t;
+        }));
     }
-    async getMany(t) {
-        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;
+    async set(e, t, s) {
+        const r = {};
+        if (s !== void 0) {
+            r.expires = r.ttl = Math.floor(s / 1e3);
         }
-        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;
+        await this.client.set(this.formatKey(e), t, r);
     }
-    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
+    async delete(e) {
+        return new Promise(((t, s) => {
+            this.client.delete(this.formatKey(e), ((e, r) => {
+                if (e) {
+                    this.emit("error", e);
+                    s(e);
+                } else {
+                    t(Boolean(r));
                 }
-            });
-            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) {
-        if (typeof t !== "string") {
-            return false;
-        }
-        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 = 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;
-        }
-        const n = await e.store.deleteMany({
-            key: {
-                $in: t
-            }
-        });
-        return n.deletedCount > 0;
+    async deleteMany(e) {
+        const t = e.map((async e => this.delete(e)));
+        const s = await Promise.allSettled(t);
+        return s.every((e => e.value === true));
     }
     async clear() {
-        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;
-                }
-            }
-        }
-        await t.store.deleteMany({
-            key: {
-                $regex: this.namespace ? `^${this.namespace}:*` : ""
-            }
-        });
-    }
-    async clearExpired() {
-        if (!this.opts.useGridFS) {
-            return false;
-        }
-        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())
+        return new Promise(((e, t) => {
+            this.client.flush((s => {
+                if (s) {
+                    this.emit("error", s);
+                    t(s);
+                } else {
+                    e(void 0);
                 }
-            }).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;
+    formatKey(e) {
+        let t = e;
+        if (this.namespace) {
+            t = this.namespace.trim() + ":" + e.trim();
         }
-        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 = await this.connect;
-        const n = {
-            [this.opts.useGridFS ? "filename" : "key"]: {
-                $eq: t
-            }
-        };
-        const s = await e.store.count(n);
-        return s !== 0;
+        return t;
     }
-    async disconnect() {
-        const t = await this.connect;
-        await t.mongoClient.close();
+    async has(e) {
+        return new Promise((t => {
+            this.client.get(this.formatKey(e), ((e, s) => {
+                if (e) {
+                    t(false);
+                } else {
+                    t(s !== null);
+                }
+            }));
+        }));
     }
 };
 
-var c = i;
+var i = r;
 
-export { i as KeyvMongo, c as default };
+export { r as KeyvMemcache, i as default };

package/vendor/TypeDef.internal.13.d.ts

@@ -207,6 +207,7 @@ interface BaseActionInfo {
     readonly id: string;
     readonly acl: boolean;
     readonly name: string;
+    readonly description: string;
     readonly groups: string[];
     readonly controller: string;
     readonly method: string;

package/vendor/TypeDef.internal.5.d.ts

@@ -4137,4 +4137,4 @@ declare class DTO extends DataValidator {
 }
 
 export { DTO };
-export type { FunctionSchema, JSONSchema, Schema$1 as Schema };
+export type { AlternativesSchema, AnySchema, ArraySchema, BinarySchema, BooleanSchema, CustomValidator, DateSchema, FunctionSchema, JSONSchema, LinkSchema, NumberSchema, ObjectSchema, Reference, ReferenceOptions, Schema$1 as Schema, SchemaFunction, SchemaLike, StringSchema, SymbolSchema, ValidationOptions };