cry-db 2.1.26 → 2.1.29

package/dist/mongo.js

@@ -1,27 +1,32 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DummyExportToFixTsCompilation = void 0;
-const assert_1 = __importDefault(require("assert"));
-const bcrypt_1 = __importDefault(require("bcrypt"));
-const mongodb_1 = require("mongodb");
-const tiny_typed_emitter_1 = require("tiny-typed-emitter");
-const _1 = require(".");
-const db_1 = require("./db");
-const types_1 = require("./types");
-const lodash_clonedeep_1 = __importDefault(require("lodash.clonedeep"));
+import assert from "assert";
+import bcrypt from 'bcrypt';
+import { ObjectId, ReadConcern, ReadPreference, Timestamp, WriteConcern } from 'mongodb';
+import { TypedEmitter } from "tiny-typed-emitter";
+import { Db, log } from './db.js';
+import { SEQUENCES_COLLECTION } from './types.js';
+import cloneDeep from "lodash.clonedeep";
+import { Base } from "./base.js";
 const saltRounds = 10;
 const TRANSACTION_OPTIONS = {
     defaultTransactionOptions: {
-        readPreference: new mongodb_1.ReadPreference("primary"),
-        readConcern: new mongodb_1.ReadConcern("local"),
-        writeConcern: new mongodb_1.WriteConcern("majority")
+        readPreference: new ReadPreference("primary"),
+        readConcern: new ReadConcern("local"),
+        writeConcern: new WriteConcern("majority")
     }
 };
-exports.DummyExportToFixTsCompilation = true;
-class Mongo extends db_1.Db {
+export const DummyExportToFixTsCompilation = true;
+export default class Mongo extends Db {
+    revisions;
+    softdelete;
+    session;
+    emittingPublishEvents;
+    auditing;
+    auditCollectionName;
+    auditedCollections;
+    emitter;
+    user;
+    audit;
+    syncSupport;
     constructor(db, url) {
         super(db, url);
         this.revisions = false;
@@ -32,30 +37,21 @@ class Mongo extends db_1.Db {
         this.auditing = false;
         this.auditCollectionName = "dblog";
         this.auditedCollections = this.auditCollections(process.env.AUDIT_COLLECTIONS || []);
-        this.emitter = new tiny_typed_emitter_1.TypedEmitter();
+        this.emitter = new TypedEmitter();
         this.user = undefined;
         this.audit = undefined;
-        db_1.log.debug('new Mongo:', this.url, this.db);
-    }
-    static newid() {
-        return db_1.Db.newid();
-    }
-    static toId(id) {
-        return db_1.Db.toId(id);
-    }
-    static objectid(o) {
-        return db_1.Db.objectid(o);
+        log.debug('new Mongo:', this.url, this.db);
     }
     on(evt, listener) {
-        db_1.log.debug("on", evt, listener);
+        log.debug("on", evt, listener);
         this.emitter.on(evt, listener);
     }
     off(evt, listener) {
-        db_1.log.debug("off", evt, listener);
+        log.debug("off", evt, listener);
         this.emitter.off(evt, listener);
     }
     once(evt, listener) {
-        db_1.log.debug("off", evt, listener);
+        log.debug("off", evt, listener);
         this.emitter.off(evt, listener);
     }
     setUser(username) {
@@ -125,29 +121,29 @@ class Mongo extends db_1.Db {
         return this.emittingPublishEvents;
     }
     async distinct(collection, field) {
-        db_1.log.debug('distinct called', collection, field);
+        log.debug('distinct called', collection, field);
         let ret = await this.executeTransactionally(collection, async (conn) => {
             return await conn.distinct(field);
         }, false, { operation: "distinct", collection, field });
-        db_1.log.debug('distinct returns', ret);
+        log.debug('distinct returns', ret);
         return ret;
     }
     async count(collection, query = {}, opts = {}) {
-        db_1.log.debug('distinct called', collection, query, opts);
+        log.debug('distinct called', collection, query, opts);
         let ret = await this.executeTransactionally(collection, async (conn) => {
             return await conn.countDocuments(query, opts);
         }, false, { operation: "count", collection, query, opts });
-        db_1.log.debug('count returns', ret);
+        log.debug('count returns', ret);
         return ret;
     }
     async find(collection, query = {}, opts = {}) {
-        (0, assert_1.default)(collection);
+        assert(collection);
         query = this.replaceIds(query);
         if (this.softdelete) {
             if (!query._deleted)
                 query._deleted = { $exists: false };
         }
-        db_1.log.debug('find called', collection, query, opts);
+        log.debug('find called', collection, query, opts);
         let ret = await this.executeTransactionally(collection, async (conn) => {
             let optsIn = {};
             if (opts.readPreference)
@@ -168,11 +164,11 @@ class Mongo extends db_1.Db {
             let res = await r.toArray();
             return this._processReturnedObject(res);
         }, false, { operation: "find", collection, query, opts });
-        db_1.log.debug('find returns', ret);
+        log.debug('find returns', ret);
         return ret;
     }
     async findAll(collection, query = {}, opts = {}) {
-        (0, assert_1.default)(collection);
+        assert(collection);
         query = this.replaceIds(query);
         let ret = await this.executeTransactionally(collection, async (conn) => {
             let optsIn = {};
@@ -193,12 +189,12 @@ class Mongo extends db_1.Db {
                 r = r.collation(opts.collation);
             return this._processReturnedObject(await r.toArray());
         }, false, { operation: "findAll", collection, query, opts });
-        db_1.log.debug('findAll returns', ret);
+        log.debug('findAll returns', ret);
         return ret;
     }
     async findNewer(collection, timestamp, query = {}, opts = {}) {
         query = this._createQueryForNewer(timestamp, query);
-        db_1.log.debug('findNewer called', collection, timestamp, query, opts);
+        log.debug('findNewer called', collection, timestamp, query, opts);
         let ret = await this.executeTransactionally(collection, async (conn) => {
             let optsIn = {};
             if (opts.readPreference)
@@ -220,11 +216,11 @@ class Mongo extends db_1.Db {
                 r = r.collation(opts.collation);
             return this._processReturnedObject(await r.toArray());
         }, false, { operation: "findNewer", collection, timestamp, query, opts });
-        db_1.log.debug('findNewer returns', ret);
+        log.debug('findNewer returns', ret);
         return ret;
     }
     async findNewerMany(spec = []) {
-        db_1.log.debug('findNewerMany called', spec);
+        log.debug('findNewerMany called', spec);
         let conn = await this.connect();
         const getOneColl = async (coll) => {
             let query = this._createQueryForNewer(coll.timestamp, coll.query);
@@ -257,7 +253,7 @@ class Mongo extends db_1.Db {
     _createQueryForNewer(timestamp, query) {
         let ts = (timestamp === 1 || timestamp === "1" || timestamp === "0" || timestamp === 0)
             ? {}
-            : { _ts: { $gt: _1.Base.timestamp(timestamp) } };
+            : { _ts: { $gt: Base.timestamp(timestamp) } };
         query = {
             ...ts,
             ...(query || {}),
@@ -267,7 +263,7 @@ class Mongo extends db_1.Db {
     }
     async findAfter(collection, csq, query = {}, opts = {}) {
         query._csq = { $gt: csq };
-        db_1.log.debug('findAfter called', collection, csq, query, opts);
+        log.debug('findAfter called', collection, csq, query, opts);
         let ret = await this.executeTransactionally(collection, async (conn) => {
             let optsIn = {};
             if (opts.readPreference)
@@ -289,11 +285,11 @@ class Mongo extends db_1.Db {
                 r = r.collation(opts.collation);
             return this._processReturnedObject(await r.toArray());
         }, false, { operation: "findNewer", collection, csq, query, opts });
-        db_1.log.debug('findNewer returns', ret);
+        log.debug('findNewer returns', ret);
         return ret;
     }
     async findAfterMany(spec = []) {
-        db_1.log.debug('findAfterMany called', spec);
+        log.debug('findAfterMany called', spec);
         let conn = await this.connect();
         const getOneColl = async (coll) => {
             let r = conn
@@ -325,57 +321,57 @@ class Mongo extends db_1.Db {
         return out;
     }
     async findNewerFromDate(collection, date, query = {}, opts = {}) {
-        let ts = new mongodb_1.Timestamp(0, new Date(date).valueOf() / 1000);
-        db_1.log.debug('findNewerFromDate called', collection, date, query, opts);
+        let ts = new Timestamp(0, new Date(date).valueOf() / 1000);
+        log.debug('findNewerFromDate called', collection, date, query, opts);
         let ret = await Mongo.prototype.findNewer.call(this, collection, ts, query, opts); // prevent calling Repo.findNewer
-        db_1.log.debug('findNewerFromDate returns', ret);
+        log.debug('findNewerFromDate returns', ret);
         return ret;
     }
     async findOne(collection, query, projection) {
-        (0, assert_1.default)(collection);
-        (0, assert_1.default)(query);
+        assert(collection);
+        assert(query);
         query = this.replaceIds(query);
         if (!query._deleted)
             query._deleted = { $exists: false };
         // if (!query._blocked) query._blocked = { $exists: false };   // intentionally - blocked records are returned
-        db_1.log.debug('findOne called', collection, query, projection);
-        let ret = await this.executeTransactionally(collection, async (conn) => await conn.findOne(query, { projection, session: this.session }), false, { operation: "findOne", collection, query, projection });
-        db_1.log.debug('findOne returns', ret);
+        log.debug('findOne called', collection, query, projection);
+        let ret = await this.executeTransactionally(collection, async (conn) => await conn.findOne(query, { ...(projection ? { projection } : {}), ...this._sessionOpt() }), false, { operation: "findOne", collection, query, projection });
+        log.debug('findOne returns', ret);
         return this._processReturnedObject(ret);
     }
     async findById(collection, id, projection) {
-        (0, assert_1.default)(collection);
-        (0, assert_1.default)(id);
+        assert(collection);
+        assert(id);
         if (!id)
             return null;
         let query = {
             _id: Mongo._toId(id),
             // _deleted: { $exists: false }
         };
-        db_1.log.debug('findById called', this.db, collection, id, projection);
-        db_1.log.trace('findById executing with query', collection, query, projection);
+        log.debug('findById called', this.db, 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, session: this.session });
+            let r = await conn.findOne(query, { ...(projection ? { projection } : {}), ...this._sessionOpt() });
             return r;
         }, false, { operation: "findById", collection, id, projection });
-        if (ret === null || ret === void 0 ? void 0 : ret._deleted)
+        if (ret?._deleted)
             ret = null;
-        db_1.log.debug('findById returns', ret);
+        log.debug('findById returns', ret);
         return this._processReturnedObject(ret);
     }
     async updateOne(collection, query, update, options = { returnFullObject: false }) {
-        (0, assert_1.default)(collection);
-        (0, assert_1.default)(query);
-        (0, assert_1.default)(update);
+        assert(collection);
+        assert(query);
+        assert(update);
         query = this.replaceIds(query);
         update = this.replaceIds(update);
         let opts = {
             upsert: false,
             returnDocument: "after",
-            session: this.session,
+            ...this._sessionOpt()
         };
         update = await this._processUpdateObject(update);
-        db_1.log.debug('updateOne called', collection, query, update);
+        log.debug('updateOne called', collection, query, update);
         let seqKeys = this._findSequenceKeys(update.$set);
         let obj = await this.executeTransactionally(collection, async (conn, client) => {
             update.$set = update.$set || {};
@@ -386,25 +382,25 @@ class Mongo extends db_1.Db {
             let res = await conn.findOneAndUpdate(query, update, opts);
             if (!res.value)
                 return null;
-            let resObj = this._removeUnchanged(res.value, update, !!(options === null || options === void 0 ? void 0 : options.returnFullObject));
+            let resObj = this._removeUnchanged(res.value, update, !!options?.returnFullObject);
             await this._publishAndAudit('update', this.db, collection, resObj);
             return resObj;
         }, !!seqKeys, { operation: "updateOne", collection, query, update, options });
-        db_1.log.debug('updateOne returns', obj);
+        log.debug('updateOne returns', obj);
         return this._processReturnedObject(await obj);
     }
     async save(collection, update, id = undefined, options = { returnFullObject: false }) {
-        (0, assert_1.default)(collection);
-        (0, assert_1.default)(update);
+        assert(collection);
+        assert(update);
         update = this.replaceIds(update);
         let opts = {
             upsert: true,
             returnDocument: "after",
-            session: this.session,
+            ...this._sessionOpt()
         };
         let _id = Mongo.toId(id || update._id) || Mongo.newid();
         update = await this._processUpdateObject(update);
-        db_1.log.debug('save called', collection, id, update);
+        log.debug('save called', collection, id, update);
         let seqKeys = this._findSequenceKeys(update.$set);
         let obj = await this.executeTransactionally(collection, async (conn, client) => {
             update.$set = update.$set || {};
@@ -415,19 +411,19 @@ class Mongo extends db_1.Db {
             let res = await conn.findOneAndUpdate({ _id }, update, opts);
             if (!res.value)
                 return null;
-            let resObj = this._removeUnchanged(res.value, update, !!(options === null || options === void 0 ? void 0 : options.returnFullObject));
+            let resObj = this._removeUnchanged(res.value, update, !!options?.returnFullObject);
             await this._publishAndAudit('update', this.db, collection, resObj);
             return resObj;
         }, !!seqKeys, { operation: "save", collection, _id, update, options });
-        db_1.log.debug('save returns', obj);
+        log.debug('save returns', obj);
         return this._processReturnedObject(await obj);
     }
     async update(collection, query, update) {
-        (0, assert_1.default)(collection);
-        (0, assert_1.default)(query);
-        (0, assert_1.default)(update);
+        assert(collection);
+        assert(query);
+        assert(update);
         if (this.syncSupport)
-            db_1.log.warn("update does not increase _csq, avoit it.");
+            log.warn("update does not increase _csq, avoit it.");
         if (!Object.keys(update).length)
             return { n: 0, ok: false };
         query = this.replaceIds(query);
@@ -435,10 +431,10 @@ class Mongo extends db_1.Db {
         let opts = {
             upsert: false,
             returnDocument: "after",
-            session: this.session,
+            ...this._sessionOpt()
         };
         update = await this._processUpdateObject(update);
-        db_1.log.debug('update called', collection, query, update);
+        log.debug('update called', collection, query, update);
         let seqKeys = this._findSequenceKeys(update.$set);
         let obj = await this.executeTransactionally(collection, async (conn, client) => {
             update.$set = update.$set || {};
@@ -446,7 +442,7 @@ class Mongo extends db_1.Db {
                 await this._processSequenceField(client, collection, update.$set, seqKeys);
             if (update.$set === undefined || Object.keys(update.$set).length === 0)
                 delete update.$set;
-            db_1.log.debug('update called', collection, query, update);
+            log.debug('update called', collection, query, update);
             let res = await conn.updateMany(query, update, opts);
             let resObj = {
                 n: res.modifiedCount,
@@ -455,14 +451,14 @@ class Mongo extends db_1.Db {
             await this._publishAndAudit('updateMany', this.db, collection, resObj);
             return resObj;
         }, !!seqKeys, { operation: "update", collection, query, update });
-        db_1.log.debug('update returns', obj);
+        log.debug('update returns', obj);
         return await obj;
     }
     async upsert(collection, query, update, options = { returnFullObject: false }) {
-        (0, assert_1.default)(collection);
-        (0, assert_1.default)(query);
-        (0, assert_1.default)(update);
-        (0, assert_1.default)(typeof update === 'object', 'update must be an object');
+        assert(collection);
+        assert(query);
+        assert(update);
+        assert(typeof update === 'object', 'update must be an object');
         // if (!Object.keys(update).length) return null;
         query = this.replaceIds(query);
         update = this.replaceIds(update);
@@ -470,16 +466,15 @@ class Mongo extends db_1.Db {
             ...options,
             upsert: true,
             returnDocument: "after",
-            session: this.session,
+            ...this._sessionOpt()
         };
-        db_1.log.debug('upsert called', collection, query, update);
+        log.debug('upsert called', collection, query, update);
         update = await this._processUpdateObject(update);
         let seqKeys = this._findSequenceKeys(update.$set);
-        db_1.log.debug('upsert processed', collection, query, update);
+        log.debug('upsert processed', collection, query, update);
         if (Object.keys(query).length === 0)
             query._id = Mongo.newid();
         let ret = await this.executeTransactionally(collection, async (conn, client) => {
-            var _a;
             update.$set = update.$set || {};
             if (seqKeys)
                 await this._processSequenceField(client, collection, update.$set, seqKeys);
@@ -487,50 +482,49 @@ class Mongo extends db_1.Db {
                 delete update.$set;
             let ret = await conn.findOneAndUpdate(query, update, opts);
             if (ret.value) {
-                let oper = ((_a = ret.lastErrorObject) === null || _a === void 0 ? void 0 : _a.updatedExisting) ? "update" : "insert";
-                let retObj = oper === "insert" ? ret.value : this._removeUnchanged(ret.value, update, !!(options === null || options === void 0 ? void 0 : options.returnFullObject));
+                let oper = ret.lastErrorObject?.updatedExisting ? "update" : "insert";
+                let retObj = oper === "insert" ? ret.value : this._removeUnchanged(ret.value, update, !!options?.returnFullObject);
                 await this._publishAndAudit(oper, this.db, collection, retObj);
                 return retObj;
             }
             ;
             return ret;
         }, !!seqKeys, { operation: "upsert", query, update, options });
-        db_1.log.debug('upsert returns', ret);
+        log.debug('upsert returns', ret);
         return this._processReturnedObject(await ret);
     }
     async insert(collection, insert) {
-        (0, assert_1.default)(collection, "collection can't be null");
-        (0, assert_1.default)(insert, "insert can't be null");
-        (0, assert_1.default)(typeof insert === "object", "insert must be an object");
-        db_1.log.debug('insert called', collection, insert);
+        assert(collection, "collection can't be null");
+        assert(insert, "insert can't be null");
+        assert(typeof insert === "object", "insert must be an object");
+        log.debug('insert called', collection, insert);
         insert = this.replaceIds(insert);
         if (this.revisions) {
             insert._rev = 1;
-            insert._ts = _1.Base.timestamp();
+            insert._ts = Base.timestamp();
         }
         await this._processHashedKeys(insert);
         let seqKeys = this._findSequenceKeys(insert);
         let ret = await this.executeTransactionally(collection, async (conn, client) => {
             if (insert)
                 insert = await this._processSequenceField(client, collection, insert, seqKeys);
-            let obj = await conn.insertOne(insert, { session: this.session });
+            let obj = await conn.insertOne(insert, this._sessionOpt());
             let fullObj = { _id: obj.insertedId, ...insert };
             await this._publishAndAudit('insert', this.db, collection, fullObj);
             return fullObj;
         }, !!seqKeys, { operation: "insert", collection, insert });
-        db_1.log.debug('insert returns', ret);
+        log.debug('insert returns', ret);
         return this._processReturnedObject(await ret);
     }
     async upsertBatch(collection, batch) {
-        (0, assert_1.default)(collection, "collection can't be null");
-        (0, assert_1.default)(batch, "batch can't be null");
-        (0, assert_1.default)(batch instanceof Array, "batch must be an Array");
-        db_1.log.debug('upsertBatch called', collection, batch);
+        assert(collection, "collection can't be null");
+        assert(batch, "batch can't be null");
+        assert(batch instanceof Array, "batch must be an Array");
+        log.debug('upsertBatch called', collection, batch);
         batch = this.replaceIds(batch);
         for (let i = 0; i < batch.length; i++)
-            await this._processHashedKeys(batch[i].update);
+            await this._processHashedKeys(batch[i]?.update);
         let ret = await this.executeTransactionally(collection, async (conn, client) => {
-            var _a, _b;
             await this._processSequenceFieldForMany(client, collection, batch.map(b => b.update));
             let publications = [];
             let changes = [];
@@ -540,13 +534,13 @@ class Mongo extends db_1.Db {
                     ...(opts || {}),
                     upsert: true,
                     returnDocument: "after",
-                    session: this.session,
+                    ...this._sessionOpt()
                 };
                 update = await this._processUpdateObject(update);
                 let ret = (await conn.findOneAndUpdate(query, update, options));
-                if ((_a = ret === null || ret === void 0 ? void 0 : ret.value) === null || _a === void 0 ? void 0 : _a._id) {
-                    let oper = ((_b = ret.lastErrorObject) === null || _b === void 0 ? void 0 : _b.updatedExisting) ? "update" : "insert";
-                    let retObj = oper === "insert" ? ret.value : this._removeUnchanged(ret.value, update, !!(opts === null || opts === void 0 ? void 0 : opts.returnFullObject));
+                if (ret?.value?._id) {
+                    let oper = ret.lastErrorObject?.updatedExisting ? "update" : "insert";
+                    let retObj = oper === "insert" ? ret.value : this._removeUnchanged(ret.value, update, !!opts?.returnFullObject);
                     publications.push(await this._publishAndAudit(oper, this.db, collection, retObj, true));
                     changes.push(retObj);
                 }
@@ -559,28 +553,28 @@ class Mongo extends db_1.Db {
                         operation: "batch",
                         db: this.db,
                         collection,
-                        data: publications.map(p => p === null || p === void 0 ? void 0 : p.payload).filter(p => !!p)
+                        data: publications.map(p => p?.payload).filter(p => !!p)
                     }
                 });
             }
             return changes;
         }, false, { operation: "upsertBatch", collection, batch });
-        db_1.log.debug('upsertBatch returns', ret);
+        log.debug('upsertBatch returns', ret);
         return ret;
     }
     async insertMany(collection, insert) {
-        (0, assert_1.default)(collection, "collection can't be null");
-        (0, assert_1.default)(insert, "insert can't be null");
-        (0, assert_1.default)(insert instanceof Array, "insert must be an Array");
-        db_1.log.debug('insertMany called', collection, insert);
+        assert(collection, "collection can't be null");
+        assert(insert, "insert can't be null");
+        assert(insert instanceof Array, "insert must be an Array");
+        log.debug('insertMany called', collection, insert);
         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 = _1.Base.timestamp(); });
+            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);
-            let obj = await conn.insertMany(insert, { session: this.session });
+            let obj = await conn.insertMany(insert, this._sessionOpt());
             let ret = [];
             for (let ns of Object.keys(obj.insertedIds)) {
                 let n = Number(ns);
@@ -597,35 +591,35 @@ class Mongo extends db_1.Db {
             }
             return ret;
         }, false, { operation: "insertMany", collection, insert });
-        db_1.log.debug('insertMany returns', ret);
+        log.debug('insertMany returns', ret);
         return ret;
     }
     async deleteOne(collection, query) {
-        (0, assert_1.default)(collection);
-        (0, assert_1.default)(query);
+        assert(collection);
+        assert(query);
         query = this.replaceIds(query);
         if (!this.softdelete) {
             let opts = {
                 returnDocument: "after",
-                session: this.session,
+                ...this._sessionOpt()
             };
-            db_1.log.debug('deleteOne called', collection, query);
+            log.debug('deleteOne called', collection, query);
             let ret = await this.executeTransactionally(collection, async (conn) => {
                 let obj = await conn.findOneAndDelete(query, opts);
                 if (obj.value)
                     await this._publishAndAudit('delete', this.db, collection, obj.value);
                 return obj.value;
             }, false, { operation: "deleteOne", collection, query, softdelete: this.softdelete });
-            db_1.log.debug('deleteOne returns', ret);
+            log.debug('deleteOne returns', ret);
             return ret;
         }
         else {
             let opts = {
                 upsert: true,
                 returnDocument: "after",
-                session: this.session,
+                ...this._sessionOpt()
             };
-            db_1.log.debug('deleteOne called', collection, query);
+            log.debug('deleteOne called', collection, query);
             let ret = await this.executeTransactionally(collection, async (conn, client) => {
                 let del = {
                     $set: { _deleted: new Date() },
@@ -639,7 +633,7 @@ class Mongo extends db_1.Db {
                     await this._publishAndAudit('delete', this.db, collection, obj.value);
                 return obj.value;
             }, false, { operation: "deleteOne", collection, query, softdelete: this.softdelete });
-            db_1.log.debug('deleteOne returns', ret);
+            log.debug('deleteOne returns', ret);
             return ret;
         }
     }
@@ -647,10 +641,10 @@ class Mongo extends db_1.Db {
         let opts = {
             upsert: false,
             returnDocument: "after",
-            session: this.session,
+            ...this._sessionOpt()
         };
         query = this.replaceIds(query);
-        db_1.log.debug('blockOne called', collection, query);
+        log.debug('blockOne called', collection, query);
         let ret = await this.executeTransactionally(collection, async (conn, client) => {
             query._blocked = { $exists: 0 };
             let update = {
@@ -672,17 +666,17 @@ class Mongo extends db_1.Db {
             await this._publishAndAudit('block', this.db, collection, retObj);
             return retObj;
         }, false, { operation: "blockOne", collection, query });
-        db_1.log.debug('blockOne returns', ret);
+        log.debug('blockOne returns', ret);
         return ret;
     }
     async unblockOne(collection, query) {
         let opts = {
             upsert: false,
             returnDocument: "after",
-            session: this.session,
+            ...this._sessionOpt()
         };
         query = this.replaceIds(query);
-        db_1.log.debug('unblockOne called', collection, query);
+        log.debug('unblockOne called', collection, query);
         let ret = await this.executeTransactionally(collection, async (conn, client) => {
             query._blocked = { $exists: 1 };
             let update = {
@@ -703,18 +697,18 @@ class Mongo extends db_1.Db {
             await this._publishAndAudit('unblock', this.db, collection, retObj);
             return retObj;
         }, false, { operation: "unblockOne", collection, query });
-        db_1.log.debug('unblockOne returns', ret);
+        log.debug('unblockOne returns', ret);
         return ret;
     }
     async hardDeleteOne(collection, query) {
-        (0, assert_1.default)(collection);
-        (0, assert_1.default)(query);
+        assert(collection);
+        assert(query);
         query = this.replaceIds(query);
         let opts = {
             returnDocument: "after",
-            session: this.session,
+            ...this._sessionOpt()
         };
-        db_1.log.debug('hardDeleteOne called', collection, query);
+        log.debug('hardDeleteOne called', collection, query);
         let ret = await this.executeTransactionally(collection, async (conn) => {
             let obj = await conn.findOneAndDelete(query, opts);
             if (obj.value) {
@@ -722,21 +716,21 @@ class Mongo extends db_1.Db {
             }
             return obj.value;
         }, false, { operation: "hardDeleteOne", collection, query });
-        db_1.log.debug('hardDeleteOne returns', ret);
+        log.debug('hardDeleteOne returns', ret);
         return ret;
     }
     async delete(collection, query) {
-        (0, assert_1.default)(collection);
-        (0, assert_1.default)(query);
+        assert(collection);
+        assert(query);
         if (this.syncSupport)
-            db_1.log.warn("delete does not increase _csq, avoit it.");
+            log.warn("delete does not increase _csq, avoit it.");
         query = this.replaceIds(query);
         if (!this.softdelete) {
             let opts = {
                 returnDocument: "after",
-                session: this.session,
+                ...this._sessionOpt()
             };
-            db_1.log.debug('delete called', collection, query);
+            log.debug('delete called', collection, query);
             let ret = await this.executeTransactionally(collection, async (conn) => {
                 let obj = await conn.deleteMany(query, opts);
                 let resObj = {
@@ -746,17 +740,17 @@ class Mongo extends db_1.Db {
                 await this._publishAndAudit('deleteMany', this.db, collection, resObj);
                 return resObj;
             }, false, { operation: "delete", collection, query, softdelete: this.softdelete });
-            db_1.log.debug('delete returns', ret);
+            log.debug('delete returns', ret);
             return ret;
         }
         else {
             let opts = {
                 upsert: false,
                 returnDocument: "after",
-                session: this.session,
+                ...this._sessionOpt()
             };
             let date = new Date();
-            db_1.log.debug('delete called', collection, query);
+            log.debug('delete called', collection, query);
             let ret = await this.executeTransactionally(collection, async (conn) => {
                 let obj = await conn.updateMany(query, { $set: { _deleted: date } }, opts);
                 let resObj = {
@@ -766,21 +760,21 @@ class Mongo extends db_1.Db {
                 await this._publishAndAudit('deleteMany', this.db, collection, resObj);
                 return resObj;
             }, false, { operation: "delete", collection, query, softdelete: this.softdelete });
-            db_1.log.debug('delete returns', ret);
+            log.debug('delete returns', ret);
             return ret;
         }
     }
     async hardDelete(collection, query) {
-        (0, assert_1.default)(collection);
-        (0, assert_1.default)(query);
+        assert(collection);
+        assert(query);
         if (this.syncSupport)
-            db_1.log.warn("hardDelete does not increase _csq, avoit it.");
+            log.warn("hardDelete does not increase _csq, avoit it.");
         query = this.replaceIds(query);
         let opts = {
             returnDocument: "after",
-            session: this.session,
+            ...this._sessionOpt()
         };
-        db_1.log.debug('hardDelete called', collection, query);
+        log.debug('hardDelete called', collection, query);
         let ret = await this.executeTransactionally(collection, async (conn) => {
             let obj = await conn.deleteMany(query, opts);
             let resObj = {
@@ -790,12 +784,12 @@ class Mongo extends db_1.Db {
             await this._publishAndAudit('deleteMany', this.db, collection, resObj);
             return resObj;
         }, false, { operation: "hardDelete", collection, query, softdelete: this.softdelete });
-        db_1.log.debug('hardDelete returns', ret);
+        log.debug('hardDelete returns', ret);
         return ret;
     }
     async testHash(collection, query, field, unhashedValue) {
         let _field;
-        db_1.log.debug('teshHash called', collection, query, field, unhashedValue);
+        log.debug('teshHash called', collection, query, field, unhashedValue);
         if (typeof field === "object") {
             if (Object.keys(field).length === 1)
                 [_field, unhashedValue] = Object.entries(field)[0];
@@ -807,21 +801,21 @@ class Mongo extends db_1.Db {
         if (!/^__hashed__/.test(_field))
             _field = "__hashed__" + _field;
         let conn = await this.connect();
-        let obj = await conn.db(this.db).collection(collection).findOne(query, { projection: { [_field]: 1 }, session: this.session });
+        let obj = await conn.db(this.db).collection(collection).findOne(query, { projection: { [_field]: 1 }, ...this._sessionOpt() });
         if (!obj || !obj[_field]) {
-            db_1.log.debug('teshHash returns false', obj);
+            log.debug('teshHash returns false', obj);
             return false;
         }
-        let res = await bcrypt_1.default.compare(unhashedValue, obj[_field].hash);
-        db_1.log.debug('teshHash returns', res);
+        let res = await bcrypt.compare(unhashedValue, obj[_field].hash);
+        log.debug('teshHash returns', res);
         return res;
     }
     async aggregate(collection, pipeline, opts = {
-        readPreference: mongodb_1.ReadPreference.SECONDARY_PREFERRED,
+        readPreference: ReadPreference.SECONDARY_PREFERRED,
     }) {
-        (0, assert_1.default)(collection);
-        (0, assert_1.default)(pipeline instanceof Array);
-        db_1.log.debug('aggregate called', collection, pipeline);
+        assert(collection);
+        assert(pipeline instanceof Array);
+        log.debug('aggregate called', collection, pipeline);
         pipeline = this.replaceIds(pipeline);
         if (this.session)
             opts.session = this.session;
@@ -829,15 +823,15 @@ class Mongo extends db_1.Db {
             let res = await conn.aggregate(pipeline, opts).toArray();
             return res;
         }, false, { operation: "aggregate", collection, pipeline, opts });
-        db_1.log.debug('aggregare returns', ret);
+        log.debug('aggregare returns', ret);
         return ret;
     }
     async isUnique(collection, field, value, id) {
-        (0, assert_1.default)(collection);
-        (0, assert_1.default)(field);
-        (0, assert_1.default)(value);
-        db_1.log.debug('isUnuqie called', collection, field, value, id);
-        let _id = id === null || id === void 0 ? void 0 : id.toString();
+        assert(collection);
+        assert(field);
+        assert(value);
+        log.debug('isUnuqie called', collection, field, value, id);
+        let _id = id?.toString();
         let matches = await this.executeTransactionally(collection, async (conn) => {
             let agg = await conn.find({ [field]: value });
             let res = await agg.toArray();
@@ -850,13 +844,13 @@ class Mongo extends db_1.Db {
                 return false;
             }
         }
-        db_1.log.debug('isUnuqie returns', ret);
+        log.debug('isUnuqie returns', ret);
         return ret;
     }
     async collectFieldValues(collection, field, inArray = false, opts) {
-        (0, assert_1.default)(collection);
-        (0, assert_1.default)(field);
-        db_1.log.debug('collectFieldValues called', collection, field);
+        assert(collection);
+        assert(field);
+        log.debug('collectFieldValues called', collection, field);
         let pipeline = [
             { $group: { _id: '$' + field } },
             { $sort: { _id: 1 } }
@@ -871,33 +865,33 @@ class Mongo extends db_1.Db {
             let res = await agg.toArray();
             return res;
         }, false, { operation: "collectFieldValues", collection, field, inArray, pipeline, opts });
-        let ret = res === null || res === void 0 ? void 0 : res.map((v) => v._id);
-        db_1.log.debug('collectFieldValues returns', ret);
+        let ret = res?.map((v) => v._id);
+        log.debug('collectFieldValues returns', ret);
         return ret;
     }
     async dropCollection(collection) {
-        (0, assert_1.default)(collection);
-        db_1.log.debug('dropCollection called', this.auditCollections);
+        assert(collection);
+        log.debug('dropCollection called', this.auditCollections);
         let client = await this.connect();
         let existing = await client.db(this.db).collections();
         if (existing.map((c) => c.s.name).includes(collection)) {
             await client.db(this.db).dropCollection(collection);
         }
-        db_1.log.debug('dropCollection returns');
+        log.debug('dropCollection returns');
     }
     async resetCollectionSync(collection) {
-        (0, assert_1.default)(collection);
-        db_1.log.debug('resetCollectionSync called for', collection);
+        assert(collection);
+        log.debug('resetCollectionSync called for', collection);
         let client = await this.connect();
         await client.db(this.db)
-            .collection(types_1.SEQUENCES_COLLECTION)
+            .collection(SEQUENCES_COLLECTION)
             .findOneAndDelete({ collection });
-        db_1.log.debug(`resetCollectionSync for ${collection} returns`);
+        log.debug(`resetCollectionSync for ${collection} returns`);
     }
     async dropCollections(collections) {
-        (0, assert_1.default)(collections);
-        (0, assert_1.default)(collections instanceof Array);
-        db_1.log.debug('dropCollections called', this.auditCollections);
+        assert(collections);
+        assert(collections instanceof Array);
+        log.debug('dropCollections called', this.auditCollections);
         let client = await this.connect();
         let existing = await client.db(this.db).collections();
         for await (let collection of collections) {
@@ -905,12 +899,12 @@ class Mongo extends db_1.Db {
                 await client.db(this.db).dropCollection(collection);
             }
         }
-        db_1.log.debug('dropCollections returns');
+        log.debug('dropCollections returns');
     }
     async createCollections(collections) {
-        (0, assert_1.default)(collections);
-        (0, assert_1.default)(collections instanceof Array);
-        db_1.log.debug('createCollections called', this.auditCollections);
+        assert(collections);
+        assert(collections instanceof Array);
+        log.debug('createCollections called', this.auditCollections);
         let client = await this.connect();
         let existing = await this.getCollections();
         for await (let collection of collections) {
@@ -918,21 +912,21 @@ class Mongo extends db_1.Db {
                 await client.db(this.db).createCollection(collection);
             }
         }
-        db_1.log.debug('createCollections returns');
+        log.debug('createCollections returns');
     }
     async createCollection(collection) {
-        (0, assert_1.default)(collection);
-        db_1.log.debug('createCollection called', collection);
+        assert(collection);
+        log.debug('createCollection called', collection);
         let client = await this.connect();
         let existing = await this.getCollections();
         if (!existing.includes(collection)) {
             await client.db(this.db).createCollection(collection);
         }
-        db_1.log.debug('createCollection returns');
+        log.debug('createCollection returns');
     }
     async dbLogPurge(collection, _id) {
-        (0, assert_1.default)(collection);
-        db_1.log.debug('dblogPurge called', collection, _id);
+        assert(collection);
+        log.debug('dblogPurge called', collection, _id);
         let ret = await this.executeTransactionally(collection, async () => {
             let cond = { db: this.db, collection, };
             if (_id !== undefined)
@@ -941,18 +935,18 @@ class Mongo extends db_1.Db {
             let ret = await client
                 .db(this.db)
                 .collection(this.auditCollectionName)
-                .deleteMany(cond, { session: this.session });
+                .deleteMany(cond, this._sessionOpt());
             return {
                 ok: !!ret.acknowledged,
                 n: ret.deletedCount
             };
         }, false, { operation: "dbLogPurge", collection, _id });
-        db_1.log.debug('dblogPurge returns', ret);
+        log.debug('dblogPurge returns', ret);
         return ret;
     }
     async dbLogGet(collection, _id) {
-        (0, assert_1.default)(collection);
-        db_1.log.debug('dblogGet called', collection, _id);
+        assert(collection);
+        log.debug('dblogGet called', collection, _id);
         let ret = await this.executeTransactionally(collection, async () => {
             let cond = { db: this.db, collection };
             if (_id)
@@ -961,12 +955,12 @@ class Mongo extends db_1.Db {
             let ret = await client
                 .db(this.db)
                 .collection(this.auditCollectionName)
-                .find(cond, { session: this.session })
+                .find(cond, this._sessionOpt())
                 .sort({ _id: -1 })
                 .toArray();
             return ret;
         }, false, { operation: "dbLogGet", collection, _id });
-        db_1.log.debug('dblogGet returns', ret);
+        log.debug('dblogGet returns', ret);
         return ret;
     }
     // HELPER FUNCTIONS
@@ -984,9 +978,9 @@ class Mongo extends db_1.Db {
                 return undefined;
             if (typeof data === "symbol")
                 return data.toString();
-            if (data instanceof mongodb_1.ObjectId)
+            if (data instanceof ObjectId)
                 return data;
-            if (data instanceof mongodb_1.Timestamp)
+            if (data instanceof Timestamp)
                 return data;
             if (data instanceof Date)
                 return data;
@@ -996,17 +990,17 @@ class Mongo extends db_1.Db {
                 return data;
             if (data instanceof String)
                 return data;
-            if (typeof data === "string" && (data === null || data === void 0 ? void 0 : data.match(/^[0-9a-f]{24,24}$/g)))
-                return new mongodb_1.ObjectId(data);
+            if (typeof data === "string" && data?.match(/^[0-9a-f]{24,24}$/g))
+                return new ObjectId(data);
             if (typeof data === "string")
                 return data;
             if (data instanceof Array) {
                 return data.map(d => this.replaceIds(d));
             }
-            if (typeof data == 'object' && (data === null || data === void 0 ? void 0 : data.t) && (data === null || data === void 0 ? void 0 : data.i) !== undefined)
-                return _1.Base.timestamp(data);
-            if (typeof data == 'object' && (data === null || data === void 0 ? void 0 : data.high) && (data === null || data === void 0 ? void 0 : data.low) !== undefined)
-                return _1.Base.timestamp(data);
+            if (typeof data == 'object' && data?.t && data?.i !== undefined)
+                return Base.timestamp(data);
+            if (typeof data == 'object' && data?.high && data?.low !== undefined)
+                return Base.timestamp(data);
             if (typeof data == 'object') {
                 for (let key in data) {
                     data[key] = this.replaceIds(data[key]);
@@ -1021,7 +1015,7 @@ class Mongo extends db_1.Db {
         }
     }
     async connect() {
-        super.connect();
+        await super.connect();
         // this.session = undefined;
         return this.client;
     }
@@ -1029,16 +1023,16 @@ class Mongo extends db_1.Db {
         if (this.session)
             try {
                 await this.session.endSession();
-                db_1.log.info("session ended");
+                log.info("session ended");
             }
             catch (err) {
-                db_1.log.error(`Error ending session ${err.message}`);
+                log.error(`Error ending session ${err.message}`);
             }
         try {
             await super.close();
-            db_1.log.info("connection closed");
+            log.info("connection closed");
         }
-        catch ( /** intentionally */_a) { /** intentionally */ }
+        catch { /** intentionally */ }
         this.session = undefined;
     }
     async inTransaction() {
@@ -1056,13 +1050,13 @@ class Mongo extends db_1.Db {
             let hadSession = !!this.session;
             if (!this.session) {
                 this.session = client.startSession();
-                db_1.log.info("session started");
+                log.info("session started");
             }
             let session = this.session;
             await session.withTransaction(async () => await funct(client, session));
             if (!hadSession) {
                 session.endSession();
-                db_1.log.info("session ended");
+                log.info("session ended");
                 this.session = undefined;
             }
             return;
@@ -1078,24 +1072,24 @@ class Mongo extends db_1.Db {
         try {
             if (!this.session) {
                 this.session = client.startSession(TRANSACTION_OPTIONS);
-                db_1.log.info("session started");
+                log.info("session started");
             }
             if (!await this.inTransaction()) {
                 await this.session.startTransaction();
-                db_1.log.info("transaction started");
+                log.info("transaction started");
             }
         }
         catch (err) {
-            db_1.log.error('startTransaction error', err);
+            log.error('startTransaction error', err);
             try {
                 if (this.session) {
                     await this.session.endSession();
-                    db_1.log.info("session ended");
+                    log.info("session ended");
                 }
                 this.session = undefined;
             }
             catch (e) {
-                db_1.log.error("startTransaction - error in endSession", e.message || e);
+                log.error("startTransaction - error in endSession", e.message || e);
             }
             return;
         }
@@ -1108,13 +1102,13 @@ class Mongo extends db_1.Db {
                 return;
             let session = this.session;
             await session.commitTransaction();
-            db_1.log.info("transaction committed");
+            log.info("transaction committed");
             session.endSession();
             this.session = undefined;
-            db_1.log.info("session ended");
+            log.info("session ended");
         }
         catch (err) {
-            db_1.log.error(`commitTransaction error ${err.message || err}`);
+            log.error(`commitTransaction error ${err.message || err}`);
         }
     }
     async abortTransaction() {
@@ -1125,13 +1119,13 @@ class Mongo extends db_1.Db {
                 return;
             let session = this.session;
             await session.abortTransaction();
-            db_1.log.info("transaction aborted");
+            log.info("transaction aborted");
             await session.endSession();
             this.session = undefined;
-            db_1.log.info("session ended");
+            log.info("session ended");
         }
         catch (err) {
-            db_1.log.error(`abortTransaction error ${err.message || err}`);
+            log.error(`abortTransaction error ${err.message || err}`);
         }
     }
     async _try_once(useTransaction, f, collection) {
@@ -1155,7 +1149,7 @@ class Mongo extends db_1.Db {
                 if (useTransaction)
                     await this.abortTransaction();
             }
-            catch ( /* intentionally */_a) { /* intentionally */ }
+            catch { /* intentionally */ }
             throw err;
         }
     }
@@ -1168,9 +1162,9 @@ class Mongo extends db_1.Db {
             return await this._try_once(useTransaction, f, collection);
         }
         catch (err) {
-            db_1.log.error(`Mongo command has failed for ${this.db}.${collection} - ${(this.session ? "ROLLBACK - " : "")} ${err.message || err}`);
-            db_1.log.error(debugObject);
-            db_1.log.debug(err);
+            log.error(`Mongo command has failed for ${this.db}.${collection} - ${(this.session ? "ROLLBACK - " : "")} ${err.message || err}`);
+            log.error(debugObject);
+            log.debug(err);
             let x = (err || "").toString();
             console.log('x');
             let isRepeatable = x.match(/Topology is closed, please connect/i)
@@ -1179,21 +1173,21 @@ class Mongo extends db_1.Db {
                 || x.match(/Topology closed/);
             if (isRepeatable) {
                 try {
-                    db_1.log.error("Trying to reopen connection and repeat as");
+                    log.error("Trying to reopen connection and repeat as");
                     await this.close();
                     // a single retry
                     await super.connect();
                     let ret = await this._try_once(useTransaction, f, collection);
-                    db_1.log.error("OK - Retry succeeded.");
-                    db_1.log.error("");
+                    log.error("OK - Retry succeeded.");
+                    log.error("");
                     return ret;
                 }
                 catch (err2) {
                     /* intentional */
                     if (debugObject)
-                        db_1.log.error(debugObject);
-                    db_1.log.error(`FAIL - Retry failed: ${err2.message || err2}`);
-                    db_1.log.error("");
+                        log.error(debugObject);
+                    log.error(`FAIL - Retry failed: ${err2.message || err2}`);
+                    log.error("");
                 }
             }
             throw err;
@@ -1201,41 +1195,40 @@ class Mongo extends db_1.Db {
     }
     async _findLastSequenceForKey(connection, key) {
         let maxfld = await (connection
-            .find({}, { session: this.session })
+            .find({}, this._sessionOpt())
             .sort({ [key]: -1 })
             .limit(1)
             .toArray());
         if (maxfld.length === 0)
             return undefined;
-        return parseInt(maxfld[0][key]) || 0;
+        return parseInt(maxfld?.[0]?.[key]) || 0;
     }
     async _getNextCollectionUpdateSeqNo(collection, conn) {
-        var _a;
         let opts = {
             upsert: true,
             returnDocument: "after",
         };
         let nextSeq = await (conn.db(this.db)
-            .collection(types_1.SEQUENCES_COLLECTION)
+            .collection(SEQUENCES_COLLECTION)
             .findOneAndUpdate({ collection }, {
             $inc: { seq: 1 },
             $currentDate: { last: { $type: "date" }, ts: { $type: "timestamp" } }
         }, opts));
         conn.db(this.db).collection(collection);
-        return ((_a = nextSeq === null || nextSeq === void 0 ? void 0 : nextSeq.value) === null || _a === void 0 ? void 0 : _a.seq) || 1;
+        return nextSeq?.value?.seq || 1;
     }
     _findSequenceKeys(object) {
         if (!object)
             return;
         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;
+        return (seqKeys?.length > 0 || this.syncSupport) ? { seqKeys } : undefined;
     }
     async _processSequenceField(client, collection, insert, seqKeys) {
-        (0, assert_1.default)(this.client);
+        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) || []) {
+        for await (let seqKey of seqKeys?.seqKeys || []) {
             let last = await this._findLastSequenceForKey(client.db(this.db).collection(collection), seqKey);
             if (last === undefined) {
                 await this.createCollection(collection);
@@ -1247,21 +1240,21 @@ class Mongo extends db_1.Db {
         return insert;
     }
     async _processSequenceFieldForMany(connection, collection, inserts) {
-        (0, assert_1.default)(this.client);
-        (0, assert_1.default)(connection);
-        if (!(inserts === null || inserts === void 0 ? void 0 : inserts.length))
+        assert(this.client);
+        assert(connection);
+        if (!inserts?.length)
             return;
         let seqKeys = this._findSequenceKeys(inserts[0]);
         let seq = 0;
         if (this.syncSupport)
             seq = await this._getNextCollectionUpdateSeqNo(collection, connection);
-        for await (let seqKey of (seqKeys === null || seqKeys === void 0 ? void 0 : seqKeys.seqKeys) || []) {
+        for await (let seqKey of seqKeys?.seqKeys || []) {
             let last = await this._findLastSequenceForKey(connection.db(this.db).collection(collection), seqKey);
             if (last === undefined) {
                 try {
                     await this.createCollection(collection);
                 }
-                catch ( /* intentionaly */_a) { /* intentionaly */ }
+                catch { /* intentionaly */ }
                 last = 0;
             }
             for (let insert of inserts) {
@@ -1312,7 +1305,7 @@ class Mongo extends db_1.Db {
     async _publishAndAudit(operation, db, collection, dataToPublish, noEmit) {
         if (!dataToPublish._id && !["deleteMany", "updateMany"].includes(operation))
             throw new Error(`_publishAndAudit requires _id for ${operation}`);
-        let data = (0, lodash_clonedeep_1.default)(dataToPublish);
+        let data = cloneDeep(dataToPublish);
         if (data._id && /[0-9a-f]{24,24}/i.test(data._id.toString()))
             data._id = data._id.toHexString();
         let toPublish = undefined;
@@ -1343,7 +1336,7 @@ class Mongo extends db_1.Db {
         return toPublish;
     }
     emit(what) {
-        db_1.log.debug("emitting publish", what);
+        log.debug("emitting publish", what);
         this.emitter.emit('publish', what);
     }
     async _writeAuditRecord(collection, operation, data, user = this.user, audit = this.audit) {
@@ -1354,7 +1347,7 @@ class Mongo extends db_1.Db {
             { $match: { entityid: Mongo._toId(data._id) } },
             { $sort: { rev: -1 } },
             { $limit: 1 }
-        ], { session: this.session })).toArray();
+        ], this.session ? { session: this.session } : {})).toArray();
         let previousAuditRecord = previousAuditRecords.length ? previousAuditRecords[0] : { rev: 0, changes: {} };
         if (previousAuditRecords.length === 0)
             await this.createCollection(this.auditCollectionName);
@@ -1363,9 +1356,9 @@ class Mongo extends db_1.Db {
         let auditRecord = {
             db: this.db,
             collection: collection,
-            entityid: _1.Base.objectid(data._id),
-            rev: previousAuditRecord.rev + 1,
-            ts: _1.Base.timestamp(),
+            entityid: Base.objectid(data._id),
+            rev: (previousAuditRecord?.rev || 0) + 1,
+            ts: Base.timestamp(),
             on: new Date(),
             operation: operation,
             changes: dataNoId,
@@ -1374,11 +1367,14 @@ class Mongo extends db_1.Db {
             auditRecord.user = user;
         if (audit)
             auditRecord.audit = audit;
-        db_1.log.trace('AUDITING', auditRecord);
+        log.trace('AUDITING', auditRecord);
         let ret = await client.db(this.db)
             .collection(this.auditCollectionName)
-            .insertOne(auditRecord, { session: this.session });
-        db_1.log.debug('AUDITED', auditRecord, ret.insertedId);
+            .insertOne(auditRecord, this._sessionOpt());
+        log.debug('AUDITED', auditRecord, ret.insertedId);
+    }
+    _sessionOpt() {
+        return this.session ? { session: this.session } : {};
     }
     async _processUpdateObject(update) {
         await this._processHashedKeys(update);
@@ -1417,8 +1413,8 @@ class Mongo extends db_1.Db {
         for await (let key of Object.keys(update)) {
             let shouldBeHashed = /^__hashed_(.+)$/.test(key);
             if (shouldBeHashed) {
-                let salt = await bcrypt_1.default.genSalt(saltRounds);
-                let hash = await bcrypt_1.default.hash(update[key], salt);
+                let salt = await bcrypt.genSalt(saltRounds);
+                let hash = await bcrypt.hash(update[key], salt);
                 update[key] = { salt, hash };
             }
         }
@@ -1442,6 +1438,4 @@ class Mongo extends db_1.Db {
         return ret;
     }
 }
-exports.default = Mongo;
 module.exports = Mongo;
-//# sourceMappingURL=mongo.js.map