lakutata 2.0.65 → 2.0.67

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.1.d.ts

@@ -276,4 +276,4 @@ declare class Time extends Date {
     clone(): Time;
 }
 
-export { Time as T };
+export { Time };

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

@@ -11,4 +11,4 @@ interface IPatRun {
     toJSON(): string;
 }
 
-export type { ActionPattern as A, IPatRun as I };
+export type { ActionPattern, IPatRun };

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

@@ -1,7 +1,7 @@
-import { I as IConstructor } from './TypeDef.internal.9.js';
+import { IConstructor } from './TypeDef.internal.9.js';
 
 type ClassDecorator<Constructor extends IConstructor> = (target: Constructor) => Constructor | void;
 
 type PropertyDecorator<ClassPrototype> = (target: ClassPrototype, propertyKey: string | symbol) => void;
 
-export type { ClassDecorator as C, PropertyDecorator as P };
+export type { ClassDecorator, PropertyDecorator };

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

@@ -1,4 +1,4 @@
-import { k as OrderByCondition } from './TypeDef.internal.4.js';
+import { OrderByCondition } from './TypeDef.internal.4.js';
 
 /**
  * Describes all index options.
@@ -104,4 +104,4 @@ interface EntityOptions {
     comment?: string;
 }
 
-export type { EntityOptions as E, IndexOptions as I };
+export type { EntityOptions, IndexOptions };

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

@@ -1,8 +1,8 @@
-import { P as Provider, B as BaseObject, I as IBaseObjectConstructor, a as Container, M as Module, C as Component } from './TypeDef.internal.3.js';
-import { D as DTO, J as JSONSchema, F as FunctionSchema } from './TypeDef.internal.5.js';
-import { A as ActionPattern, I as IPatRun } from './TypeDef.internal.10.js';
+import { Provider, BaseObject, IBaseObjectConstructor, Container, Module, Component } from './TypeDef.internal.3.js';
+import { DTO, JSONSchema, FunctionSchema } from './TypeDef.internal.5.js';
+import { ActionPattern, IPatRun } from './TypeDef.internal.10.js';
 import { IncomingMessage, ServerResponse } from 'node:http';
-import { E as Exception } from './TypeDef.internal.7.js';
+import { Exception } from './TypeDef.internal.7.js';
 
 /**
  * Context types
@@ -411,5 +411,5 @@ declare class Entrypoint extends Component {
     getCliActions(): EntrypointActions<CLIActionInfo>;
 }
 
-export { BuildCLIEntrypoint as l, BuildHTTPEntrypoint as m, BuildServiceEntrypoint as n, BuildEntrypoints as o, Entrypoint as p, ContextType as q, BaseContext as r, CLIContext as s, HTTPContext as t, ServiceContext as u, Controller as w, AccessControlRule as y };
-export type { ActionGroupInfo as A, BaseActionInfo as B, CLIEntrypoint as C, EntrypointDestroyer as E, HTTPEntrypoint as H, ServiceEntrypoint as S, CLIMap as a, HTTPRouteMap as b, CLIEntrypointHandler as c, HTTPEntrypointHandler as d, ServiceEntrypointHandler as e, EntrypointDestroyerRegistrar as f, EntrypointOptions as g, HTTPActionInfo as h, ServiceActionInfo as i, CLIActionInfo as j, EntrypointActions as k, ControllerProperty as v, AccessControlRuleHandler as x };
+export { AccessControlRule, BaseContext, BuildCLIEntrypoint, BuildEntrypoints, BuildHTTPEntrypoint, BuildServiceEntrypoint, CLIContext, ContextType, Controller, Entrypoint, HTTPContext, ServiceContext };
+export type { AccessControlRuleHandler, ActionGroupInfo, BaseActionInfo, CLIActionInfo, CLIEntrypoint, CLIEntrypointHandler, CLIMap, ControllerProperty, EntrypointActions, EntrypointDestroyer, EntrypointDestroyerRegistrar, EntrypointOptions, HTTPActionInfo, HTTPEntrypoint, HTTPEntrypointHandler, HTTPRouteMap, ServiceActionInfo, ServiceEntrypoint, ServiceEntrypointHandler };

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

@@ -1,4 +1,4 @@
-import { D as DTO } from './TypeDef.internal.5.js';
+import { DTO } from './TypeDef.internal.5.js';
 import './TypeDef.internal.2.js';
 
 /**
@@ -979,5 +979,5 @@ declare class Container {
     destroy(): Promise<void>;
 }
 
-export { BaseObject as B, Component as C, Module as M, OverridableNamedObjectOptions as O, Provider as P, Container as a, ModuleOptions as b, ModuleConfigLoader as c, LoadObjectOptions as d, LoadAnonymousObjectOptions as h, LoadNamedObjectOptions as i, ModuleLoadObjectsOptions as j, OverridableObjectOptions as k };
-export type { EventAndListener as E, IBaseObjectConstructor as I, LifetimeType as L, ConstructorOptions as e, event as f, ListenerFn as g };
+export { BaseObject, Component, Container, LoadAnonymousObjectOptions, LoadNamedObjectOptions, LoadObjectOptions, Module, ModuleConfigLoader, ModuleLoadObjectsOptions, ModuleOptions, OverridableNamedObjectOptions, OverridableObjectOptions, Provider };
+export type { ConstructorOptions, EventAndListener, IBaseObjectConstructor, LifetimeType, ListenerFn, event };