@aerokit/sdk 12.44.0

package/dist/cjs/mongodb/client.js

@@ -0,0 +1,627 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var client_exports = {};
+__export(client_exports, {
+  Client: () => Client,
+  DB: () => DB,
+  DBCollection: () => DBCollection,
+  DBCursor: () => DBCursor,
+  DBObject: () => DBObject,
+  createBasicDBObject: () => createBasicDBObject
+});
+module.exports = __toCommonJS(client_exports);
+var import_uuid = require("@aerokit/sdk/utils/uuid");
+const MongoDBFacade = Java.type("org.eclipse.dirigible.components.api.mongodb.MongoDBFacade");
+const TimeUnit = Java.type("java.util.concurrent.TimeUnit");
+class DBObject {
+  /**
+   * Constructs a new DBObject instance.
+   * @param native The native MongoDB object (e.g., com.mongodb.DBObject)
+   */
+  constructor(native) {
+    this.native = native;
+  }
+  /**
+   * Appends a key-value pair to the DBObject.
+   * @param key The field name.
+   * @param value The value to append.
+   * @returns The current DBObject instance for chaining.
+   */
+  append(key, value) {
+    this.native.append(key, value);
+    return this;
+  }
+  /**
+   * Converts the DBObject to a standard JavaScript object representation (JSON).
+   * @returns A plain JavaScript object.
+   */
+  toJson() {
+    return this.native.toJson();
+  }
+  /**
+   * Marks the object as a partial object (used internally by MongoDB driver).
+   */
+  markAsPartialObject() {
+    this.native.markAsPartialObject();
+  }
+  /**
+   * Checks if the object is a partial object.
+   * @returns True if partial, false otherwise.
+   */
+  isPartialObject() {
+    return this.native.isPartialObject();
+  }
+  /**
+   * Checks if the DBObject contains a field with the specified key.
+   * @param key The field name.
+   * @returns True if the field exists, false otherwise.
+   */
+  containsField(key) {
+    return this.native.containsField(key);
+  }
+  /**
+   * Gets the value associated with the given key.
+   * @param key The field name.
+   * @returns The field value.
+   */
+  get(key) {
+    return this.native.get(key);
+  }
+  /**
+   * Puts a key-value pair into the DBObject.
+   * @param key The field name.
+   * @param value The value to put.
+   * @returns The previous value associated with the key, or null.
+   */
+  put(key, value) {
+    return this.native.put(key, value);
+  }
+  /**
+   * Removes a field from the DBObject.
+   * @param key The field name to remove.
+   * @returns The removed field value.
+   */
+  removeField(key) {
+    return this.native.removeField(key);
+  }
+}
+function extract(dbObject) {
+  if (!dbObject.native) {
+    return {};
+  }
+  var extracted = JSON.parse(dbObject.native.toJson());
+  for (var propertyName in extracted) {
+    dbObject[propertyName] = extracted[propertyName];
+  }
+  return extracted;
+}
+function implicit(object) {
+  if (!object) {
+    return void 0;
+  }
+  if (object.native) {
+    return object;
+  }
+  var dbObject = createBasicDBObject();
+  for (var propertyName in object) {
+    dbObject.append(propertyName, object[propertyName]);
+  }
+  return dbObject;
+}
+function createBasicDBObject() {
+  const dbObject = new DBObject(MongoDBFacade.createBasicDBObject());
+  extract(dbObject);
+  return dbObject;
+}
+class Client {
+  /**
+   * Constructs a new MongoDB Client instance.
+   * @param uri The MongoDB connection URI.
+   * @param user The username for authentication.
+   * @param password The password for authentication.
+   */
+  constructor(uri, user, password) {
+    this.native = MongoDBFacade.getClient(uri, user, password);
+  }
+  /**
+   * Retrieves a database instance.
+   * @param name Optional name of the database. If not provided, the default database name is used.
+   * @returns A DB instance.
+   */
+  getDB(name) {
+    let native = null;
+    if (name) {
+      native = this.native.getDB(name);
+    } else {
+      const defaultDB = MongoDBFacade.getDefaultDatabaseName();
+      native = this.native.getDB(defaultDB);
+    }
+    return new DB(native);
+  }
+}
+class DB {
+  /**
+   * Constructs a new DB instance.
+   * @param native The native MongoDB DB object.
+   */
+  constructor(native) {
+    this.native = native;
+  }
+  /**
+   * Retrieves a collection instance from the database.
+   * @param name The name of the collection.
+   * @returns A DBCollection instance.
+   */
+  getCollection(name) {
+    const native = this.native.getCollection(name);
+    return new DBCollection(native);
+  }
+}
+class DBCollection {
+  /**
+   * Constructs a new DBCollection instance.
+   * @param native The native MongoDB DBCollection object.
+   */
+  constructor(native) {
+    this.native = native;
+  }
+  /**
+   * Inserts a document into the collection.
+   * @param dbObject The document to insert (can be a plain JS object or DBObject).
+   */
+  insert(dbObject) {
+    const dbo = implicit(dbObject);
+    if (dbo) {
+      this.native.insert(dbo.native);
+    }
+  }
+  /**
+   * Finds documents matching the query.
+   * @param query The query specification (can be a plain JS object or DBObject).
+   * @param projection The fields to include or exclude (can be a plain JS object or DBObject).
+   * @returns A DBCursor for iterating over results.
+   */
+  find(query, projection) {
+    const q = implicit(query);
+    const p = implicit(projection);
+    var native = null;
+    if (q) {
+      if (p) {
+        native = this.native.find(q.native, p.native);
+      } else {
+        native = this.native.find(q.native);
+      }
+    } else {
+      native = this.native.find();
+    }
+    return new DBCursor(native);
+  }
+  /**
+   * Finds a single document matching the query.
+   * @param query The query specification.
+   * @param projection The fields to include or exclude.
+   * @param sort The sorting specification.
+   * @returns The found document as a DBObject.
+   */
+  findOne(query, projection, sort) {
+    const q = implicit(query);
+    const p = implicit(projection);
+    const s = implicit(sort);
+    var dbObject = createBasicDBObject();
+    var native = null;
+    if (q) {
+      if (p) {
+        if (s) {
+          native = this.native.findOne(q.native, p.native, s.native);
+        } else {
+          native = this.native.findOne(q.native, p.native);
+        }
+      } else {
+        native = this.native.findOne(q.native);
+      }
+    } else {
+      native = this.native.findOne();
+    }
+    dbObject.native = native;
+    extract(dbObject);
+    return dbObject;
+  }
+  /**
+   * Finds a single document by its string ID.
+   * @param id The string ID of the document.
+   * @param projection The fields to include or exclude.
+   * @returns The found document as a DBObject.
+   */
+  findOneById(id, projection) {
+    const p = implicit(projection);
+    const dbObject = createBasicDBObject();
+    let native = null;
+    if (p) {
+      native = this.native.findOne(id, p.native);
+    } else {
+      native = this.native.findOne(id);
+    }
+    dbObject.native = native;
+    extract(dbObject);
+    return dbObject;
+  }
+  /**
+   * Counts the number of documents in the collection, optionally filtered by a query.
+   * @param query Optional query to filter the count.
+   * @returns The number of documents.
+   */
+  count(query) {
+    const q = implicit(query);
+    if (q) {
+      return this.native.count(q.native);
+    }
+    return this.native.count();
+  }
+  /**
+   * Gets the count of documents (alias for count).
+   * @param query Optional query to filter the count.
+   * @returns The number of documents.
+   */
+  getCount(query) {
+    const q = implicit(query);
+    if (q) {
+      return this.native.getCount(q.native);
+    }
+    return this.native.getCount();
+  }
+  /**
+   * Creates an index on the collection.
+   * @param keys The index key specification.
+   * @param options Optional index options.
+   */
+  createIndex(keys, options) {
+    const k = implicit(keys);
+    const o = implicit(options);
+    if (k) {
+      if (o) {
+        this.native.createIndex(k.native, o.native);
+      } else {
+        this.native.createIndex(k.native);
+      }
+    } else {
+      throw new Error("At least Keys parameter must be provided");
+    }
+  }
+  /**
+   * Creates an index on a single field by name.
+   * @param name The name of the field to index.
+   */
+  createIndexForField(name) {
+    if (name) {
+      this.native.createIndex(name);
+    } else {
+      throw new Error("The filed name must be provided");
+    }
+  }
+  /**
+   * Retrieves the distinct values for a specified field across a collection.
+   * NOTE: The signature in the original code seems slightly off compared to typical MongoDB drivers.
+   * This implementation follows the original structure using `keys.native` if `keys` is provided.
+   * @param name The field name.
+   * @param query Optional query to filter results.
+   * @param keys Optional keys to use for distinct (replaces 'name' if provided and query exists).
+   */
+  distinct(name, query, keys) {
+    const q = implicit(query);
+    const k = implicit(keys);
+    if (name) {
+      if (q) {
+        this.native.distinct(k ? k.native : name, q.native);
+      } else {
+        this.native.distinct(name);
+      }
+    } else {
+      throw new Error("At least the filed name parameter must be provided");
+    }
+  }
+  /**
+   * Drops a specified index.
+   * @param index The name of the index or the DBObject representing the index keys.
+   */
+  dropIndex(index) {
+    if (typeof index === "string") {
+      this.native.dropIndex(index);
+    } else {
+      const dbo = implicit(index);
+      if (dbo) {
+        this.native.dropIndex(dbo.native);
+      }
+    }
+  }
+  /**
+   * Drops a specified index by name.
+   * @param name The name of the index.
+   */
+  dropIndexByName(name) {
+    this.native.dropIndex(name);
+  }
+  /**
+   * Drops all indexes on the collection.
+   */
+  dropIndexes() {
+    this.native.dropIndexes();
+  }
+  /**
+   * Removes documents from the collection matching the query.
+   * @param query The deletion query specification.
+   */
+  remove(query) {
+    const q = implicit(query);
+    if (q) {
+      this.native.remove(q.native);
+    }
+  }
+  /**
+   * Renames the collection.
+   * @param newName The new name for the collection.
+   */
+  rename(newName) {
+    this.native.rename(newName);
+  }
+  /**
+   * Saves a document to the collection. If the document has an `_id`, it performs an update;
+   * otherwise, it performs an insert.
+   * @param dbObject The document to save.
+   */
+  save(dbObject) {
+    const dbo = implicit(dbObject);
+    if (dbo) {
+      this.native.save(dbo.native);
+    }
+  }
+  /**
+   * Updates documents in the collection matching the query.
+   * @param query The update query specification.
+   * @param update The update operation specification (e.g., {$set: {...}}).
+   * @param upsert If true, creates a new document if no documents match the query.
+   * @param multi If true, updates all documents matching the query; otherwise, only one.
+   */
+  update(query, update, upsert, multi) {
+    const q = implicit(query);
+    const u = implicit(update);
+    if (q) {
+      if (u) {
+        if (upsert) {
+          if (multi) {
+            this.native.update(q.native, u.native, upsert, multi);
+          } else {
+            this.native.update(q.native, u.native, upsert);
+          }
+        } else {
+          this.native.update(q.native, u.native);
+        }
+      } else {
+        throw new Error("The update parameter must be provided");
+      }
+    } else {
+      throw new Error("The query parameter must be provided");
+    }
+  }
+  /**
+   * Updates multiple documents in the collection matching the query.
+   * (Equivalent to calling `update` with `multi=true` and `upsert=true` implicitly).
+   * @param query The update query specification.
+   * @param update The update operation specification.
+   */
+  updateMulti(query, update) {
+    const q = implicit(query);
+    const u = implicit(update);
+    if (q) {
+      if (u) {
+        this.native.update(q.native, u.native, true, true);
+      } else {
+        throw new Error("The update parameter must be provided");
+      }
+    } else {
+      throw new Error("The query parameter must be provided");
+    }
+  }
+  /**
+   * Calculates the next sequential ID based on the largest existing `_id` in the collection.
+   * Assumes `_id` is a numeric field.
+   * @returns The next available sequential ID (starting at 1 if collection is empty).
+   */
+  getNextId() {
+    var cursor = this.find({}, { "_id": 1 }).sort({ "_id": -1 }).limit(1);
+    if (!cursor.hasNext()) {
+      return 1;
+    } else {
+      return cursor.next()["_id"] + 1;
+    }
+  }
+  /**
+   * Generates a new random UUID (Universally Unique Identifier).
+   * @returns A string representing the UUID.
+   */
+  generateUUID() {
+    return import_uuid.UUID.random();
+  }
+}
+class DBCursor {
+  /**
+   * Constructs a new DBCursor instance.
+   * @param native The native MongoDB DBCursor object.
+   */
+  constructor(native) {
+    this.native = native;
+  }
+  /**
+   * Returns the single result from the cursor.
+   * @returns A DBObject representing the document.
+   */
+  one() {
+    const dbObject = new DBObject(this.native.one());
+    extract(dbObject);
+    return dbObject;
+  }
+  /**
+   * Sets the batch size for the cursor.
+   * @param numberOfElements The batch size.
+   * @returns The DBCursor instance for chaining.
+   */
+  batchSize(numberOfElements) {
+    this.native.batchSize(numberOfElements);
+    return this;
+  }
+  /**
+   * Gets the current batch size.
+   * @returns The batch size.
+   */
+  getBatchSize() {
+    return this.native.getBatchSize();
+  }
+  /**
+   * Gets the collection associated with this cursor.
+   * @returns The DBCollection instance.
+   */
+  getCollection() {
+    return new DBCollection(this.native.getCollection());
+  }
+  /**
+   * Gets the cursor ID.
+   * @returns The cursor ID string.
+   */
+  getCursorId() {
+    return this.native.getCursorId();
+  }
+  /**
+   * Gets the projection object (fields wanted) used in the query.
+   * @returns The projection DBObject.
+   */
+  getKeysWanted() {
+    const dbObject = new DBObject(this.native.getKeysWanted());
+    extract(dbObject);
+    return dbObject;
+  }
+  /**
+   * Gets the limit set on the cursor.
+   * @returns The limit number.
+   */
+  getLimit() {
+    return this.native.getLimit();
+  }
+  /**
+   * Closes the cursor.
+   */
+  close() {
+    this.native.close();
+  }
+  /**
+   * Checks if there is a next document in the cursor.
+   * @returns True if there is a next document, false otherwise.
+   */
+  hasNext() {
+    return this.native.hasNext();
+  }
+  /**
+   * Retrieves the next document in the cursor.
+   * @returns The next document as a DBObject.
+   */
+  next() {
+    const dbObject = new DBObject(this.native.next());
+    extract(dbObject);
+    return dbObject;
+  }
+  /**
+   * Gets the query object used to create this cursor.
+   * @returns The query DBObject.
+   */
+  getQuery() {
+    const dbObject = new DBObject(this.native.getQuery());
+    extract(dbObject);
+    return dbObject;
+  }
+  /**
+   * Gets the number of documents matched by the query.
+   * @returns The total number of documents.
+   */
+  length() {
+    return this.native.length();
+  }
+  /**
+   * Specifies the order in which the query returns the results.
+   * @param orderBy The sorting specification (e.g., {field: 1} for ascending).
+   * @returns The DBCursor instance for chaining.
+   */
+  sort(orderBy) {
+    const dbo = implicit(orderBy);
+    if (!dbo) {
+      throw new Error("The orderBy parameter must be provided");
+    }
+    this.native.sort(dbo.native);
+    return this;
+  }
+  /**
+   * Limits the number of results to be returned.
+   * @param limit The maximum number of documents to return.
+   * @returns The DBCursor instance for chaining.
+   */
+  limit(limit) {
+    this.native.limit(limit);
+    return this;
+  }
+  /**
+   * Specifies the exclusive upper bound for a specific index.
+   * @param min The minimum value.
+   * @returns The DBCursor instance for chaining.
+   */
+  min(min) {
+    this.native.min(min);
+    return this;
+  }
+  /**
+   * Specifies the exclusive upper bound for a specific index.
+   * @param max The maximum value.
+   * @returns The DBCursor instance for chaining.
+   */
+  max(max) {
+    this.native.max(max);
+    return this;
+  }
+  /**
+   * Sets a timeout for the server to execute the query.
+   * @param maxTime The maximum time in milliseconds.
+   * @returns The DBCursor instance for chaining.
+   */
+  maxTime(maxTime) {
+    this.native.maxTime(maxTime, TimeUnit.MILLISECONDS);
+    return this;
+  }
+  /**
+   * Gets the size of the result set.
+   * @returns The size number.
+   */
+  size() {
+    return this.native.size();
+  }
+  /**
+   * Skips the specified number of documents.
+   * @param numberOfElements The number of documents to skip.
+   * @returns The DBCursor instance for chaining.
+   */
+  skip(numberOfElements) {
+    this.native.skip(numberOfElements);
+    return this;
+  }
+}
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/mongodb/client.ts"],
  "sourcesContent": ["const MongoDBFacade = Java.type(\"org.eclipse.dirigible.components.api.mongodb.MongoDBFacade\");\nconst TimeUnit = Java.type(\"java.util.concurrent.TimeUnit\");\nimport { UUID } from \"@aerokit/sdk/utils/uuid\";\n\n/**\n * Define a common type for input to functions that accept either a plain JavaScript object\n * (which will be implicitly converted to DBObject) or an existing DBObject wrapper instance.\n */\ntype DBInput = { [key: string]: any } | DBObject | undefined | null;\n\n/**\n * DBObject object represents a BSON document used for queries, insertions, and updates.\n * It wraps the underlying native Java object.\n */\nexport class DBObject {\n\n    /**\n     * The underlying native Java object representing the BSON document.\n     * @private\n     */\n    public native: any;\n\n    /**\n     * Constructs a new DBObject instance.\n     * @param native The native MongoDB object (e.g., com.mongodb.DBObject)\n     */\n    constructor(native: any) {\n        this.native = native;\n    }\n\n    /**\n     * Appends a key-value pair to the DBObject.\n     * @param key The field name.\n     * @param value The value to append.\n     * @returns The current DBObject instance for chaining.\n     */\n    public append(key: string, value: any): DBObject {\n        this.native.append(key, value);\n        return this;\n    }\n\n    /**\n     * Converts the DBObject to a standard JavaScript object representation (JSON).\n     * @returns A plain JavaScript object.\n     */\n    public toJson(): { [key: string]: any } {\n        return this.native.toJson();\n    }\n\n    /**\n     * Marks the object as a partial object (used internally by MongoDB driver).\n     */\n    public markAsPartialObject(): void {\n        this.native.markAsPartialObject();\n    }\n\n    /**\n     * Checks if the object is a partial object.\n     * @returns True if partial, false otherwise.\n     */\n    public isPartialObject(): boolean {\n        return this.native.isPartialObject();\n    }\n\n    /**\n     * Checks if the DBObject contains a field with the specified key.\n     * @param key The field name.\n     * @returns True if the field exists, false otherwise.\n     */\n    public containsField(key: string): boolean {\n        return this.native.containsField(key);\n    }\n\n    /**\n     * Gets the value associated with the given key.\n     * @param key The field name.\n     * @returns The field value.\n     */\n    public get(key: string): any {\n        return this.native.get(key);\n    }\n\n    /**\n     * Puts a key-value pair into the DBObject.\n     * @param key The field name.\n     * @param value The value to put.\n     * @returns The previous value associated with the key, or null.\n     */\n    public put(key: string, value: any): any {\n        return this.native.put(key, value);\n    }\n\n    /**\n     * Removes a field from the DBObject.\n     * @param key The field name to remove.\n     * @returns The removed field value.\n     */\n    public removeField(key: string): any {\n        return this.native.removeField(key);\n    }\n\n}\n\n/**\n * Copies the properties from the native MongoDB object's JSON representation\n * onto the public properties of the DBObject wrapper instance.\n * This allows direct access like `dbObject.fieldName`.\n * @param dbObject The DBObject wrapper instance.\n * @returns The extracted properties object.\n */\nfunction extract(dbObject: DBObject): { [key: string]: any } {\n    if (!dbObject.native) {\n        return {};\n    }\n    // Parse the native object's JSON representation\n    var extracted = JSON.parse(dbObject.native.toJson());\n    // Copy all properties to the wrapper instance\n    for (var propertyName in extracted) {\n        dbObject[propertyName] = extracted[propertyName];\n    }\n    return extracted;\n}\n\n/**\n * Helper function to implicitly convert a plain JS object to a DBObject,\n * or return the existing DBObject instance.\n * @param object Input object which can be a plain object, DBObject, or undefined/null.\n * @returns DBObject or undefined.\n */\nfunction implicit(object: DBInput): DBObject | undefined {\n    if (!object) {\n        return undefined; // Explicitly return undefined if input is falsy\n    }\n    // Check if it already has the native property (assumes it's a DBObject or similar wrapper)\n    if ((object as any).native) {\n        return object as DBObject;\n    }\n\n    // Convert plain object to DBObject\n    var dbObject = createBasicDBObject();\n\n    for (var propertyName in object) {\n        dbObject.append(propertyName, object[propertyName]);\n    }\n    return dbObject;\n}\n\n/**\n * Creates a new, empty DBObject instance.\n * @returns A new DBObject.\n */\nexport function createBasicDBObject(): DBObject {\n    const dbObject = new DBObject(MongoDBFacade.createBasicDBObject());\n    extract(dbObject);\n    return dbObject;\n}\n\n/**\n * Client object wrapper for connecting to MongoDB.\n */\nexport class Client {\n\n    /**\n     * The underlying native MongoDB client object.\n     * @private\n     */\n    private readonly native: any;\n\n    /**\n     * Constructs a new MongoDB Client instance.\n     * @param uri The MongoDB connection URI.\n     * @param user The username for authentication.\n     * @param password The password for authentication.\n     */\n    constructor(uri: string, user: string, password: string) {\n        this.native = MongoDBFacade.getClient(uri, user, password)\n    }\n\n    /**\n     * Retrieves a database instance.\n     * @param name Optional name of the database. If not provided, the default database name is used.\n     * @returns A DB instance.\n     */\n    public getDB(name?: string): DB {\n        let native = null;\n        if (name) {\n            native = this.native.getDB(name);\n        } else {\n            const defaultDB = MongoDBFacade.getDefaultDatabaseName();\n            native = this.native.getDB(defaultDB);\n        }\n\n        return new DB(native);\n    }\n}\n\n/**\n * DB object wrapper for a MongoDB database.\n */\nexport class DB {\n\n    /**\n     * The underlying native MongoDB DB object.\n     * @private\n     */\n    private readonly native: any;\n\n    /**\n     * Constructs a new DB instance.\n     * @param native The native MongoDB DB object.\n     */\n    constructor(native: any) {\n        this.native = native;\n    }\n\n    /**\n     * Retrieves a collection instance from the database.\n     * @param name The name of the collection.\n     * @returns A DBCollection instance.\n     */\n    public getCollection(name: string): DBCollection {\n        const native = this.native.getCollection(name);\n        return new DBCollection(native);\n    }\n}\n\n/**\n * DBCollection object wrapper for a MongoDB collection.\n */\nexport class DBCollection {\n\n    /**\n     * The underlying native MongoDB DBCollection object.\n     * @private\n     */\n    private readonly native: any;\n\n    /**\n     * Constructs a new DBCollection instance.\n     * @param native The native MongoDB DBCollection object.\n     */\n    constructor(native: any) {\n        this.native = native;\n    }\n\n    /**\n     * Inserts a document into the collection.\n     * @param dbObject The document to insert (can be a plain JS object or DBObject).\n     */\n    public insert(dbObject: DBInput): void {\n        const dbo = implicit(dbObject);\n        if (dbo) {\n            this.native.insert(dbo.native);\n        }\n    }\n\n    /**\n     * Finds documents matching the query.\n     * @param query The query specification (can be a plain JS object or DBObject).\n     * @param projection The fields to include or exclude (can be a plain JS object or DBObject).\n     * @returns A DBCursor for iterating over results.\n     */\n    public find(query?: DBInput, projection?: DBInput): DBCursor {\n        const q = implicit(query);\n        const p = implicit(projection);\n\n        var native = null;\n        if (q) {\n            if (p) {\n                native = this.native.find(q.native, p.native);\n            } else {\n                native = this.native.find(q.native);\n            }\n        } else {\n            native = this.native.find();\n        }\n\n        return new DBCursor(native);\n    }\n\n    /**\n     * Finds a single document matching the query.\n     * @param query The query specification.\n     * @param projection The fields to include or exclude.\n     * @param sort The sorting specification.\n     * @returns The found document as a DBObject.\n     */\n    public findOne(query: DBInput, projection: DBInput, sort: DBInput): DBObject {\n        const q = implicit(query);\n        const p = implicit(projection);\n        const s = implicit(sort);\n\n        var dbObject = createBasicDBObject();\n        var native = null;\n        if (q) {\n            if (p) {\n                if (s) {\n                    native = this.native.findOne(q.native, p.native, s.native);\n                } else {\n                    native = this.native.findOne(q.native, p.native);\n                }\n            } else {\n                native = this.native.findOne(q.native);\n            }\n        } else {\n            native = this.native.findOne();\n        }\n        dbObject.native = native;\n        extract(dbObject);\n        return dbObject;\n    }\n\n    /**\n     * Finds a single document by its string ID.\n     * @param id The string ID of the document.\n     * @param projection The fields to include or exclude.\n     * @returns The found document as a DBObject.\n     */\n    public findOneById(id: string, projection?: DBInput): DBObject {\n        const p = implicit(projection);\n        const dbObject = createBasicDBObject();\n        let native = null;\n        if (p) {\n            native = this.native.findOne(id, p.native);\n        } else {\n            native = this.native.findOne(id);\n        }\n        dbObject.native = native;\n        extract(dbObject);\n        return dbObject;\n    }\n\n    /**\n     * Counts the number of documents in the collection, optionally filtered by a query.\n     * @param query Optional query to filter the count.\n     * @returns The number of documents.\n     */\n    public count(query?: DBInput): number {\n        const q = implicit(query);\n        if (q) {\n            return this.native.count(q.native);\n        }\n        return this.native.count();\n    }\n\n    /**\n     * Gets the count of documents (alias for count).\n     * @param query Optional query to filter the count.\n     * @returns The number of documents.\n     */\n    public getCount(query: DBInput): number {\n        const q = implicit(query);\n        if (q) {\n            return this.native.getCount(q.native);\n        }\n        return this.native.getCount();\n    }\n\n    /**\n     * Creates an index on the collection.\n     * @param keys The index key specification.\n     * @param options Optional index options.\n     */\n    public createIndex(keys: DBInput, options: DBInput): void {\n        const k = implicit(keys);\n        const o = implicit(options);\n        if (k) {\n            if (o) {\n                this.native.createIndex(k.native, o.native);\n            } else {\n                this.native.createIndex(k.native);\n            }\n        } else {\n            throw new Error(\"At least Keys parameter must be provided\");\n        }\n    }\n\n    /**\n     * Creates an index on a single field by name.\n     * @param name The name of the field to index.\n     */\n    public createIndexForField(name: string): void {\n        if (name) {\n            this.native.createIndex(name);\n        } else {\n            throw new Error(\"The filed name must be provided\");\n        }\n    }\n\n    /**\n     * Retrieves the distinct values for a specified field across a collection.\n     * NOTE: The signature in the original code seems slightly off compared to typical MongoDB drivers.\n     * This implementation follows the original structure using `keys.native` if `keys` is provided.\n     * @param name The field name.\n     * @param query Optional query to filter results.\n     * @param keys Optional keys to use for distinct (replaces 'name' if provided and query exists).\n     */\n    public distinct(name: string, query: DBInput, keys: DBInput): void {\n        const q = implicit(query);\n        const k = implicit(keys);\n        if (name) {\n            if (q) {\n                // If query is provided, use keys for the field name if k is present, otherwise use 'name'\n                this.native.distinct(k ? k.native : name, q.native);\n            } else {\n                this.native.distinct(name);\n            }\n        } else {\n            throw new Error(\"At least the filed name parameter must be provided\");\n        }\n    }\n\n    /**\n     * Drops a specified index.\n     * @param index The name of the index or the DBObject representing the index keys.\n     */\n    public dropIndex(index: string | DBInput): void {\n        if (typeof index === 'string') {\n            this.native.dropIndex(index);\n        } else {\n            const dbo = implicit(index);\n            if (dbo) {\n                this.native.dropIndex(dbo.native);\n            }\n        }\n    }\n\n    /**\n     * Drops a specified index by name.\n     * @param name The name of the index.\n     */\n    public dropIndexByName(name: string): void {\n        this.native.dropIndex(name);\n    }\n\n    /**\n     * Drops all indexes on the collection.\n     */\n    public dropIndexes(): void {\n        this.native.dropIndexes();\n    }\n\n    /**\n     * Removes documents from the collection matching the query.\n     * @param query The deletion query specification.\n     */\n    public remove(query: DBInput): void {\n        const q = implicit(query);\n        if (q) {\n            this.native.remove(q.native);\n        }\n    }\n\n    /**\n     * Renames the collection.\n     * @param newName The new name for the collection.\n     */\n    public rename(newName: string): void {\n        this.native.rename(newName);\n    }\n\n    /**\n     * Saves a document to the collection. If the document has an `_id`, it performs an update;\n     * otherwise, it performs an insert.\n     * @param dbObject The document to save.\n     */\n    public save(dbObject: DBInput): void {\n        const dbo = implicit(dbObject);\n        if (dbo) {\n            this.native.save(dbo.native);\n        }\n    }\n\n    /**\n     * Updates documents in the collection matching the query.\n     * @param query The update query specification.\n     * @param update The update operation specification (e.g., {$set: {...}}).\n     * @param upsert If true, creates a new document if no documents match the query.\n     * @param multi If true, updates all documents matching the query; otherwise, only one.\n     */\n    public update(query: DBInput, update: DBInput, upsert?: boolean, multi?: boolean): void {\n        const q = implicit(query);\n        const u = implicit(update);\n        if (q) {\n            if (u) {\n                if (upsert) {\n                    if (multi) {\n                        this.native.update(q.native, u.native, upsert, multi);\n                    } else {\n                        this.native.update(q.native, u.native, upsert);\n                    }\n                } else {\n                    this.native.update(q.native, u.native);\n                }\n            } else {\n                throw new Error(\"The update parameter must be provided\");\n            }\n        } else {\n            throw new Error(\"The query parameter must be provided\");\n        }\n    }\n\n    /**\n     * Updates multiple documents in the collection matching the query.\n     * (Equivalent to calling `update` with `multi=true` and `upsert=true` implicitly).\n     * @param query The update query specification.\n     * @param update The update operation specification.\n     */\n    public updateMulti(query: DBInput, update: DBInput): void {\n        const q = implicit(query);\n        const u = implicit(update);\n        if (q) {\n            if (u) {\n                this.native.update(q.native, u.native, true, true); // Assuming updateMulti means upsert=true and multi=true\n            } else {\n                throw new Error(\"The update parameter must be provided\");\n            }\n        } else {\n            throw new Error(\"The query parameter must be provided\");\n        }\n    };\n\n    /**\n     * Calculates the next sequential ID based on the largest existing `_id` in the collection.\n     * Assumes `_id` is a numeric field.\n     * @returns The next available sequential ID (starting at 1 if collection is empty).\n     */\n    public getNextId(): number {\n        var cursor = this.find({}, { \"_id\": 1 }).sort({ \"_id\": -1 }).limit(1);\n        if (!cursor.hasNext()) {\n            return 1;\n        } else {\n            return cursor.next()[\"_id\"] + 1;\n        }\n    }\n\n    /**\n     * Generates a new random UUID (Universally Unique Identifier).\n     * @returns A string representing the UUID.\n     */\n    public generateUUID(): string {\n        return UUID.random();\n    }\n\n}\n\n/**\n * DBCursor object wrapper for iterating over results of a MongoDB query.\n */\nexport class DBCursor {\n\n    /**\n     * The underlying native MongoDB DBCursor object.\n     * @private\n     */\n    private readonly native: any;\n\n    /**\n     * Constructs a new DBCursor instance.\n     * @param native The native MongoDB DBCursor object.\n     */\n    constructor(native: any) {\n        this.native = native;\n    }\n\n    /**\n     * Returns the single result from the cursor.\n     * @returns A DBObject representing the document.\n     */\n    public one(): DBObject {\n        const dbObject = new DBObject(this.native.one());\n        extract(dbObject);\n        return dbObject;\n    }\n\n    /**\n     * Sets the batch size for the cursor.\n     * @param numberOfElements The batch size.\n     * @returns The DBCursor instance for chaining.\n     */\n    public batchSize(numberOfElements: number): DBCursor {\n        this.native.batchSize(numberOfElements);\n        return this;\n    }\n\n    /**\n     * Gets the current batch size.\n     * @returns The batch size.\n     */\n    public getBatchSize(): number {\n        return this.native.getBatchSize();\n    }\n\n    /**\n     * Gets the collection associated with this cursor.\n     * @returns The DBCollection instance.\n     */\n    public getCollection(): DBCollection {\n        return new DBCollection(this.native.getCollection());\n    }\n\n    /**\n     * Gets the cursor ID.\n     * @returns The cursor ID string.\n     */\n    public getCursorId(): string {\n        return this.native.getCursorId();\n    }\n\n    /**\n     * Gets the projection object (fields wanted) used in the query.\n     * @returns The projection DBObject.\n     */\n    public getKeysWanted(): DBObject {\n        const dbObject = new DBObject(this.native.getKeysWanted());\n        extract(dbObject);\n        return dbObject;\n    }\n\n    /**\n     * Gets the limit set on the cursor.\n     * @returns The limit number.\n     */\n    public getLimit(): number {\n        return this.native.getLimit();\n    }\n\n    /**\n     * Closes the cursor.\n     */\n    public close(): void {\n        this.native.close();\n    }\n\n    /**\n     * Checks if there is a next document in the cursor.\n     * @returns True if there is a next document, false otherwise.\n     */\n    public hasNext(): boolean {\n        return this.native.hasNext();\n    }\n\n    /**\n     * Retrieves the next document in the cursor.\n     * @returns The next document as a DBObject.\n     */\n    public next(): DBObject {\n        const dbObject = new DBObject(this.native.next());\n        extract(dbObject);\n        return dbObject;\n    }\n\n    /**\n     * Gets the query object used to create this cursor.\n     * @returns The query DBObject.\n     */\n    public getQuery(): DBObject {\n        const dbObject = new DBObject(this.native.getQuery());\n        extract(dbObject);\n        return dbObject;\n    }\n\n    /**\n     * Gets the number of documents matched by the query.\n     * @returns The total number of documents.\n     */\n    public length(): number {\n        return this.native.length();\n    }\n\n    /**\n     * Specifies the order in which the query returns the results.\n     * @param orderBy The sorting specification (e.g., {field: 1} for ascending).\n     * @returns The DBCursor instance for chaining.\n     */\n    public sort(orderBy: DBInput): DBCursor {\n        const dbo = implicit(orderBy);\n        if (!dbo) {\n            throw new Error(\"The orderBy parameter must be provided\");\n        }\n        this.native.sort(dbo.native);\n        return this;\n    }\n\n    /**\n     * Limits the number of results to be returned.\n     * @param limit The maximum number of documents to return.\n     * @returns The DBCursor instance for chaining.\n     */\n    public limit(limit: number): DBCursor {\n        this.native.limit(limit);\n        return this;\n    }\n\n    /**\n     * Specifies the exclusive upper bound for a specific index.\n     * @param min The minimum value.\n     * @returns The DBCursor instance for chaining.\n     */\n    public min(min: number): DBCursor {\n        this.native.min(min);\n        return this;\n    }\n\n    /**\n     * Specifies the exclusive upper bound for a specific index.\n     * @param max The maximum value.\n     * @returns The DBCursor instance for chaining.\n     */\n    public max(max: number): DBCursor {\n        this.native.max(max);\n        return this;\n    }\n\n    /**\n     * Sets a timeout for the server to execute the query.\n     * @param maxTime The maximum time in milliseconds.\n     * @returns The DBCursor instance for chaining.\n     */\n    public maxTime(maxTime: number): DBCursor {\n        this.native.maxTime(maxTime, TimeUnit.MILLISECONDS);\n        return this;\n    }\n\n    /**\n     * Gets the size of the result set.\n     * @returns The size number.\n     */\n    public size(): number {\n        return this.native.size();\n    }\n\n    /**\n     * Skips the specified number of documents.\n     * @param numberOfElements The number of documents to skip.\n     * @returns The DBCursor instance for chaining.\n     */\n    public skip(numberOfElements: number): DBCursor {\n        this.native.skip(numberOfElements);\n        return this;\n    }\n\n}\n"],
  "mappings": "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",
  "names": []
}
