cry-db 2.3.4 → 2.4.2

package/dist/mongo.mjs

@@ -152,24 +152,8 @@ export class Mongo extends Db {
         }
         log.debug('find called', collection, query, opts);
         let ret = await this.executeTransactionally(collection, async (conn) => {
-            let optsIn = {};
-            if (opts.readPreference)
-                optsIn.readPreference = opts.readPreference;
-            if (this.session)
-                optsIn.session = this.session;
-            let r = conn.find(query, optsIn);
-            if (opts.project)
-                r = r.project(opts.project);
-            if (opts.sort)
-                r = r.sort(opts.sort);
-            if (opts.skip)
-                r = r.skip(opts.skip);
-            if (opts.limit)
-                r = r.limit(opts.limit);
-            if (opts.collation)
-                r = r.collation(opts.collation);
-            let res = await r.toArray();
-            return this._processReturnedObject(res);
+            let r = this._applyQueryOpts(conn.find(query, this._buildFindOptions(opts)), opts);
+            return this._processReturnedObject(await r.toArray());
         }, false, { operation: "find", collection, query, opts });
         log.debug('find returns', ret);
         return ret;
@@ -178,22 +162,7 @@ export class Mongo extends Db {
         assert(collection);
         query = this.replaceIds(query);
         let ret = await this.executeTransactionally(collection, async (conn) => {
-            let optsIn = {};
-            if (opts.readPreference)
-                optsIn.readPreference = opts.readPreference;
-            if (this.session)
-                optsIn.session = this.session;
-            let r = conn.find(query, optsIn);
-            if (opts.project)
-                r = r.project(opts.project);
-            if (opts.sort)
-                r = r.sort(opts.sort);
-            if (opts.skip)
-                r = r.skip(opts.skip);
-            if (opts.limit)
-                r = r.limit(opts.limit);
-            if (opts.collation)
-                r = r.collation(opts.collation);
+            let r = this._applyQueryOpts(conn.find(query, this._buildFindOptions(opts)), opts);
             return this._processReturnedObject(await r.toArray());
         }, false, { operation: "findAll", collection, query, opts });
         log.debug('findAll returns', ret);
@@ -203,24 +172,7 @@ export class Mongo extends Db {
         query = this._createQueryForNewer(timestamp, query);
         log.debug('findNewer called', collection, timestamp, query, opts);
         let ret = await this.executeTransactionally(collection, async (conn) => {
-            let optsIn = {};
-            if (opts.readPreference)
-                optsIn.readPreference = opts.readPreference;
-            if (this.session)
-                optsIn.session = this.session;
-            let r = conn
-                .find(query, optsIn)
-                .sort({ _ts: 1 });
-            if (opts.project)
-                r = r.project(opts.project);
-            if (opts.sort)
-                r = r.sort(opts.sort);
-            if (opts.skip)
-                r = r.skip(opts.skip);
-            if (opts.limit)
-                r = r.limit(opts.limit);
-            if (opts.collation)
-                r = r.collation(opts.collation);
+            let r = this._applyQueryOpts(conn.find(query, this._buildFindOptions(opts)).sort({ _ts: 1 }), opts);
             return this._processReturnedObject(await r.toArray());
         }, false, { operation: "findNewer", collection, timestamp, query, opts });
         log.debug('findNewer returns', ret);
@@ -229,30 +181,15 @@ export class Mongo extends Db {
     async findNewerMany(spec = []) {
         var _a;
         log.debug('findNewerMany called', spec);
+        const dbName = this.db; // Capture db at operation start
         let conn = await this.connect();
         const getOneColl = async (coll) => {
             let query = this._createQueryForNewer(coll.timestamp, coll.query || {});
             if (process.env.MONGO_DEBUG_FINDNEWERMANY) {
                 log.debug("findNewerMany <-", coll.collection, coll.timestamp, coll.query, " -> ", JSON.stringify(query));
             }
-            let r = conn
-                .db(this.db)
-                .collection(coll.collection)
-                .find(query, {
-            // readPreference: ReadPreference.SECONDARY_PREFERRED
-            })
-                .sort({ _ts: 1 });
-            let opts = coll.opts || {};
-            if (opts.project)
-                r = r.project(opts.project);
-            if (opts.sort)
-                r = r.sort(opts.sort);
-            if (opts.skip)
-                r = r.skip(opts.skip);
-            if (opts.limit)
-                r = r.limit(opts.limit);
-            if (opts.collation)
-                r = r.collation(opts.collation);
+            const opts = coll.opts || {};
+            let r = this._applyQueryOpts(conn.db(dbName).collection(coll.collection).find(query, {}).sort({ _ts: 1 }), opts);
             let data = await r.toArray();
             if (process.env.MONGO_DEBUG_FINDNEWERMANY) {
                 log.debug("findNewerMany ->", coll.collection, JSON.stringify(data, null, 2));
@@ -281,11 +218,12 @@ export class Mongo extends Db {
         assert(collections);
         assert(collections instanceof Array);
         log.debug('latestTimestamps called', collections);
+        const dbName = this.db; // Capture db at operation start
         let conn = await this.connect();
         const getOne = async (collection) => {
             var _a;
             let cursor = conn
-                .db(this.db)
+                .db(dbName)
                 .collection(collection)
                 .find({}, this._sessionOpt())
                 .project({ _ts: 1 })
@@ -308,9 +246,10 @@ export class Mongo extends Db {
         var _a;
         assert(collection);
         log.debug('latestTimestamp called', collection);
+        const dbName = this.db; // Capture db at operation start
         let conn = await this.connect();
         let cursor = conn
-            .db(this.db)
+            .db(dbName)
             .collection(collection)
             .find({}, this._sessionOpt())
             .project({ _ts: 1 })
@@ -405,11 +344,12 @@ export class Mongo extends Db {
         assert(id);
         if (!id)
             return null;
+        const dbName = this.db; // Capture db at operation start
         let query = {
             _id: Mongo._toId(id),
             // _deleted: { $exists: false }
         };
-        log.debug('findById called', this.db, collection, id, projection);
+        log.debug('findById called', dbName, collection, id, projection);
         log.trace('findById executing with query', collection, query, projection);
         let ret = await this.executeTransactionally(collection, async (conn) => {
             let r = await conn.findOne(query, { ...(projection ? { projection } : {}), ...this._sessionOpt() });
@@ -424,6 +364,7 @@ export class Mongo extends Db {
         assert(collection);
         assert(query);
         assert(update);
+        const dbName = this.db; // Capture db at operation start
         query = this.replaceIds(query);
         update = this.replaceIds(update);
         let opts = {
@@ -437,14 +378,14 @@ export class Mongo extends Db {
         let obj = await this.executeTransactionally(collection, async (conn, client) => {
             update.$set = update.$set || {};
             if (seqKeys)
-                await this._processSequenceField(client, collection, update.$set, seqKeys);
+                await this._processSequenceField(client, dbName, collection, update.$set, seqKeys);
             if (update.$set === undefined || Object.keys(update.$set).length === 0)
                 delete update.$set;
             let res = await conn.findOneAndUpdate(query, update, opts);
             if (!res)
                 return null;
             let resObj = this._removeUnchanged(res, update, !!(options === null || options === void 0 ? void 0 : options.returnFullObject));
-            await this._publishAndAudit('update', this.db, collection, resObj);
+            await this._publishAndAudit('update', dbName, collection, resObj);
             return resObj;
         }, !!seqKeys, { operation: "updateOne", collection, query, update, options });
         log.debug('updateOne returns', obj);
@@ -453,6 +394,7 @@ export class Mongo extends Db {
     async save(collection, update, id = undefined, options = { returnFullObject: false }) {
         assert(collection);
         assert(update);
+        const dbName = this.db; // Capture db at operation start
         update = this.replaceIds(update);
         let opts = {
             upsert: true,
@@ -466,14 +408,14 @@ export class Mongo extends Db {
         let obj = await this.executeTransactionally(collection, async (conn, client) => {
             update.$set = update.$set || {};
             if (seqKeys)
-                await this._processSequenceField(client, collection, update.$set, seqKeys);
+                await this._processSequenceField(client, dbName, collection, update.$set, seqKeys);
             if (update.$set === undefined || Object.keys(update.$set).length === 0)
                 delete update.$set;
             let res = await conn.findOneAndUpdate({ _id }, update, opts);
             if (!res)
                 return null;
             let resObj = this._removeUnchanged(res, update, !!(options === null || options === void 0 ? void 0 : options.returnFullObject));
-            await this._publishAndAudit('update', this.db, collection, resObj);
+            await this._publishAndAudit('update', dbName, collection, resObj);
             return resObj;
         }, !!seqKeys, { operation: "save", collection, _id, update, options });
         log.debug('save returns', obj);
@@ -486,6 +428,7 @@ export class Mongo extends Db {
         // if (this.syncSupport) log.warn("update does not increase _csq, avoit it.")
         if (!Object.keys(update).length)
             return { n: 0, ok: false };
+        const dbName = this.db; // Capture db at operation start
         query = this.replaceIds(query);
         update = this.replaceIds(update);
         let opts = {
@@ -499,7 +442,7 @@ export class Mongo extends Db {
         let obj = await this.executeTransactionally(collection, async (conn, client) => {
             update.$set = update.$set || {};
             if (seqKeys)
-                await this._processSequenceField(client, collection, update.$set, seqKeys);
+                await this._processSequenceField(client, dbName, collection, update.$set, seqKeys);
             if (update.$set === undefined || Object.keys(update.$set).length === 0)
                 delete update.$set;
             log.debug('update called', collection, query, update);
@@ -508,7 +451,7 @@ export class Mongo extends Db {
                 n: res.modifiedCount,
                 ok: !!res.acknowledged
             };
-            await this._publishAndAudit('updateMany', this.db, collection, resObj);
+            await this._publishAndAudit('updateMany', dbName, collection, resObj);
             return resObj;
         }, !!seqKeys, { operation: "update", collection, query, update });
         log.debug('update returns', obj);
@@ -520,6 +463,7 @@ export class Mongo extends Db {
         assert(update);
         assert(typeof update === 'object', 'update must be an object');
         // if (!Object.keys(update).length) return null;
+        const dbName = this.db; // Capture db at operation start
         query = this.replaceIds(query);
         update = this.replaceIds(update);
         let opts = {
@@ -537,15 +481,18 @@ export class Mongo extends Db {
         let ret = await this.executeTransactionally(collection, async (conn, client) => {
             update.$set = update.$set || {};
             if (seqKeys)
-                await this._processSequenceField(client, collection, update.$set, seqKeys);
+                await this._processSequenceField(client, dbName, collection, update.$set, seqKeys);
             if (update.$set === undefined || Object.keys(update.$set).length === 0)
                 delete update.$set;
             let ret = await conn.findOneAndUpdate(query, update, opts);
             if (ret) {
-                let oper = "update";
-                let retObj = this._removeUnchanged(ret, update, !!(options === null || options === void 0 ? void 0 : options.returnFullObject));
-                await this._publishAndAudit(oper, this.db, collection, retObj);
-                return retObj;
+                // Detect if this was an insert or update by checking _rev
+                const isInsert = this.revisions && ret._rev === 1;
+                let oper = isInsert ? "insert" : "update";
+                // For inserts, use full record to capture query fields; for updates, only changed fields
+                let retObj = isInsert ? ret : this._removeUnchanged(ret, update, !!(options === null || options === void 0 ? void 0 : options.returnFullObject));
+                await this._publishAndAudit(oper, dbName, collection, retObj);
+                return this._removeUnchanged(ret, update, !!(options === null || options === void 0 ? void 0 : options.returnFullObject));
             }
             ;
             return ret;
@@ -558,6 +505,7 @@ export class Mongo extends Db {
         assert(insert, "insert can't be null");
         assert(typeof insert === "object", "insert must be an object");
         log.debug('insert called', collection, insert);
+        const dbName = this.db; // Capture db at operation start
         insert = this.replaceIds(insert);
         if (this.revisions) {
             insert._rev = 1;
@@ -567,10 +515,10 @@ export class Mongo extends Db {
         let seqKeys = this._findSequenceKeys(insert);
         let ret = await this.executeTransactionally(collection, async (conn, client) => {
             if (insert)
-                insert = await this._processSequenceField(client, collection, insert, seqKeys);
+                insert = await this._processSequenceField(client, dbName, collection, insert, seqKeys);
             let obj = await conn.insertOne(insert, this._sessionOpt());
             let fullObj = { _id: obj.insertedId, ...insert };
-            await this._publishAndAudit('insert', this.db, collection, fullObj);
+            await this._publishAndAudit('insert', dbName, collection, fullObj);
             return fullObj;
         }, !!seqKeys, { operation: "insert", collection, insert });
         log.debug('insert returns', ret);
@@ -582,12 +530,13 @@ export class Mongo extends Db {
         assert(batch, "batch can't be null");
         assert(batch instanceof Array, "batch must be an Array");
         log.debug('upsertBatch called', collection, batch);
+        const dbName = this.db; // Capture db at operation start
         batch = this.replaceIds(batch);
         for (let i = 0; i < batch.length; i++)
             await this._processHashedKeys((_a = batch[i]) === null || _a === void 0 ? void 0 : _a.update);
         let ret = await this.executeTransactionally(collection, async (conn, client) => {
             var _a;
-            await this._processSequenceFieldForMany(client, collection, batch.map(b => b.update));
+            await this._processSequenceFieldForMany(client, dbName, collection, batch.map(b => b.update));
             let batchData = [];
             let changes = [];
             for await (let part of batch) {
@@ -631,10 +580,10 @@ export class Mongo extends Db {
             }
             if (this.emittingPublishEvents || this.auditing) {
                 await this.emit("publish", {
-                    channel: `db/${this.db}/${collection}`,
+                    channel: `db/${dbName}/${collection}`,
                     payload: {
                         operation: "batch",
-                        db: this.db,
+                        db: dbName,
                         collection,
                         data: batchData
                     }
@@ -642,10 +591,10 @@ export class Mongo extends Db {
             }
             if (this.emittingPublishRevEvents) {
                 await this.emit("publishRev", {
-                    channel: `dbrev/${this.db}/${collection}`,
+                    channel: `dbrev/${dbName}/${collection}`,
                     payload: {
                         operation: "batch",
-                        db: this.db,
+                        db: dbName,
                         collection,
                         data: batchData.map(item => ({
                             operation: item.operation,
@@ -665,13 +614,14 @@ export class Mongo extends Db {
         assert(insert, "insert can't be null");
         assert(insert instanceof Array, "insert must be an Array");
         log.debug('insertMany called', collection, insert);
+        const dbName = this.db; // Capture db at operation start
         insert = this.replaceIds(insert);
         for (let i = 0; i < insert.length; i++)
             await this._processHashedKeys(insert[i]);
         if (this.revisions)
             insert.forEach(ins => { ins._rev = 1; ins._ts = Base.timestamp(); });
         let ret = await this.executeTransactionally(collection, async (conn, client) => {
-            await this._processSequenceFieldForMany(client, collection, insert);
+            await this._processSequenceFieldForMany(client, dbName, collection, insert);
             let obj = await conn.insertMany(insert, this._sessionOpt());
             let ret = [];
             for (let ns of Object.keys(obj.insertedIds)) {
@@ -685,7 +635,7 @@ export class Mongo extends Db {
             if (this.emittingPublishEvents || this.emittingPublishRevEvents || this.auditing) {
                 for await (let rec of ret) {
                     if (rec)
-                        await this._publishAndAudit('insert', this.db, collection, rec);
+                        await this._publishAndAudit('insert', dbName, collection, rec);
                 }
             }
             return ret;
@@ -696,6 +646,7 @@ export class Mongo extends Db {
     async deleteOne(collection, query) {
         assert(collection);
         assert(query);
+        const dbName = this.db; // Capture db at operation start
         query = this.replaceIds(query);
         if (!this.softdelete) {
             const opts = this._sessionOpt();
@@ -703,7 +654,7 @@ export class Mongo extends Db {
             let ret = await this.executeTransactionally(collection, async (conn) => {
                 let obj = await conn.findOneAndDelete(query, opts);
                 if (obj)
-                    await this._publishAndAudit('delete', this.db, collection, obj);
+                    await this._publishAndAudit('delete', dbName, collection, obj);
                 return obj;
             }, false, { operation: "deleteOne", collection, query, softdelete: this.softdelete });
             log.debug('deleteOne returns', ret);
@@ -725,7 +676,7 @@ export class Mongo extends Db {
                 // if (this.syncSupport) del.$set._csq = await this._getNextCollectionUpdateSeqNo(collection, client)
                 let obj = await conn.findOneAndUpdate(query, del, opts);
                 if (obj)
-                    await this._publishAndAudit('delete', this.db, collection, obj);
+                    await this._publishAndAudit('delete', dbName, collection, obj);
                 return obj;
             }, false, { operation: "deleteOne", collection, query, softdelete: this.softdelete });
             log.debug('deleteOne returns', ret);
@@ -738,6 +689,7 @@ export class Mongo extends Db {
             returnDocument: "after",
             ...this._sessionOpt()
         };
+        const dbName = this.db; // Capture db at operation start
         query = this.replaceIds(query);
         log.debug('blockOne called', collection, query);
         let ret = await this.executeTransactionally(collection, async (conn) => {
@@ -753,7 +705,7 @@ export class Mongo extends Db {
                 return {
                     ok: false
                 };
-            await this._publishAndAudit('block', this.db, collection, obj);
+            await this._publishAndAudit('block', dbName, collection, obj);
             return obj;
         }, false, { operation: "blockOne", collection, query });
         log.debug('blockOne returns', ret);
@@ -765,6 +717,7 @@ export class Mongo extends Db {
             returnDocument: "after",
             ...this._sessionOpt()
         };
+        const dbName = this.db; // Capture db at operation start
         query = this.replaceIds(query);
         log.debug('unblockOne called', collection, query);
         let ret = await this.executeTransactionally(collection, async (conn) => {
@@ -780,7 +733,7 @@ export class Mongo extends Db {
                 return {
                     ok: false
                 };
-            await this._publishAndAudit('unblock', this.db, collection, obj);
+            await this._publishAndAudit('unblock', dbName, collection, obj);
             return obj;
         }, false, { operation: "unblockOne", collection, query });
         log.debug('unblockOne returns', ret);
@@ -789,6 +742,7 @@ export class Mongo extends Db {
     async hardDeleteOne(collection, query) {
         assert(collection);
         assert(query);
+        const dbName = this.db; // Capture db at operation start
         if (typeof query === "string" || typeof query === "number" || query instanceof ObjectId) {
             query = { _id: query };
         }
@@ -801,7 +755,7 @@ export class Mongo extends Db {
         let ret = await this.executeTransactionally(collection, async (conn) => {
             let obj = await conn.findOneAndDelete(query, opts);
             if (obj) {
-                await this._publishAndAudit('delete', this.db, collection, obj);
+                await this._publishAndAudit('delete', dbName, collection, obj);
             }
             return obj;
         }, false, { operation: "hardDeleteOne", collection, query });
@@ -812,6 +766,7 @@ export class Mongo extends Db {
         assert(collection);
         assert(query);
         // if (this.syncSupport) log.warn("delete does not increase _csq, avoit it.")
+        const dbName = this.db; // Capture db at operation start
         query = this.replaceIds(query);
         if (!this.softdelete) {
             const opts = this._sessionOpt();
@@ -822,7 +777,7 @@ export class Mongo extends Db {
                     n: obj.deletedCount,
                     ok: !!obj.acknowledged
                 };
-                await this._publishAndAudit('deleteMany', this.db, collection, resObj);
+                await this._publishAndAudit('deleteMany', dbName, collection, resObj);
                 return resObj;
             }, false, { operation: "delete", collection, query, softdelete: this.softdelete });
             log.debug('delete returns', ret);
@@ -847,7 +802,7 @@ export class Mongo extends Db {
                     n: obj.modifiedCount,
                     ok: !!obj.acknowledged
                 };
-                await this._publishAndAudit('deleteMany', this.db, collection, resObj);
+                await this._publishAndAudit('deleteMany', dbName, collection, resObj);
                 return resObj;
             }, false, { operation: "delete", collection, query, softdelete: this.softdelete });
             log.debug('delete returns', ret);
@@ -858,6 +813,7 @@ export class Mongo extends Db {
         assert(collection);
         assert(query);
         // if (this.syncSupport) log.warn("hardDelete does not increase _csq, avoit it.")
+        const dbName = this.db; // Capture db at operation start
         query = this.replaceIds(query);
         const opts = this._sessionOpt();
         log.debug('hardDelete called', collection, query);
@@ -867,7 +823,7 @@ export class Mongo extends Db {
                 n: obj.deletedCount,
                 ok: !!obj.acknowledged
             };
-            await this._publishAndAudit('deleteMany', this.db, collection, resObj);
+            await this._publishAndAudit('deleteMany', dbName, collection, resObj);
             return resObj;
         }, false, { operation: "hardDelete", collection, query, softdelete: this.softdelete });
         log.debug('hardDelete returns', ret);
@@ -886,8 +842,9 @@ export class Mongo extends Db {
             _field = field;
         if (!/^__hashed__/.test(_field))
             _field = "__hashed__" + _field;
+        const dbName = this.db; // Capture db at operation start
         let conn = await this.connect();
-        let obj = await conn.db(this.db).collection(collection).findOne(query, { projection: { [_field]: 1 }, ...this._sessionOpt() });
+        let obj = await conn.db(dbName).collection(collection).findOne(query, { projection: { [_field]: 1 }, ...this._sessionOpt() });
         if (!obj || !obj[_field]) {
             log.debug('testHash returns false', obj);
             return false;
@@ -963,18 +920,20 @@ export class Mongo extends Db {
     async dropCollection(collection) {
         assert(collection);
         log.debug('dropCollection called', this.auditCollections);
+        const dbName = this.db; // Capture db at operation start
         let client = await this.connect();
-        let existing = await client.db(this.db).collections();
+        let existing = await client.db(dbName).collections();
         if (existing.map((c) => c.collectionName).includes(collection)) {
-            await client.db(this.db).dropCollection(collection);
+            await client.db(dbName).dropCollection(collection);
         }
         log.debug('dropCollection returns');
     }
     async resetCollectionSync(collection) {
         assert(collection);
         log.debug('resetCollectionSync called for', collection);
+        const dbName = this.db; // Capture db at operation start
         let client = await this.connect();
-        await client.db(this.db)
+        await client.db(dbName)
             .collection(SEQUENCES_COLLECTION)
             .findOneAndDelete({ collection });
         log.debug(`resetCollectionSync for ${collection} returns`);
@@ -983,11 +942,12 @@ export class Mongo extends Db {
         assert(collections);
         assert(collections instanceof Array);
         log.debug('dropCollections called', this.auditCollections);
+        const dbName = this.db; // Capture db at operation start
         let client = await this.connect();
-        let existing = await client.db(this.db).collections();
+        let existing = await client.db(dbName).collections();
         for await (let collection of collections) {
             if (existing.map((c) => c.collectionName).includes(collection)) {
-                await client.db(this.db).dropCollection(collection);
+                await client.db(dbName).dropCollection(collection);
             }
         }
         log.debug('dropCollections returns');
@@ -996,11 +956,12 @@ export class Mongo extends Db {
         assert(collections);
         assert(collections instanceof Array);
         log.debug('createCollections called', this.auditCollections);
+        const dbName = this.db; // Capture db at operation start
         let client = await this.connect();
         let existing = await this.getCollections();
         for await (let collection of collections) {
             if (!existing.includes(collection)) {
-                await client.db(this.db).createCollection(collection);
+                await client.db(dbName).createCollection(collection);
             }
         }
         log.debug('createCollections returns');
@@ -1008,23 +969,25 @@ export class Mongo extends Db {
     async createCollection(collection) {
         assert(collection);
         log.debug('createCollection called', collection);
+        const dbName = this.db; // Capture db at operation start
         let client = await this.connect();
         let existing = await this.getCollections();
         if (!existing.includes(collection)) {
-            await client.db(this.db).createCollection(collection);
+            await client.db(dbName).createCollection(collection);
         }
         log.debug('createCollection returns');
     }
     async dbLogPurge(collection, _id) {
         assert(collection);
         log.debug('dblogPurge called', collection, _id);
+        const dbName = this.db; // Capture db at operation start
         let ret = await this.executeTransactionally(collection, async () => {
-            let cond = { db: this.db, collection, };
+            let cond = { db: dbName, collection, };
             if (_id !== undefined)
                 cond._id = Mongo._toId(_id);
             let client = await this.connect();
             let ret = await client
-                .db(this.db)
+                .db(dbName)
                 .collection(this.auditCollectionName)
                 .deleteMany(cond, this._sessionOpt());
             return {
@@ -1038,13 +1001,14 @@ export class Mongo extends Db {
     async dbLogGet(collection, _id) {
         assert(collection);
         log.debug('dblogGet called', collection, _id);
+        const dbName = this.db; // Capture db at operation start
         let ret = await this.executeTransactionally(collection, async () => {
-            let cond = { db: this.db, collection };
+            let cond = { db: dbName, collection };
             if (_id)
                 cond.entityid = Mongo._toId(_id);
             let client = await this.connect();
             let ret = await client
-                .db(this.db)
+                .db(dbName)
                 .collection(this.auditCollectionName)
                 .find(cond, this._sessionOpt())
                 .sort({ _id: -1 })
@@ -1110,7 +1074,7 @@ export class Mongo extends Db {
         // this.session = undefined;
         return this.client;
     }
-    async close() {
+    async close(force = true) {
         // 1. Handle active transactions
         if (this.session) {
             try {
@@ -1136,10 +1100,12 @@ export class Mongo extends Db {
         }
         // 3. Close parent connection
         try {
-            await super.close();
+            await super.close(force);
             log.info("connection closed");
         }
-        catch { /** intentionally */ }
+        catch (err) {
+            log.debug(`close parent connection failed: ${err.message || err}`);
+        }
         // 4. Clean up state
         this.session = undefined;
     }
@@ -1236,7 +1202,7 @@ export class Mongo extends Db {
             log.error(`abortTransaction error ${err.message || err}`);
         }
     }
-    async _try_once(useTransaction, f, collection) {
+    async _try_once(useTransaction, f, collection, dbName) {
         try {
             let conn = await this.connect();
             if (useTransaction)
@@ -1246,8 +1212,8 @@ export class Mongo extends Db {
              * prewarm Mongo to avoid mongo bug
              *  "Cannot run getMore on cursor ... which was created in session ..., without an lsid
              */
-            await (conn.db(this.db).collection(collection).findOne({}));
-            let ret = await f(conn.db(this.db).collection(collection), conn);
+            // await (conn.db(dbName).collection(collection).findOne({}))
+            let ret = await f(conn.db(dbName).collection(collection), conn);
             if (useTransaction)
                 await this.commitTransaction();
             return ret;
@@ -1257,20 +1223,23 @@ export class Mongo extends Db {
                 if (useTransaction)
                     await this.abortTransaction();
             }
-            catch { /* intentionally */ }
+            catch (abortErr) {
+                log.debug(`abort transaction failed: ${abortErr.message || abortErr}`);
+            }
             throw err;
         }
     }
     async executeTransactionally(collection, f, useTransaction = false, debugObject) {
+        const dbName = this.db; // Capture db at operation start
         try {
             // NOTE - add this.syncSuppoer to use transactions for _csq increases
             // Adds A LOT of performance penalty - soft.js takes 20x longer!!! (5.2s vs 250ms)
             //let useTransaction = /* this.syncSupport || */ this._shouldAuditCollection(this.db, collection);
             //if (useTransaction && !await this.inTransaction()) useTransaction=true;
-            return await this._try_once(useTransaction, f, collection);
+            return await this._try_once(useTransaction, f, collection, dbName);
         }
         catch (err) {
-            log.error(`Mongo command has failed for ${this.db}.${collection} - ${(this.session ? "ROLLBACK - " : "")} ${err.message || err}`);
+            log.error(`Mongo command has failed for ${dbName}.${collection} - ${(this.session ? "ROLLBACK - " : "")} ${err.message || err}`);
             log.error(debugObject);
             log.debug(err);
             let x = ((err === null || err === void 0 ? void 0 : err.message) || (err === null || err === void 0 ? void 0 : err.toString()) || "").toString();
@@ -1291,7 +1260,7 @@ export class Mongo extends Db {
                     await this.close();
                     // a single retry
                     await super.connect();
-                    let ret = await this._try_once(useTransaction, f, collection);
+                    let ret = await this._try_once(useTransaction, f, collection, dbName);
                     log.error("OK - Retry succeeded.");
                     log.error("");
                     return ret;
@@ -1340,13 +1309,13 @@ export class Mongo extends Db {
         let seqKeys = Object.keys(object).filter(key => object[key] === 'SEQ_NEXT' || object[key] === 'SEQ_LAST');
         return ((seqKeys === null || seqKeys === void 0 ? void 0 : seqKeys.length) > 0 || this.syncSupport) ? { seqKeys } : undefined;
     }
-    async _processSequenceField(client, collection, insert, seqKeys) {
+    async _processSequenceField(client, dbName, collection, insert, seqKeys) {
         assert(this.client);
         // if (this.syncSupport) {
         //     insert._csq = (await this._getNextCollectionUpdateSeqNo(collection, client));
         // }
         for await (let seqKey of (seqKeys === null || seqKeys === void 0 ? void 0 : seqKeys.seqKeys) || []) {
-            let last = await this._findLastSequenceForKey(client.db(this.db).collection(collection), seqKey);
+            let last = await this._findLastSequenceForKey(client.db(dbName).collection(collection), seqKey);
             if (last === undefined) {
                 await this.createCollection(collection);
                 last = 0;
@@ -1356,7 +1325,7 @@ export class Mongo extends Db {
         }
         return insert;
     }
-    async _processSequenceFieldForMany(connection, collection, inserts) {
+    async _processSequenceFieldForMany(connection, dbName, collection, inserts) {
         assert(this.client);
         assert(connection);
         if (!(inserts === null || inserts === void 0 ? void 0 : inserts.length))
@@ -1372,12 +1341,12 @@ export class Mongo extends Db {
         if (!seqKeys.length)
             return inserts;
         for await (let seqKey of seqKeys) {
-            let last = await this._findLastSequenceForKey(connection.db(this.db).collection(collection), seqKey);
+            let last = await this._findLastSequenceForKey(connection.db(dbName).collection(collection), seqKey);
             if (last === undefined) {
                 try {
                     await this.createCollection(collection);
                 }
-                catch { /* intentionaly */ }
+                catch { /* collection may already exist */ }
                 last = 0;
             }
             for (let insert of inserts) {
@@ -1417,12 +1386,8 @@ export class Mongo extends Db {
     _shouldAuditCollection(db, col, audited = this.auditedCollections) {
         if (!this.auditing)
             return false;
-        for (let m of audited) {
-            let r = (db ? db + "." : "") + (col || "");
-            if (new RegExp(m, "i").test(r))
-                return true;
-        }
-        return false;
+        const fullName = ((db ? db + "." : "") + (col || "")).toLowerCase();
+        return audited.some(m => fullName.includes(m.toLowerCase()));
     }
     async _publishAndAudit(operation, db, collection, dataToPublish, noEmit) {
         if (!dataToPublish._id && !["deleteMany", "updateMany"].includes(operation))
@@ -1453,9 +1418,9 @@ export class Mongo extends Db {
                 toPublishAll.push(toPublish);
             }
         }
-        if (this._shouldAuditCollection(this.db, collection)) {
+        if (this._shouldAuditCollection(db, collection)) {
             if (['insert', 'update', 'delete', 'block', 'unblock'].includes(operation))
-                await this._writeAuditRecord(collection, operation, data);
+                await this._writeAuditRecord(db, collection, operation, data);
         }
         return toPublishAll;
     }
@@ -1482,6 +1447,7 @@ export class Mongo extends Db {
                 operation,
                 _id: data._id,
                 _ts: data._ts,
+                _rev: data._rev,
                 enquireLastTs: !data._ts,
             }
         };
@@ -1496,11 +1462,11 @@ export class Mongo extends Db {
         if (event === "publishRev")
             this.emitter.emit(event, what);
     }
-    async _writeAuditRecord(collection, operation, data, user = this.user, audit = this.audit) {
+    async _writeAuditRecord(db, collection, operation, data, user = this.user, audit = this.audit) {
         if (!this.auditing)
             return;
         let client = await this.connect();
-        let previousAuditRecords = await (await client.db(this.db).collection(this.auditCollectionName).aggregate([
+        let previousAuditRecords = await (await client.db(db).collection(this.auditCollectionName).aggregate([
             { $match: { entityid: Mongo._toId(data._id) } },
             { $sort: { rev: -1 } },
             { $limit: 1 }
@@ -1511,7 +1477,7 @@ export class Mongo extends Db {
         let dataNoId = { ...data };
         delete dataNoId._id;
         let auditRecord = {
-            db: this.db,
+            db: db,
             collection: collection,
             entityid: Base.objectid(data._id),
             rev: ((previousAuditRecord === null || previousAuditRecord === void 0 ? void 0 : previousAuditRecord.rev) || 0) + 1,
@@ -1525,7 +1491,7 @@ export class Mongo extends Db {
         if (audit)
             auditRecord.audit = audit;
         log.trace('AUDITING', auditRecord);
-        let ret = await client.db(this.db)
+        let ret = await client.db(db)
             .collection(this.auditCollectionName)
             .insertOne(auditRecord, this._sessionOpt());
         log.debug('AUDITED', auditRecord, ret.insertedId);
@@ -1533,6 +1499,28 @@ export class Mongo extends Db {
     _sessionOpt() {
         return this.session ? { session: this.session } : {};
     }
+    _buildFindOptions(opts) {
+        const findOpts = {};
+        if (opts.readPreference)
+            findOpts.readPreference = opts.readPreference;
+        if (this.session)
+            findOpts.session = this.session;
+        return findOpts;
+    }
+    _applyQueryOpts(cursor, opts) {
+        let r = cursor;
+        if (opts.project)
+            r = r.project(opts.project);
+        if (opts.sort)
+            r = r.sort(opts.sort);
+        if (opts.skip)
+            r = r.skip(opts.skip);
+        if (opts.limit)
+            r = r.limit(opts.limit);
+        if (opts.collation)
+            r = r.collation(opts.collation);
+        return r;
+    }
     async _processUpdateObject(update) {
         await this._processHashedKeys(update);
         for (let k in update) {