@keyv/mongo 3.0.0-rc.1 → 3.0.1

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2017-2021 Luke Childs
+Copyright (c) 2021-2022 Jared Wray
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,4 +1,4 @@
-# @keyv/mongo [<img width="100" align="right" src="https://jaredwray.com/images/keyv.svg" alt="keyv">](https://github.com/jaredwra/keyv)
+# @keyv/mongo [<img width="100" align="right" src="https://jaredwray.com/images/keyv-symbol.svg" alt="keyv">](https://github.com/jaredwra/keyv)
 
 > MongoDB storage adapter for Keyv
 
@@ -20,9 +20,10 @@ npm install --save keyv @keyv/mongo
 ## Usage
 
 ```js
-const Keyv = require('keyv');
+import Keyv from 'keyv';
+import KeyvMongo from '@keyv/mongo';
 
-const keyv = new Keyv('mongodb://user:pass@localhost:27017/dbname');
+const keyv = new Keyv(new KeyvMongo('mongodb://user:pass@localhost:27017/dbname'));
 keyv.on('error', handleConnectionError);
 ```
 
@@ -36,4 +37,4 @@ const keyv = new Keyv('mongodb://user:pass@localhost:27017/dbname', { collection
 
 ## License
 
-MIT © Jared Wray
+[MIT © Jared Wray](LISCENCE)

package/dist/index.cjs

@@ -0,0 +1,303 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  KeyvMongo: () => KeyvMongo,
+  default: () => src_default
+});
+module.exports = __toCommonJS(src_exports);
+var import_events = __toESM(require("events"), 1);
+var import_buffer = require("buffer");
+var import_mongodb = require("mongodb");
+var keyvMongoKeys = /* @__PURE__ */ new Set(["url", "collection", "namespace", "serialize", "deserialize", "uri", "useGridFS", "dialect"]);
+var KeyvMongo = class extends import_events.default {
+  ttlSupport = false;
+  opts;
+  connect;
+  namespace;
+  constructor(url, options) {
+    super();
+    url ??= {};
+    if (typeof url === "string") {
+      url = { url };
+    }
+    if (url.uri) {
+      url = { url: url.uri, ...url };
+    }
+    this.opts = {
+      url: "mongodb://127.0.0.1:27017",
+      collection: "keyv",
+      ...url,
+      ...options
+    };
+    delete this.opts.emitErrors;
+    const mongoOptions = Object.fromEntries(
+      Object.entries(this.opts).filter(
+        ([k]) => !keyvMongoKeys.has(k)
+      )
+    );
+    this.opts = Object.fromEntries(
+      Object.entries(this.opts).filter(
+        ([k]) => keyvMongoKeys.has(k)
+      )
+    );
+    this.connect = new Promise(async (resolve, reject) => {
+      try {
+        let url2 = "";
+        if (this.opts.url) {
+          url2 = this.opts.url;
+        }
+        const client = new import_mongodb.MongoClient(url2, mongoOptions);
+        await client.connect();
+        const database = client.db(this.opts.db);
+        if (this.opts.useGridFS) {
+          const bucket = new import_mongodb.GridFSBucket(database, {
+            readPreference: this.opts.readPreference,
+            bucketName: this.opts.collection
+          });
+          const store = database.collection(`${this.opts.collection}.files`);
+          await store.createIndex({ uploadDate: -1 });
+          await store.createIndex({ "metadata.expiresAt": 1 });
+          await store.createIndex({ "metadata.lastAccessed": 1 });
+          await store.createIndex({ "metadata.filename": 1 });
+          resolve({
+            bucket,
+            store,
+            db: database,
+            mongoClient: client
+          });
+        } else {
+          let collection = "keyv";
+          if (this.opts.collection) {
+            collection = this.opts.collection;
+          }
+          const store = database.collection(collection);
+          await store.createIndex({ key: 1 }, { unique: true, background: true });
+          await store.createIndex({ expiresAt: 1 }, { expireAfterSeconds: 0, background: true });
+          resolve({ store, mongoClient: client });
+        }
+      } catch (error) {
+        this.emit("error", error);
+        reject(error);
+      }
+    });
+  }
+  async get(key) {
+    const client = await this.connect;
+    if (this.opts.useGridFS) {
+      await client.store.updateOne({
+        filename: key
+      }, {
+        $set: {
+          "metadata.lastAccessed": /* @__PURE__ */ new Date()
+        }
+      });
+      const stream = client.bucket.openDownloadStreamByName(key);
+      return new Promise((resolve) => {
+        const resp = [];
+        stream.on("error", () => {
+          resolve(void 0);
+        });
+        stream.on("end", () => {
+          const data = import_buffer.Buffer.concat(resp).toString("utf8");
+          resolve(data);
+        });
+        stream.on("data", (chunk) => {
+          resp.push(chunk);
+        });
+      });
+    }
+    const document = await client.store.findOne({ key: { $eq: key } });
+    if (!document) {
+      return void 0;
+    }
+    return document.value;
+  }
+  async getMany(keys) {
+    if (this.opts.useGridFS) {
+      const promises = [];
+      for (const key of keys) {
+        promises.push(this.get(key));
+      }
+      const values2 = await Promise.allSettled(promises);
+      const data = [];
+      for (const value of values2) {
+        data.push(value.value);
+      }
+      return data;
+    }
+    const connect = await this.connect;
+    const values = await connect.store.s.db.collection(this.opts.collection).find({ key: { $in: keys } }).project({ _id: 0, value: 1, key: 1 }).toArray();
+    const results = [...keys];
+    let i = 0;
+    for (const key of keys) {
+      const rowIndex = values.findIndex((row) => row.key === key);
+      results[i] = rowIndex > -1 ? values[rowIndex].value : void 0;
+      i++;
+    }
+    return results;
+  }
+  async set(key, value, ttl) {
+    const expiresAt = typeof ttl === "number" ? new Date(Date.now() + ttl) : null;
+    if (this.opts.useGridFS) {
+      const client2 = await this.connect;
+      const stream = client2.bucket.openUploadStream(key, {
+        metadata: {
+          expiresAt,
+          lastAccessed: /* @__PURE__ */ new Date()
+        }
+      });
+      return new Promise((resolve) => {
+        stream.on("finish", () => {
+          resolve(stream);
+        });
+        stream.end(value);
+      });
+    }
+    const client = await this.connect;
+    await client.store.updateOne(
+      { key: { $eq: key } },
+      { $set: { key, value, expiresAt } },
+      { upsert: true }
+    );
+  }
+  async delete(key) {
+    if (typeof key !== "string") {
+      return false;
+    }
+    const client = await this.connect;
+    if (this.opts.useGridFS) {
+      try {
+        const connection = client.db;
+        const bucket = new import_mongodb.GridFSBucket(connection, {
+          bucketName: this.opts.collection
+        });
+        const files = await bucket.find({ filename: key }).toArray();
+        await client.bucket.delete(files[0]._id);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    const object = await client.store.deleteOne({ key: { $eq: key } });
+    return object.deletedCount > 0;
+  }
+  async deleteMany(keys) {
+    const client = await this.connect;
+    if (this.opts.useGridFS) {
+      const connection = client.db;
+      const bucket = new import_mongodb.GridFSBucket(connection, {
+        bucketName: this.opts.collection
+      });
+      const files = await bucket.find({ filename: { $in: keys } }).toArray();
+      if (files.length === 0) {
+        return false;
+      }
+      await Promise.all(files.map(async (file) => client.bucket.delete(file._id)));
+      return true;
+    }
+    const object = await client.store.deleteMany({ key: { $in: keys } });
+    return object.deletedCount > 0;
+  }
+  async clear() {
+    const client = await this.connect;
+    if (this.opts.useGridFS) {
+      try {
+        await client.bucket.drop();
+      } catch (error) {
+        if (!(error instanceof import_mongodb.MongoServerError && error.code === 26)) {
+          throw error;
+        }
+      }
+    }
+    await client.store.deleteMany({
+      key: { $regex: this.namespace ? `^${this.namespace}:*` : "" }
+    });
+  }
+  async clearExpired() {
+    if (!this.opts.useGridFS) {
+      return false;
+    }
+    return this.connect.then(async (client) => {
+      const connection = client.db;
+      const bucket = new import_mongodb.GridFSBucket(connection, {
+        bucketName: this.opts.collection
+      });
+      return bucket.find({
+        "metadata.expiresAt": {
+          $lte: new Date(Date.now())
+        }
+      }).toArray().then(async (expiredFiles) => Promise.all(expiredFiles.map(async (file) => client.bucket.delete(file._id))).then(() => true));
+    });
+  }
+  async clearUnusedFor(seconds) {
+    if (!this.opts.useGridFS) {
+      return false;
+    }
+    const client = await this.connect;
+    const connection = client.db;
+    const bucket = new import_mongodb.GridFSBucket(connection, {
+      bucketName: this.opts.collection
+    });
+    const lastAccessedFiles = await bucket.find({
+      "metadata.lastAccessed": {
+        $lte: new Date(Date.now() - seconds * 1e3)
+      }
+    }).toArray();
+    await Promise.all(lastAccessedFiles.map(async (file) => client.bucket.delete(file._id)));
+    return true;
+  }
+  async *iterator(namespace) {
+    const client = await this.connect;
+    const regexp = new RegExp(`^${namespace ? namespace + ":" : ".*"}`);
+    const iterator = this.opts.useGridFS ? client.store.find({
+      filename: regexp
+    }).map(async (x) => [x.filename, await this.get(x.filename)]) : client.store.find({
+      key: regexp
+    }).map((x) => [x.key, x.value]);
+    yield* iterator;
+  }
+  async has(key) {
+    const client = await this.connect;
+    const filter = { [this.opts.useGridFS ? "filename" : "key"]: { $eq: key } };
+    const document = await client.store.count(filter);
+    return document !== 0;
+  }
+  async disconnect() {
+    const client = await this.connect;
+    await client.mongoClient.close();
+  }
+};
+var src_default = KeyvMongo;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  KeyvMongo
+});

package/dist/{esm/index.d.ts → index.d.cts}

@@ -1,7 +1,28 @@
-/// <reference types="node" />
 import EventEmitter from 'events';
-import { KeyvStoreAdapter, type StoredData } from 'keyv';
-import { type KeyvMongoConnect, type KeyvMongoOptions, type Options } from './types';
+import { KeyvStoreAdapter, StoredData } from 'keyv';
+import { ReadPreference, GridFSBucket, Collection, Db, MongoClient } from 'mongodb';
+
+type Options = {
+    [key: string]: unknown;
+    url?: string | undefined;
+    collection?: string;
+    namespace?: string;
+    serialize?: any;
+    deserialize?: any;
+    useGridFS?: boolean;
+    uri?: string;
+    dialect?: string;
+    db?: string;
+    readPreference?: ReadPreference;
+};
+type KeyvMongoOptions = Options | string;
+type KeyvMongoConnect = {
+    bucket?: GridFSBucket;
+    store: Collection;
+    db?: Db;
+    mongoClient: MongoClient;
+};
+
 declare class KeyvMongo extends EventEmitter implements KeyvStoreAdapter {
     ttlSupport: boolean;
     opts: Options;
@@ -18,5 +39,7 @@ declare class KeyvMongo extends EventEmitter implements KeyvStoreAdapter {
     clearUnusedFor(seconds: number): Promise<boolean>;
     iterator(namespace?: string): AsyncGenerator<any[], void, void>;
     has(key: string): Promise<boolean>;
+    disconnect(): Promise<void>;
 }
-export default KeyvMongo;
+
+export { KeyvMongo, KeyvMongo as default };

package/dist/{cjs/index.d.ts → index.d.ts}

@@ -1,7 +1,28 @@
-/// <reference types="node" />
 import EventEmitter from 'events';
-import { KeyvStoreAdapter, type StoredData } from 'keyv';
-import { type KeyvMongoConnect, type KeyvMongoOptions, type Options } from './types';
+import { KeyvStoreAdapter, StoredData } from 'keyv';
+import { ReadPreference, GridFSBucket, Collection, Db, MongoClient } from 'mongodb';
+
+type Options = {
+    [key: string]: unknown;
+    url?: string | undefined;
+    collection?: string;
+    namespace?: string;
+    serialize?: any;
+    deserialize?: any;
+    useGridFS?: boolean;
+    uri?: string;
+    dialect?: string;
+    db?: string;
+    readPreference?: ReadPreference;
+};
+type KeyvMongoOptions = Options | string;
+type KeyvMongoConnect = {
+    bucket?: GridFSBucket;
+    store: Collection;
+    db?: Db;
+    mongoClient: MongoClient;
+};
+
 declare class KeyvMongo extends EventEmitter implements KeyvStoreAdapter {
     ttlSupport: boolean;
     opts: Options;
@@ -18,5 +39,7 @@ declare class KeyvMongo extends EventEmitter implements KeyvStoreAdapter {
     clearUnusedFor(seconds: number): Promise<boolean>;
     iterator(namespace?: string): AsyncGenerator<any[], void, void>;
     has(key: string): Promise<boolean>;
+    disconnect(): Promise<void>;
 }
-export default KeyvMongo;
+
+export { KeyvMongo, KeyvMongo as default };

package/dist/index.js

@@ -0,0 +1,272 @@
+// src/index.ts
+import EventEmitter from "events";
+import { Buffer } from "buffer";
+import {
+  MongoClient as mongoClient,
+  GridFSBucket,
+  MongoServerError
+} from "mongodb";
+var keyvMongoKeys = /* @__PURE__ */ new Set(["url", "collection", "namespace", "serialize", "deserialize", "uri", "useGridFS", "dialect"]);
+var KeyvMongo = class extends EventEmitter {
+  ttlSupport = false;
+  opts;
+  connect;
+  namespace;
+  constructor(url, options) {
+    super();
+    url ??= {};
+    if (typeof url === "string") {
+      url = { url };
+    }
+    if (url.uri) {
+      url = { url: url.uri, ...url };
+    }
+    this.opts = {
+      url: "mongodb://127.0.0.1:27017",
+      collection: "keyv",
+      ...url,
+      ...options
+    };
+    delete this.opts.emitErrors;
+    const mongoOptions = Object.fromEntries(
+      Object.entries(this.opts).filter(
+        ([k]) => !keyvMongoKeys.has(k)
+      )
+    );
+    this.opts = Object.fromEntries(
+      Object.entries(this.opts).filter(
+        ([k]) => keyvMongoKeys.has(k)
+      )
+    );
+    this.connect = new Promise(async (resolve, reject) => {
+      try {
+        let url2 = "";
+        if (this.opts.url) {
+          url2 = this.opts.url;
+        }
+        const client = new mongoClient(url2, mongoOptions);
+        await client.connect();
+        const database = client.db(this.opts.db);
+        if (this.opts.useGridFS) {
+          const bucket = new GridFSBucket(database, {
+            readPreference: this.opts.readPreference,
+            bucketName: this.opts.collection
+          });
+          const store = database.collection(`${this.opts.collection}.files`);
+          await store.createIndex({ uploadDate: -1 });
+          await store.createIndex({ "metadata.expiresAt": 1 });
+          await store.createIndex({ "metadata.lastAccessed": 1 });
+          await store.createIndex({ "metadata.filename": 1 });
+          resolve({
+            bucket,
+            store,
+            db: database,
+            mongoClient: client
+          });
+        } else {
+          let collection = "keyv";
+          if (this.opts.collection) {
+            collection = this.opts.collection;
+          }
+          const store = database.collection(collection);
+          await store.createIndex({ key: 1 }, { unique: true, background: true });
+          await store.createIndex({ expiresAt: 1 }, { expireAfterSeconds: 0, background: true });
+          resolve({ store, mongoClient: client });
+        }
+      } catch (error) {
+        this.emit("error", error);
+        reject(error);
+      }
+    });
+  }
+  async get(key) {
+    const client = await this.connect;
+    if (this.opts.useGridFS) {
+      await client.store.updateOne({
+        filename: key
+      }, {
+        $set: {
+          "metadata.lastAccessed": /* @__PURE__ */ new Date()
+        }
+      });
+      const stream = client.bucket.openDownloadStreamByName(key);
+      return new Promise((resolve) => {
+        const resp = [];
+        stream.on("error", () => {
+          resolve(void 0);
+        });
+        stream.on("end", () => {
+          const data = Buffer.concat(resp).toString("utf8");
+          resolve(data);
+        });
+        stream.on("data", (chunk) => {
+          resp.push(chunk);
+        });
+      });
+    }
+    const document = await client.store.findOne({ key: { $eq: key } });
+    if (!document) {
+      return void 0;
+    }
+    return document.value;
+  }
+  async getMany(keys) {
+    if (this.opts.useGridFS) {
+      const promises = [];
+      for (const key of keys) {
+        promises.push(this.get(key));
+      }
+      const values2 = await Promise.allSettled(promises);
+      const data = [];
+      for (const value of values2) {
+        data.push(value.value);
+      }
+      return data;
+    }
+    const connect = await this.connect;
+    const values = await connect.store.s.db.collection(this.opts.collection).find({ key: { $in: keys } }).project({ _id: 0, value: 1, key: 1 }).toArray();
+    const results = [...keys];
+    let i = 0;
+    for (const key of keys) {
+      const rowIndex = values.findIndex((row) => row.key === key);
+      results[i] = rowIndex > -1 ? values[rowIndex].value : void 0;
+      i++;
+    }
+    return results;
+  }
+  async set(key, value, ttl) {
+    const expiresAt = typeof ttl === "number" ? new Date(Date.now() + ttl) : null;
+    if (this.opts.useGridFS) {
+      const client2 = await this.connect;
+      const stream = client2.bucket.openUploadStream(key, {
+        metadata: {
+          expiresAt,
+          lastAccessed: /* @__PURE__ */ new Date()
+        }
+      });
+      return new Promise((resolve) => {
+        stream.on("finish", () => {
+          resolve(stream);
+        });
+        stream.end(value);
+      });
+    }
+    const client = await this.connect;
+    await client.store.updateOne(
+      { key: { $eq: key } },
+      { $set: { key, value, expiresAt } },
+      { upsert: true }
+    );
+  }
+  async delete(key) {
+    if (typeof key !== "string") {
+      return false;
+    }
+    const client = await this.connect;
+    if (this.opts.useGridFS) {
+      try {
+        const connection = client.db;
+        const bucket = new GridFSBucket(connection, {
+          bucketName: this.opts.collection
+        });
+        const files = await bucket.find({ filename: key }).toArray();
+        await client.bucket.delete(files[0]._id);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    const object = await client.store.deleteOne({ key: { $eq: key } });
+    return object.deletedCount > 0;
+  }
+  async deleteMany(keys) {
+    const client = await this.connect;
+    if (this.opts.useGridFS) {
+      const connection = client.db;
+      const bucket = new GridFSBucket(connection, {
+        bucketName: this.opts.collection
+      });
+      const files = await bucket.find({ filename: { $in: keys } }).toArray();
+      if (files.length === 0) {
+        return false;
+      }
+      await Promise.all(files.map(async (file) => client.bucket.delete(file._id)));
+      return true;
+    }
+    const object = await client.store.deleteMany({ key: { $in: keys } });
+    return object.deletedCount > 0;
+  }
+  async clear() {
+    const client = await this.connect;
+    if (this.opts.useGridFS) {
+      try {
+        await client.bucket.drop();
+      } catch (error) {
+        if (!(error instanceof MongoServerError && error.code === 26)) {
+          throw error;
+        }
+      }
+    }
+    await client.store.deleteMany({
+      key: { $regex: this.namespace ? `^${this.namespace}:*` : "" }
+    });
+  }
+  async clearExpired() {
+    if (!this.opts.useGridFS) {
+      return false;
+    }
+    return this.connect.then(async (client) => {
+      const connection = client.db;
+      const bucket = new GridFSBucket(connection, {
+        bucketName: this.opts.collection
+      });
+      return bucket.find({
+        "metadata.expiresAt": {
+          $lte: new Date(Date.now())
+        }
+      }).toArray().then(async (expiredFiles) => Promise.all(expiredFiles.map(async (file) => client.bucket.delete(file._id))).then(() => true));
+    });
+  }
+  async clearUnusedFor(seconds) {
+    if (!this.opts.useGridFS) {
+      return false;
+    }
+    const client = await this.connect;
+    const connection = client.db;
+    const bucket = new GridFSBucket(connection, {
+      bucketName: this.opts.collection
+    });
+    const lastAccessedFiles = await bucket.find({
+      "metadata.lastAccessed": {
+        $lte: new Date(Date.now() - seconds * 1e3)
+      }
+    }).toArray();
+    await Promise.all(lastAccessedFiles.map(async (file) => client.bucket.delete(file._id)));
+    return true;
+  }
+  async *iterator(namespace) {
+    const client = await this.connect;
+    const regexp = new RegExp(`^${namespace ? namespace + ":" : ".*"}`);
+    const iterator = this.opts.useGridFS ? client.store.find({
+      filename: regexp
+    }).map(async (x) => [x.filename, await this.get(x.filename)]) : client.store.find({
+      key: regexp
+    }).map((x) => [x.key, x.value]);
+    yield* iterator;
+  }
+  async has(key) {
+    const client = await this.connect;
+    const filter = { [this.opts.useGridFS ? "filename" : "key"]: { $eq: key } };
+    const document = await client.store.count(filter);
+    return document !== 0;
+  }
+  async disconnect() {
+    const client = await this.connect;
+    await client.mongoClient.close();
+  }
+};
+var src_default = KeyvMongo;
+export {
+  KeyvMongo,
+  src_default as default
+};