@event-driven-io/pongo 0.17.0-beta.4 → 0.17.0-beta.40

package/dist/shim.cjs

@@ -1,381 +1,304 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_core = require('./core-C9SB3XMx.cjs');
+const require_cli = require('./cli.cjs');
+let _event_driven_io_dumbo = require("@event-driven-io/dumbo");
 
+//#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;
+	}
+};
 
-var _chunk4BL6YWLWcjs = require('./chunk-4BL6YWLW.cjs');
-
-// src/mongo/findCursor.ts
-var FindCursor = (_class = class {
-  
-  __init() {this.documents = null}
-  __init2() {this.index = 0}
-  constructor(documents) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);
-    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() ? _nullishCoalesce(docs[this.index++], () => ( null)) : null;
-  }
-  async findDocuments() {
-    this.documents = await this.findDocumentsPromise;
-    return this.documents;
-  }
-}, _class);
-
-// src/mongo/mongoClient.ts
-
-
-
-var _dumbo = require('@event-driven-io/dumbo');
-require('http2');
-
-// src/mongo/mongoDb.ts
-require('mongodb');
-
-// src/mongo/mongoCollection.ts
-var toCollectionOperationOptions = (options) => _optionalChain([options, 'optionalAccess', _ => _.session]) ? { session: options.session } : void 0;
-var toFindOptions = (options) => {
-  if (!_optionalChain([options, 'optionalAccess', _2 => _2.session]) && !_optionalChain([options, 'optionalAccess', _3 => _3.limit]) && !_optionalChain([options, 'optionalAccess', _4 => _4.skip])) {
-    return void 0;
-  }
-  const pongoFindOptions = {};
-  if (_optionalChain([options, 'optionalAccess', _5 => _5.session])) {
-    pongoFindOptions.session = options.session;
-  }
-  if (_optionalChain([options, 'optionalAccess', _6 => _6.limit]) !== void 0) {
-    pongoFindOptions.limit = options.limit;
-  }
-  if (_optionalChain([options, 'optionalAccess', _7 => _7.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 {
-  
-  
-  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(
-      _nullishCoalesce(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.matchedCount,
+			modifiedCount: result.modifiedCount,
+			upsertedCount: result.upsertedCount,
+			upsertedId: result.upsertedId
+		};
+	}
+	async replaceOne(filter, document, options) {
+		const result = await this.collection.replaceOne(filter, document, {
+			...toCollectionOperationOptions(options),
+			upsert: options?.upsert ?? false
+		});
+		return {
+			acknowledged: result.acknowledged,
+			matchedCount: result.matchedCount,
+			modifiedCount: result.modifiedCount,
+			upsertedCount: result.upsertedCount,
+			upsertedId: result.upsertedId
+		};
+	}
+	async updateMany(filter, update, options) {
+		const result = await this.collection.updateMany(filter, update, toCollectionOperationOptions(options));
+		return {
+			acknowledged: result.acknowledged,
+			matchedCount: result.matchedCount,
+			modifiedCount: result.modifiedCount,
+			upsertedCount: 0,
+			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 {
-  
-  constructor(pongoDb) {
-    this.pongoDb = pongoDb;
-  }
-  get databaseName() {
-    return this.pongoDb.databaseName;
-  }
-  collection(collectionName) {
-    return new Collection(this, this.pongoDb.collection(collectionName));
-  }
+	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 {
-  
-  constructor(connectionStringOrOptions, options) {
-    if (typeof connectionStringOrOptions !== "string") {
-      this.pongoClient = _chunk4BL6YWLWcjs.pongoClient.call(void 0, connectionStringOrOptions);
-      return;
-    }
-    const { databaseType, driverName } = _dumbo.parseConnectionString.call(void 0, 
-      connectionStringOrOptions
-    );
-    const driver = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _8 => _8.driver]), () => ( pongoDatabaseDriverRegistry.tryGet(
-      _dumbo.toDatabaseDriverType.call(void 0, databaseType, driverName)
-    )));
-    if (driver === null) {
-      throw new Error(
-        `No database driver registered for ${databaseType} with name ${driverName}`
-      );
-    }
-    this.pongoClient = _chunk4BL6YWLWcjs.pongoClient.call(void 0, {
-      ..._nullishCoalesce(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 _chunk4BL6YWLWcjs.pongoSession.call(void 0, );
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  async withSession(optionsOrExecutor, executor) {
-    const callback = typeof optionsOrExecutor === "function" ? optionsOrExecutor : executor;
-    const session = _chunk4BL6YWLWcjs.pongoSession.call(void 0, );
-    try {
-      return await callback(session);
-    } finally {
-      await session.endSession();
-    }
-  }
+	pongoClient;
+	constructor(connectionStringOrOptions, options) {
+		if (typeof connectionStringOrOptions !== "string") {
+			this.pongoClient = require_core.pongoClient(connectionStringOrOptions);
+			return;
+		}
+		const { databaseType, driverName } = (0, _event_driven_io_dumbo.parseConnectionString)(connectionStringOrOptions);
+		const driver = options?.driver ?? pongoDriverRegistry.tryGet((0, _event_driven_io_dumbo.toDatabaseDriverType)(databaseType, driverName));
+		if (driver === null) throw new Error(`No database driver registered for ${databaseType} with name ${driverName}`);
+		this.pongoClient = require_core.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 require_core.pongoSession();
+	}
+	async withSession(optionsOrExecutor, executor) {
+		const callback = typeof optionsOrExecutor === "function" ? optionsOrExecutor : executor;
+		const session = require_core.pongoSession();
+		try {
+			return await callback(session);
+		} finally {
+			await session.endSession();
+		}
+	}
 };
 
-
-
-
-
-exports.Collection = Collection; exports.Db = Db; exports.FindCursor = FindCursor; exports.MongoClient = MongoClient;
+//#endregion
+exports.Collection = Collection;
+exports.Db = Db;
+exports.FindCursor = FindCursor;
+exports.MongoClient = MongoClient;
 //# sourceMappingURL=shim.cjs.map