@event-driven-io/pongo 0.17.0-beta.34 → 0.17.0-beta.36

package/dist/shim.js

@@ -1,380 +1,289 @@
-import {
-  pongoClient,
-  pongoSession
-} from "./chunk-U4NNEXNH.js";
+import { o as pongoClient, s as pongoSession } from "./core-D_iZiiYe.js";
+import { parseConnectionString, toDatabaseDriverType } from "@event-driven-io/dumbo";
 
-// src/mongo/findCursor.ts
+//#region src/mongo/findCursor.ts
 var FindCursor = class {
-  findDocumentsPromise;
-  documents = null;
-  index = 0;
-  constructor(documents) {
-    this.findDocumentsPromise = documents;
-  }
-  async toArray() {
-    return this.findDocuments();
-  }
-  async forEach(callback) {
-    const docs = await this.findDocuments();
-    for (const doc of docs) {
-      callback(doc);
-    }
-    return Promise.resolve();
-  }
-  hasNext() {
-    if (this.documents === null) throw Error("Error while fetching documents");
-    return this.index < this.documents.length;
-  }
-  async next() {
-    const docs = await this.findDocuments();
-    return this.hasNext() ? docs[this.index++] ?? null : null;
-  }
-  async findDocuments() {
-    this.documents = await this.findDocumentsPromise;
-    return this.documents;
-  }
+	findDocumentsPromise;
+	documents = null;
+	index = 0;
+	constructor(documents) {
+		this.findDocumentsPromise = documents;
+	}
+	async toArray() {
+		return this.findDocuments();
+	}
+	async forEach(callback) {
+		const docs = await this.findDocuments();
+		for (const doc of docs) callback(doc);
+		return Promise.resolve();
+	}
+	hasNext() {
+		if (this.documents === null) throw Error("Error while fetching documents");
+		return this.index < this.documents.length;
+	}
+	async next() {
+		const docs = await this.findDocuments();
+		return this.hasNext() ? docs[this.index++] ?? null : null;
+	}
+	async findDocuments() {
+		this.documents = await this.findDocumentsPromise;
+		return this.documents;
+	}
 };
 
-// src/mongo/mongoClient.ts
-import {
-  parseConnectionString,
-  toDatabaseDriverType
-} from "@event-driven-io/dumbo";
-
-// src/mongo/mongoCollection.ts
-var toCollectionOperationOptions = (options) => options?.session ? { session: options.session } : void 0;
-var toFindOptions = (options) => {
-  if (!options?.session && !options?.limit && !options?.skip) {
-    return void 0;
-  }
-  const pongoFindOptions = {};
-  if (options?.session) {
-    pongoFindOptions.session = options.session;
-  }
-  if (options?.limit !== void 0) {
-    pongoFindOptions.limit = options.limit;
-  }
-  if (options?.skip !== void 0) {
-    pongoFindOptions.skip = options.skip;
-  }
-  return pongoFindOptions;
+//#endregion
+//#region src/mongo/mongoCollection.ts
+const toCollectionOperationOptions = (options) => options?.session ? { session: options.session } : void 0;
+const toFindOptions = (options) => {
+	if (!options?.session && !options?.limit && !options?.skip && !options?.sort) return;
+	const pongoFindOptions = {};
+	if (options?.session) pongoFindOptions.session = options.session;
+	if (options?.limit !== void 0) pongoFindOptions.limit = options.limit;
+	if (options?.skip !== void 0) pongoFindOptions.skip = options.skip;
+	if (options?.sort !== void 0) pongoFindOptions.sort = options.sort;
+	return pongoFindOptions;
 };
 var Collection = class {
-  collection;
-  database;
-  constructor(database, collection) {
-    this.collection = collection;
-    this.database = database;
-  }
-  get db() {
-    return this.database;
-  }
-  get dbName() {
-    return this.collection.dbName;
-  }
-  get collectionName() {
-    return this.collection.collectionName;
-  }
-  get namespace() {
-    return `${this.dbName}.${this.collectionName}`;
-  }
-  get readConcern() {
-    return void 0;
-  }
-  get readPreference() {
-    return void 0;
-  }
-  get bsonOptions() {
-    return {};
-  }
-  get writeConcern() {
-    return void 0;
-  }
-  get hint() {
-    return void 0;
-  }
-  get timeoutMS() {
-    return void 0;
-  }
-  set hint(v) {
-    throw new Error("Method not implemented.");
-  }
-  async insertOne(doc, options) {
-    const result = await this.collection.insertOne(
-      doc,
-      toCollectionOperationOptions(options)
-    );
-    return {
-      acknowledged: result.acknowledged,
-      insertedId: result.insertedId
-    };
-  }
-  async insertMany(docs, options) {
-    const result = await this.collection.insertMany(
-      docs,
-      toCollectionOperationOptions(options)
-    );
-    return {
-      acknowledged: result.acknowledged,
-      insertedIds: result.insertedIds,
-      insertedCount: result.insertedCount
-    };
-  }
-  bulkWrite(_operations, _options) {
-    throw new Error("Method not implemented.");
-  }
-  async updateOne(filter, update, options) {
-    const result = await this.collection.updateOne(
-      filter,
-      update,
-      toCollectionOperationOptions(options)
-    );
-    return {
-      acknowledged: result.acknowledged,
-      matchedCount: result.modifiedCount,
-      modifiedCount: result.modifiedCount,
-      upsertedCount: result.modifiedCount,
-      upsertedId: null
-    };
-  }
-  replaceOne(filter, document, options) {
-    return this.collection.replaceOne(
-      filter,
-      document,
-      toCollectionOperationOptions(options)
-    );
-  }
-  async updateMany(filter, update, options) {
-    const result = await this.collection.updateMany(
-      filter,
-      update,
-      toCollectionOperationOptions(options)
-    );
-    return {
-      acknowledged: result.acknowledged,
-      matchedCount: result.modifiedCount,
-      modifiedCount: result.modifiedCount,
-      upsertedCount: result.modifiedCount,
-      upsertedId: null
-    };
-  }
-  async deleteOne(filter, options) {
-    const result = await this.collection.deleteOne(
-      filter,
-      toCollectionOperationOptions(options)
-    );
-    return {
-      acknowledged: result.acknowledged,
-      deletedCount: result.deletedCount
-    };
-  }
-  async deleteMany(filter, options) {
-    const result = await this.collection.deleteMany(
-      filter,
-      toCollectionOperationOptions(options)
-    );
-    return {
-      acknowledged: result.acknowledged,
-      deletedCount: result.deletedCount
-    };
-  }
-  async rename(newName, options) {
-    await this.collection.rename(
-      newName,
-      toCollectionOperationOptions(options)
-    );
-    return this;
-  }
-  drop(options) {
-    return this.collection.drop(toCollectionOperationOptions(options));
-  }
-  async findOne(filter, options) {
-    return await this.collection.findOne(
-      filter,
-      toCollectionOperationOptions(options)
-    );
-  }
-  find(filter, options) {
-    return new FindCursor(
-      this.collection.find(filter, toFindOptions(options))
-    );
-  }
-  options(_options) {
-    throw new Error("Method not implemented.");
-  }
-  isCapped(_options) {
-    throw new Error("Method not implemented.");
-  }
-  createIndex(_indexSpec, _options) {
-    throw new Error("Method not implemented.");
-  }
-  createIndexes(_indexSpecs, _options) {
-    throw new Error("Method not implemented.");
-  }
-  dropIndex(_indexName, _options) {
-    throw new Error("Method not implemented.");
-  }
-  dropIndexes(_options) {
-    throw new Error("Method not implemented.");
-  }
-  listIndexes(_options) {
-    throw new Error("Method not implemented.");
-  }
-  indexExists(_indexes, _options) {
-    throw new Error("Method not implemented.");
-  }
-  indexInformation(_options) {
-    throw new Error("Method not implemented.");
-  }
-  estimatedDocumentCount(options) {
-    return this.collection.countDocuments(
-      {},
-      toCollectionOperationOptions(options)
-    );
-  }
-  countDocuments(filter, options) {
-    return this.collection.countDocuments(
-      filter,
-      toCollectionOperationOptions(options)
-    );
-  }
-  distinct(_key, _filter, _options) {
-    throw new Error("Method not implemented.");
-  }
-  indexes(_options) {
-    throw new Error("Method not implemented.");
-  }
-  findOneAndDelete(filter, options) {
-    return this.collection.findOneAndDelete(
-      filter,
-      toCollectionOperationOptions(options)
-    );
-  }
-  findOneAndReplace(filter, replacement, options) {
-    return this.collection.findOneAndReplace(
-      filter,
-      replacement,
-      toCollectionOperationOptions(options)
-    );
-  }
-  findOneAndUpdate(filter, update, options) {
-    return this.collection.findOneAndUpdate(
-      filter,
-      update,
-      toCollectionOperationOptions(options)
-    );
-  }
-  aggregate(_pipeline, _options) {
-    throw new Error("Method not implemented.");
-  }
-  watch(_pipeline, _options) {
-    throw new Error("Method not implemented.");
-  }
-  initializeUnorderedBulkOp(_options) {
-    throw new Error("Method not implemented.");
-  }
-  initializeOrderedBulkOp(_options) {
-    throw new Error("Method not implemented.");
-  }
-  count(filter, options) {
-    return this.collection.countDocuments(
-      filter ?? {},
-      toCollectionOperationOptions(options)
-    );
-  }
-  listSearchIndexes(_name, _options) {
-    throw new Error("Method not implemented.");
-  }
-  createSearchIndex(_description) {
-    throw new Error("Method not implemented.");
-  }
-  createSearchIndexes(_descriptions) {
-    throw new Error("Method not implemented.");
-  }
-  dropSearchIndex(_name) {
-    throw new Error("Method not implemented.");
-  }
-  updateSearchIndex(_name, _definition) {
-    throw new Error("Method not implemented.");
-  }
-  async createCollection() {
-    await this.collection.createCollection();
-  }
-  async handle(id, handle, options) {
-    return this.collection.handle(id.toString(), handle, options);
-  }
+	collection;
+	database;
+	constructor(database, collection) {
+		this.collection = collection;
+		this.database = database;
+	}
+	get db() {
+		return this.database;
+	}
+	get dbName() {
+		return this.collection.dbName;
+	}
+	get collectionName() {
+		return this.collection.collectionName;
+	}
+	get namespace() {
+		return `${this.dbName}.${this.collectionName}`;
+	}
+	get readConcern() {}
+	get readPreference() {}
+	get bsonOptions() {
+		return {};
+	}
+	get writeConcern() {}
+	get hint() {}
+	get timeoutMS() {}
+	set hint(v) {
+		throw new Error("Method not implemented.");
+	}
+	async insertOne(doc, options) {
+		const result = await this.collection.insertOne(doc, toCollectionOperationOptions(options));
+		return {
+			acknowledged: result.acknowledged,
+			insertedId: result.insertedId
+		};
+	}
+	async insertMany(docs, options) {
+		const result = await this.collection.insertMany(docs, toCollectionOperationOptions(options));
+		return {
+			acknowledged: result.acknowledged,
+			insertedIds: result.insertedIds,
+			insertedCount: result.insertedCount
+		};
+	}
+	bulkWrite(_operations, _options) {
+		throw new Error("Method not implemented.");
+	}
+	async updateOne(filter, update, options) {
+		const result = await this.collection.updateOne(filter, update, toCollectionOperationOptions(options));
+		return {
+			acknowledged: result.acknowledged,
+			matchedCount: result.modifiedCount,
+			modifiedCount: result.modifiedCount,
+			upsertedCount: result.modifiedCount,
+			upsertedId: null
+		};
+	}
+	replaceOne(filter, document, options) {
+		return this.collection.replaceOne(filter, document, toCollectionOperationOptions(options));
+	}
+	async updateMany(filter, update, options) {
+		const result = await this.collection.updateMany(filter, update, toCollectionOperationOptions(options));
+		return {
+			acknowledged: result.acknowledged,
+			matchedCount: result.modifiedCount,
+			modifiedCount: result.modifiedCount,
+			upsertedCount: result.modifiedCount,
+			upsertedId: null
+		};
+	}
+	async deleteOne(filter, options) {
+		const result = await this.collection.deleteOne(filter, toCollectionOperationOptions(options));
+		return {
+			acknowledged: result.acknowledged,
+			deletedCount: result.deletedCount
+		};
+	}
+	async deleteMany(filter, options) {
+		const result = await this.collection.deleteMany(filter, toCollectionOperationOptions(options));
+		return {
+			acknowledged: result.acknowledged,
+			deletedCount: result.deletedCount
+		};
+	}
+	async rename(newName, options) {
+		await this.collection.rename(newName, toCollectionOperationOptions(options));
+		return this;
+	}
+	drop(options) {
+		return this.collection.drop(toCollectionOperationOptions(options));
+	}
+	async findOne(filter, options) {
+		return await this.collection.findOne(filter, toCollectionOperationOptions(options));
+	}
+	find(filter, options) {
+		return new FindCursor(this.collection.find(filter, toFindOptions(options)));
+	}
+	options(_options) {
+		throw new Error("Method not implemented.");
+	}
+	isCapped(_options) {
+		throw new Error("Method not implemented.");
+	}
+	createIndex(_indexSpec, _options) {
+		throw new Error("Method not implemented.");
+	}
+	createIndexes(_indexSpecs, _options) {
+		throw new Error("Method not implemented.");
+	}
+	dropIndex(_indexName, _options) {
+		throw new Error("Method not implemented.");
+	}
+	dropIndexes(_options) {
+		throw new Error("Method not implemented.");
+	}
+	listIndexes(_options) {
+		throw new Error("Method not implemented.");
+	}
+	indexExists(_indexes, _options) {
+		throw new Error("Method not implemented.");
+	}
+	indexInformation(_options) {
+		throw new Error("Method not implemented.");
+	}
+	estimatedDocumentCount(options) {
+		return this.collection.countDocuments({}, toCollectionOperationOptions(options));
+	}
+	countDocuments(filter, options) {
+		return this.collection.countDocuments(filter, toCollectionOperationOptions(options));
+	}
+	distinct(_key, _filter, _options) {
+		throw new Error("Method not implemented.");
+	}
+	indexes(_options) {
+		throw new Error("Method not implemented.");
+	}
+	findOneAndDelete(filter, options) {
+		return this.collection.findOneAndDelete(filter, toCollectionOperationOptions(options));
+	}
+	findOneAndReplace(filter, replacement, options) {
+		return this.collection.findOneAndReplace(filter, replacement, toCollectionOperationOptions(options));
+	}
+	findOneAndUpdate(filter, update, options) {
+		return this.collection.findOneAndUpdate(filter, update, toCollectionOperationOptions(options));
+	}
+	aggregate(_pipeline, _options) {
+		throw new Error("Method not implemented.");
+	}
+	watch(_pipeline, _options) {
+		throw new Error("Method not implemented.");
+	}
+	initializeUnorderedBulkOp(_options) {
+		throw new Error("Method not implemented.");
+	}
+	initializeOrderedBulkOp(_options) {
+		throw new Error("Method not implemented.");
+	}
+	count(filter, options) {
+		return this.collection.countDocuments(filter ?? {}, toCollectionOperationOptions(options));
+	}
+	listSearchIndexes(_name, _options) {
+		throw new Error("Method not implemented.");
+	}
+	createSearchIndex(_description) {
+		throw new Error("Method not implemented.");
+	}
+	createSearchIndexes(_descriptions) {
+		throw new Error("Method not implemented.");
+	}
+	dropSearchIndex(_name) {
+		throw new Error("Method not implemented.");
+	}
+	updateSearchIndex(_name, _definition) {
+		throw new Error("Method not implemented.");
+	}
+	async createCollection() {
+		await this.collection.createCollection();
+	}
+	async handle(id, handle, options) {
+		return this.collection.handle(id.toString(), handle, options);
+	}
 };
 
-// src/mongo/mongoDb.ts
+//#endregion
+//#region src/mongo/mongoDb.ts
 var Db = class {
-  pongoDb;
-  constructor(pongoDb) {
-    this.pongoDb = pongoDb;
-  }
-  get databaseName() {
-    return this.pongoDb.databaseName;
-  }
-  collection(collectionName, options) {
-    return new Collection(
-      this,
-      this.pongoDb.collection(collectionName, options)
-    );
-  }
+	pongoDb;
+	constructor(pongoDb) {
+		this.pongoDb = pongoDb;
+	}
+	get databaseName() {
+		return this.pongoDb.databaseName;
+	}
+	collection(collectionName, options) {
+		return new Collection(this, this.pongoDb.collection(collectionName, options));
+	}
 };
 
-// src/mongo/mongoClient.ts
+//#endregion
+//#region src/mongo/mongoClient.ts
 var MongoClient = class {
-  pongoClient;
-  constructor(connectionStringOrOptions, options) {
-    if (typeof connectionStringOrOptions !== "string") {
-      this.pongoClient = pongoClient(connectionStringOrOptions);
-      return;
-    }
-    const { databaseType, driverName } = parseConnectionString(
-      connectionStringOrOptions
-    );
-    const driver = options?.driver ?? pongoDriverRegistry.tryGet(
-      toDatabaseDriverType(databaseType, driverName)
-    );
-    if (driver === null) {
-      throw new Error(
-        `No database driver registered for ${databaseType} with name ${driverName}`
-      );
-    }
-    this.pongoClient = pongoClient({
-      ...options ?? {},
-      ...{ connectionString: connectionStringOrOptions },
-      driver
-    });
-  }
-  async connect() {
-    await this.pongoClient.connect();
-    return this;
-  }
-  async close() {
-    await this.pongoClient.close();
-  }
-  db(dbName) {
-    return new Db(this.pongoClient.db(dbName));
-  }
-  startSession(_options) {
-    return pongoSession();
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  async withSession(optionsOrExecutor, executor) {
-    const callback = typeof optionsOrExecutor === "function" ? optionsOrExecutor : executor;
-    const session = pongoSession();
-    try {
-      return await callback(session);
-    } finally {
-      await session.endSession();
-    }
-  }
-};
-export {
-  Collection,
-  Db,
-  FindCursor,
-  MongoClient
+	pongoClient;
+	constructor(connectionStringOrOptions, options) {
+		if (typeof connectionStringOrOptions !== "string") {
+			this.pongoClient = pongoClient(connectionStringOrOptions);
+			return;
+		}
+		const { databaseType, driverName } = parseConnectionString(connectionStringOrOptions);
+		const driver = options?.driver ?? pongoDriverRegistry.tryGet(toDatabaseDriverType(databaseType, driverName));
+		if (driver === null) throw new Error(`No database driver registered for ${databaseType} with name ${driverName}`);
+		this.pongoClient = pongoClient({
+			...options ?? {},
+			connectionString: connectionStringOrOptions,
+			driver
+		});
+	}
+	async connect() {
+		await this.pongoClient.connect();
+		return this;
+	}
+	async close() {
+		await this.pongoClient.close();
+	}
+	db(dbName) {
+		return new Db(this.pongoClient.db(dbName));
+	}
+	startSession(_options) {
+		return pongoSession();
+	}
+	async withSession(optionsOrExecutor, executor) {
+		const callback = typeof optionsOrExecutor === "function" ? optionsOrExecutor : executor;
+		const session = pongoSession();
+		try {
+			return await callback(session);
+		} finally {
+			await session.endSession();
+		}
+	}
 };
+
+//#endregion
+export { Collection, Db, FindCursor, MongoClient };
 //# sourceMappingURL=shim.js.map