cry-db 2.0.6

package/dist/mongo.js

@@ -0,0 +1,1431 @@
+"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 saltRounds = 10;
+const TRANSACTION_OPTIONS = {
+    defaultTransactionOptions: {
+        readPreference: 'primary',
+        readConcern: { level: 'local' },
+        writeConcern: { w: 'majority' }
+    }
+};
+exports.DummyExportToFixTsCompilation = true;
+class Mongo extends db_1.Db {
+    constructor(db, url) {
+        super(db, url);
+        this.revisions = false;
+        this.softdelete = false;
+        this.syncSupport = false;
+        this.session = undefined;
+        this.emittingPublishEvents = false;
+        this.auditing = false;
+        this.auditCollectionName = "dblog";
+        this.auditedCollections = this.auditCollections(process.env.AUDIT_COLLECTIONS || []);
+        this.emitter = new tiny_typed_emitter_1.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);
+    }
+    on(evt, listener) {
+        db_1.log.debug("on", evt, listener);
+        this.emitter.on(evt, listener);
+    }
+    off(evt, listener) {
+        db_1.log.debug("off", evt, listener);
+        this.emitter.off(evt, listener);
+    }
+    once(evt, listener) {
+        db_1.log.debug("off", evt, listener);
+        this.emitter.off(evt, listener);
+    }
+    setUser(username) {
+        return this.user = username;
+    }
+    setAudit(obj) {
+        return this.audit = obj;
+    }
+    useRevisions(enabled) {
+        return this.revisions = !!enabled;
+    }
+    usesRevisions() {
+        return this.revisions;
+    }
+    useSoftDelete(enabled) {
+        return this.softdelete = !!enabled;
+    }
+    usesSoftDelete() {
+        return this.softdelete;
+    }
+    useAuditing(enabled) {
+        return this.auditing = enabled;
+    }
+    usesAuditing() {
+        return this.auditing;
+    }
+    useSync(enabled) {
+        return this.syncSupport = enabled;
+    }
+    usesSync() {
+        return this.syncSupport;
+    }
+    auditToCollection(c) {
+        if (c)
+            return this.auditCollectionName = c;
+        return this.auditCollectionName;
+    }
+    auditCollection(coll, enable = true) {
+        coll = coll.toLowerCase().trim();
+        if (typeof enable !== "boolean")
+            throw new Error("auditCollection: second argument must be a boolean");
+        if (enable) {
+            if (this.auditedCollections.includes(coll))
+                return;
+            this.auditedCollections.push(coll);
+        }
+        else {
+            this.auditedCollections = this.auditedCollections.filter((c) => c != coll);
+        }
+    }
+    auditCollections(arr) {
+        if (arr === undefined)
+            return this.auditedCollections;
+        if (arr && typeof arr === "string")
+            this.auditedCollections = arr.toString().split(',').map(a => a.trim().toLowerCase()).filter(a => !!a);
+        if (arr instanceof Array)
+            this.auditedCollections = arr.map(a => a.trim().toLowerCase()).filter(a => !!a);
+        return this.auditedCollections;
+    }
+    auditingCollection(coll, db = this.db) {
+        return this._shouldAuditCollection(db, coll);
+    }
+    emitPublishEvents(enabled) {
+        return this.emittingPublishEvents = enabled;
+    }
+    emitsPublishEvents() {
+        return this.emittingPublishEvents;
+    }
+    async distinct(collection, field) {
+        db_1.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);
+        return ret;
+    }
+    async count(collection, query = {}, opts = {}) {
+        db_1.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);
+        return ret;
+    }
+    async find(collection, query = {}, opts = {}) {
+        (0, assert_1.default)(collection);
+        query = this.replaceIds(query);
+        if (this.softdelete) {
+            if (!query._deleted)
+                query._deleted = { $exists: false };
+        }
+        db_1.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);
+        }, false, { operation: "find", collection, query, opts });
+        db_1.log.debug('find returns', ret);
+        return ret;
+    }
+    async findAll(collection, query = {}, opts = {}) {
+        (0, assert_1.default)(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);
+            return this._processReturnedObject(await r.toArray());
+        }, false, { operation: "findAll", collection, query, opts });
+        db_1.log.debug('findAll returns', ret);
+        return ret;
+    }
+    async findNewer(collection, timestamp, query = {}, opts = {}) {
+        if (timestamp === 1 || timestamp === "1" || timestamp === "0" || timestamp === 0)
+            timestamp = new Date(0);
+        if (!(timestamp instanceof mongodb_1.Timestamp))
+            timestamp = _1.Base.timestamp(timestamp);
+        query._ts = { $gt: timestamp };
+        // query._deleted = { $exists: false }; // intentionally not set, to forward deletions 
+        // query._blocked = { $exists: false }; // intentionally not set, to forward blocks 
+        db_1.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);
+            return this._processReturnedObject(await r.toArray());
+        }, false, { operation: "findNewer", collection, timestamp, query, opts });
+        db_1.log.debug('findNewer returns', ret);
+        return ret;
+    }
+    async findNewerMany(spec = []) {
+        db_1.log.debug('findAfterMany called', spec);
+        let conn = await this.connect();
+        const getOneColl = async (coll) => {
+            let timestamp = coll.timestamp;
+            if (timestamp === 1 || timestamp === "1" || timestamp === "0" || timestamp === 0)
+                timestamp = new Date(0);
+            if (!(timestamp instanceof mongodb_1.Timestamp))
+                timestamp = _1.Base.timestamp(timestamp);
+            let query = {
+                ...(coll.query || {}),
+                _ts: { $gt: timestamp }
+            };
+            let r = conn
+                .db(this.db)
+                .collection(coll.collection)
+                .find(query)
+                .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);
+            let data = await r.toArray();
+            return { collection: coll.collection, data };
+        };
+        let promises = [];
+        for (let coll of spec)
+            promises.push(getOneColl(coll));
+        let out = {};
+        (await Promise.all(promises)).forEach(r => out[r.collection] = r.data);
+        return out;
+    }
+    async findAfter(collection, csq, query = {}, opts = {}) {
+        query._csq = { $gt: csq };
+        db_1.log.debug('findAfter called', collection, csq, 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);
+            return this._processReturnedObject(await r.toArray());
+        }, false, { operation: "findNewer", collection, csq, query, opts });
+        db_1.log.debug('findNewer returns', ret);
+        return ret;
+    }
+    async findAfterMany(spec = []) {
+        db_1.log.debug('findAfterMany called', spec);
+        let conn = await this.connect();
+        const getOneColl = async (coll) => {
+            let r = conn
+                .db(this.db)
+                .collection(coll.collection)
+                .find({
+                _csq: { $gt: coll.csq, ...(coll.query || {}) }
+            })
+                .sort({ _csq: 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);
+            let data = await r.toArray();
+            return { collection: coll.collection, data };
+        };
+        let promises = [];
+        for (let coll of spec)
+            promises.push(getOneColl(coll));
+        let out = {};
+        (await Promise.all(promises)).forEach(r => out[r.collection] = r.data);
+        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 ret = await Mongo.prototype.findNewer.call(this, collection, ts, query, opts); // prevent calling Repo.findNewer
+        db_1.log.debug('findNewerFromDate returns', ret);
+        return ret;
+    }
+    async findOne(collection, query, projection) {
+        (0, assert_1.default)(collection);
+        (0, assert_1.default)(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) => conn.findOne(query, { projection, session: this.session }), false, { operation: "findOne", collection, query, projection });
+        db_1.log.debug('findOne returns', ret);
+        return this._processReturnedObject(ret);
+    }
+    async findById(collection, id, projection) {
+        (0, assert_1.default)(collection);
+        (0, assert_1.default)(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);
+        let ret = await this.executeTransactionally(collection, async (conn) => conn.findOne(query, { projection, session: this.session }), false, { operation: "findById", collection, id, projection });
+        if (ret._deleted)
+            ret = null;
+        db_1.log.debug('findById returns', ret);
+        return this._processReturnedObject(await ret);
+    }
+    async updateOne(collection, query, update, options = { returnFullObject: false }) {
+        (0, assert_1.default)(collection);
+        (0, assert_1.default)(query);
+        (0, assert_1.default)(update);
+        query = this.replaceIds(query);
+        update = this.replaceIds(update);
+        let opts = {
+            upsert: false,
+            returnNewDocument: true,
+            returnOriginal: false,
+            session: this.session,
+        };
+        update = await this._processUpdateObject(update);
+        db_1.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 || {};
+            if (seqKeys)
+                await this._processSequenceField(client, 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.value)
+                return null;
+            let resObj = this._removeUnchanged(res.value, update, !!(options === null || options === void 0 ? void 0 : 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);
+        return this._processReturnedObject(await obj);
+    }
+    async save(collection, update, id = undefined, options = { returnFullObject: false }) {
+        (0, assert_1.default)(collection);
+        (0, assert_1.default)(update);
+        update = this.replaceIds(update);
+        let opts = {
+            upsert: true,
+            returnNewDocument: true,
+            returnOriginal: false,
+            session: this.session,
+        };
+        let _id = Mongo.toId(id || update._id) || Mongo.newid();
+        update = await this._processUpdateObject(update);
+        db_1.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 || {};
+            if (seqKeys)
+                await this._processSequenceField(client, 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.value)
+                return null;
+            let resObj = this._removeUnchanged(res.value, update, !!(options === null || options === void 0 ? void 0 : 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);
+        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);
+        if (this.syncSupport)
+            db_1.log.warn("update does not increase _csq, avoit it.");
+        if (!Object.keys(update).length)
+            return { n: 0, ok: false };
+        query = this.replaceIds(query);
+        update = this.replaceIds(update);
+        let opts = {
+            upsert: false,
+            returnNewDocument: true,
+            returnOriginal: false,
+            multi: true,
+            session: this.session,
+        };
+        update = await this._processUpdateObject(update);
+        db_1.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 || {};
+            if (seqKeys)
+                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);
+            let res = await conn.updateMany(query, update, opts);
+            let resObj = {
+                n: res.result.n,
+                ok: !!res.result.ok,
+            };
+            await this._publishAndAudit('updateMany', this.db, collection, resObj);
+            return resObj;
+        }, !!seqKeys, { operation: "update", collection, query, update });
+        db_1.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');
+        // if (!Object.keys(update).length) return null;
+        query = this.replaceIds(query);
+        update = this.replaceIds(update);
+        let opts = {
+            ...options,
+            upsert: true,
+            returnNewDocument: true,
+            returnOriginal: false,
+            session: this.session,
+        };
+        db_1.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);
+        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);
+            if (update.$set === undefined || Object.keys(update.$set).length === 0)
+                delete update.$set;
+            let ret = await conn.findOneAndUpdate(query, update, opts);
+            if ((_a = ret === null || ret === void 0 ? void 0 : ret.value) === null || _a === void 0 ? void 0 : _a._id) {
+                let oper = ret.lastErrorObject.updatedExisting ? "update" : "insert";
+                let retObj = oper === "insert" ? ret.value : this._removeUnchanged(ret.value, update, !!(options === null || options === void 0 ? void 0 : 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);
+        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);
+        insert = this.replaceIds(insert);
+        if (this.revisions) {
+            insert._rev = 1;
+            insert._ts = _1.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 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);
+        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);
+        batch = this.replaceIds(batch);
+        for (let i = 0; i < batch.length; i++)
+            await this._processHashedKeys(batch[i].update);
+        let ret = await this.executeTransactionally(collection, async (conn, client) => {
+            var _a;
+            await this._processSequenceFieldForMany(client, collection, batch.map(b => b.update));
+            let publications = [];
+            let changes = [];
+            for await (let part of batch) {
+                let { query, update, opts } = part;
+                let options = {
+                    ...(opts || {}),
+                    upsert: true,
+                    returnNewDocument: true,
+                    returnOriginal: false,
+                    session: this.session,
+                };
+                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 = ret.lastErrorObject.updatedExisting ? "update" : "insert";
+                    let retObj = oper === "insert" ? ret.value : this._removeUnchanged(ret.value, update, !!(opts === null || opts === void 0 ? void 0 : opts.returnFullObject));
+                    publications.push(await this._publishAndAudit(oper, this.db, collection, retObj, true));
+                    changes.push(retObj);
+                }
+                ;
+            }
+            if (this.emittingPublishEvents || this.auditing) {
+                await this.emit({
+                    channel: `db/${this.db}/${collection}`,
+                    payload: {
+                        operation: "batch",
+                        db: this.db,
+                        collection,
+                        data: publications.map(p => p === null || p === void 0 ? void 0 : p.payload).filter(p => !!p)
+                    }
+                });
+            }
+            return changes;
+        }, false, { operation: "upsertBatch", collection, batch });
+        db_1.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);
+        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(); });
+        let ret = await this.executeTransactionally(collection, async (conn, client) => {
+            await this._processSequenceFieldForMany(client, collection, insert);
+            let obj = await conn.insertMany(insert, { session: this.session });
+            if (this.emittingPublishEvents || this.auditing) {
+                for await (let rec of obj.ops) {
+                    await this._publishAndAudit('insert', this.db, collection, rec);
+                }
+            }
+            return obj.ops;
+        }, false, { operation: "insertMany", collection, insert });
+        db_1.log.debug('insertMany returns', ret);
+        return ret;
+    }
+    async deleteOne(collection, query) {
+        (0, assert_1.default)(collection);
+        (0, assert_1.default)(query);
+        query = this.replaceIds(query);
+        if (!this.softdelete) {
+            let opts = {
+                returnNewDocument: true,
+                returnOriginal: false,
+                session: this.session,
+            };
+            db_1.log.debug('deleteOne called', collection, query);
+            let ret = await this.executeTransactionally(collection, async (conn) => {
+                let obj = await conn.findOneAndDelete(query, opts);
+                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);
+            return ret;
+        }
+        else {
+            let opts = {
+                upsert: true,
+                returnNewDocument: true,
+                returnOriginal: false,
+                session: this.session,
+            };
+            db_1.log.debug('deleteOne called', collection, query);
+            let ret = await this.executeTransactionally(collection, async (conn, client) => {
+                let del = {
+                    $set: { _deleted: new Date() },
+                    $inc: { _rev: 1, },
+                    $currentDate: { _ts: { $type: 'timestamp' } }
+                };
+                if (this.syncSupport)
+                    del.$set._csq = await this._getNextCollectionUpdateSeqNo(collection, client);
+                let obj = await conn.findOneAndUpdate(query, del, opts);
+                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);
+            return ret;
+        }
+    }
+    async blockOne(collection, query) {
+        let opts = {
+            upsert: false,
+            returnNewDocument: true,
+            returnOriginal: false,
+            session: this.session,
+        };
+        query = this.replaceIds(query);
+        db_1.log.debug('blockOne called', collection, query);
+        let ret = await this.executeTransactionally(collection, async (conn, client) => {
+            query._blocked = { $exists: 0 };
+            let update = {
+                $set: { _blocked: new Date(), },
+                $inc: { _rev: 1, },
+                $currentDate: { _ts: { $type: 'timestamp' } }
+            };
+            if (this.syncSupport)
+                update.$set._csq = await this._getNextCollectionUpdateSeqNo(collection, client);
+            let obj = await conn.findOneAndUpdate(query, update, opts);
+            if (!obj.value || !obj.value._id)
+                return {
+                    ok: false
+                };
+            let retObj = {
+                _id: obj.value._id,
+                _blocked: obj.value._blocked,
+            };
+            await this._publishAndAudit('block', this.db, collection, retObj);
+            return retObj;
+        }, false, { operation: "blockOne", collection, query });
+        db_1.log.debug('blockOne returns', ret);
+        return ret;
+    }
+    async unblockOne(collection, query) {
+        let opts = {
+            upsert: false,
+            returnNewDocument: true,
+            returnOriginal: false,
+            session: this.session,
+        };
+        query = this.replaceIds(query);
+        db_1.log.debug('unblockOne called', collection, query);
+        let ret = await this.executeTransactionally(collection, async (conn, client) => {
+            query._blocked = { $exists: 1 };
+            let update = {
+                $unset: { _blocked: 1 },
+                $inc: { _rev: 1, },
+                $currentDate: { _ts: { $type: 'timestamp' } }
+            };
+            if (this.syncSupport)
+                update.$set = { _csq: await this._getNextCollectionUpdateSeqNo(collection, client) };
+            let obj = await conn.findOneAndUpdate(query, update, opts);
+            if (!obj.value || !obj.value._id)
+                return {
+                    ok: false
+                };
+            let retObj = {
+                _id: obj.value._id,
+            };
+            await this._publishAndAudit('unblock', this.db, collection, retObj);
+            return retObj;
+        }, false, { operation: "unblockOne", collection, query });
+        db_1.log.debug('unblockOne returns', ret);
+        return ret;
+    }
+    async hardDeleteOne(collection, query) {
+        (0, assert_1.default)(collection);
+        (0, assert_1.default)(query);
+        query = this.replaceIds(query);
+        let opts = {
+            returnNewDocument: true,
+            returnOriginal: false,
+            session: this.session,
+        };
+        db_1.log.debug('hardDeleteOne 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: "hardDeleteOne", collection, query });
+        db_1.log.debug('hardDeleteOne returns', ret);
+        return ret;
+    }
+    async delete(collection, query) {
+        (0, assert_1.default)(collection);
+        (0, assert_1.default)(query);
+        if (this.syncSupport)
+            db_1.log.warn("delete does not increase _csq, avoit it.");
+        query = this.replaceIds(query);
+        if (!this.softdelete) {
+            let opts = {
+                returnNewDocument: true,
+                returnOriginal: false,
+                session: this.session,
+            };
+            db_1.log.debug('delete called', collection, query);
+            let ret = await this.executeTransactionally(collection, async (conn) => {
+                let obj = await conn.deleteMany(query, opts);
+                let resObj = {
+                    n: obj.result.n,
+                    ok: !!obj.result.ok,
+                };
+                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);
+            return ret;
+        }
+        else {
+            let opts = {
+                upsert: false,
+                returnNewDocument: true,
+                returnOriginal: false,
+                multi: true,
+                session: this.session,
+            };
+            let date = new Date();
+            db_1.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 = {
+                    n: obj.result.n,
+                    ok: obj.result.ok,
+                };
+                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);
+            return ret;
+        }
+    }
+    async hardDelete(collection, query) {
+        (0, assert_1.default)(collection);
+        (0, assert_1.default)(query);
+        if (this.syncSupport)
+            db_1.log.warn("hardDelete does not increase _csq, avoit it.");
+        query = this.replaceIds(query);
+        let opts = {
+            returnNewDocument: true,
+            returnOriginal: false,
+            session: this.session,
+        };
+        db_1.log.debug('hardDelete called', collection, query);
+        let ret = await this.executeTransactionally(collection, async (conn) => {
+            let obj = await conn.deleteMany(query, opts);
+            let resObj = {
+                n: obj.result.n,
+                ok: obj.result.ok,
+            };
+            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);
+        return ret;
+    }
+    async testHash(collection, query, field, unhashedValue) {
+        let _field;
+        db_1.log.debug('teshHash called', collection, query, field, unhashedValue);
+        if (typeof field === "object") {
+            if (Object.keys(field).length === 1)
+                [_field, unhashedValue] = Object.entries(field)[0];
+            else
+                throw new Error("if field is an object, it must have exactly one key");
+        }
+        else
+            _field = field;
+        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 });
+        if (!obj || !obj[_field]) {
+            db_1.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);
+        return res;
+    }
+    async aggregate(collection, pipeline, opts = {
+        readPreference: mongodb_1.ReadPreference.SECONDARY_PREFERRED,
+    }) {
+        (0, assert_1.default)(collection);
+        (0, assert_1.default)(pipeline instanceof Array);
+        db_1.log.debug('aggregate called', collection, pipeline);
+        pipeline = this.replaceIds(pipeline);
+        if (this.session)
+            opts.session = this.session;
+        let ret = await this.executeTransactionally(collection, async (conn) => {
+            let agg = await conn.aggregate(pipeline, opts);
+            let res = await agg.toArray();
+            return res;
+        }, false, { operation: "aggregate", collection, pipeline, opts });
+        db_1.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();
+        let matches = await this.executeTransactionally(collection, async (conn) => {
+            let agg = await conn.find({ [field]: value });
+            let res = await agg.toArray();
+            return res;
+        }, false, { operation: "isUnique", collection, field, value, id });
+        let ret = true;
+        for (let match of matches || []) {
+            if (match._id.toString() != _id) {
+                ret = false;
+                return false;
+            }
+        }
+        db_1.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);
+        let pipeline = [
+            { $group: { _id: '$' + field } },
+            { $sort: { _id: 1 } }
+        ];
+        if (inArray)
+            pipeline = [
+                { $unwind: '$' + field },
+                ...pipeline
+            ];
+        let res = await this.executeTransactionally(collection, async (conn) => {
+            let agg = await conn.aggregate(pipeline, opts);
+            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);
+        return ret;
+    }
+    async dropCollection(collection) {
+        (0, assert_1.default)(collection);
+        db_1.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');
+    }
+    async resetCollectionSync(collection) {
+        (0, assert_1.default)(collection);
+        db_1.log.debug('resetCollectionSync called for', collection);
+        let client = await this.connect();
+        await client.db(this.db)
+            .collection(types_1.SEQUENCES_COLLECTION)
+            .findOneAndDelete({ collection });
+        db_1.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);
+        let client = await this.connect();
+        let existing = await client.db(this.db).collections();
+        for await (let collection of collections) {
+            if (existing.map((c) => c.s.name).includes(collection)) {
+                await client.db(this.db).dropCollection(collection);
+            }
+        }
+        db_1.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);
+        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);
+            }
+        }
+        db_1.log.debug('createCollections returns');
+    }
+    async createCollection(collection) {
+        (0, assert_1.default)(collection);
+        db_1.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');
+    }
+    async dbLogPurge(collection, _id) {
+        (0, assert_1.default)(collection);
+        db_1.log.debug('dblogPurge called', collection, _id);
+        let ret = await this.executeTransactionally(collection, async () => {
+            let cond = { db: this.db, collection, };
+            if (_id !== undefined)
+                cond._id = Mongo._toId(_id);
+            let client = await this.connect();
+            let ret = await client
+                .db(this.db)
+                .collection(this.auditCollectionName)
+                .deleteMany(cond, { session: this.session });
+            return {
+                ok: true,
+                n: ret.result.n
+            };
+        }, false, { operation: "dbLogPurge", collection, _id });
+        db_1.log.debug('dblogPurge returns', ret);
+        return ret;
+    }
+    async dbLogGet(collection, _id) {
+        (0, assert_1.default)(collection);
+        db_1.log.debug('dblogGet called', collection, _id);
+        let ret = await this.executeTransactionally(collection, async () => {
+            let cond = { db: this.db, collection };
+            if (_id)
+                cond.entityid = Mongo._toId(_id);
+            let client = await this.connect();
+            let ret = await client
+                .db(this.db)
+                .collection(this.auditCollectionName)
+                .find(cond, { session: this.session })
+                .sort({ _id: -1 })
+                .toArray();
+            return ret;
+        }, false, { operation: "dbLogGet", collection, _id });
+        db_1.log.debug('dblogGet returns', ret);
+        return ret;
+    }
+    // HELPER FUNCTIONS
+    replaceIds(data) {
+        try {
+            if (!data)
+                return data;
+            if (typeof data === "number")
+                return data;
+            if (typeof data === "boolean")
+                return data;
+            if (typeof data === "bigint")
+                return data;
+            if (typeof data === "function")
+                return undefined;
+            if (typeof data === "symbol")
+                return data.toString();
+            if (data instanceof mongodb_1.ObjectId)
+                return data;
+            if (data instanceof mongodb_1.Timestamp)
+                return data;
+            if (data instanceof Date)
+                return data;
+            if (data instanceof RegExp)
+                return data;
+            if (data instanceof Number)
+                return data;
+            if (data instanceof String)
+                return data;
+            if (typeof data === "string" && data.match(/^[0-9a-f]{24,24}$/g))
+                return new mongodb_1.ObjectId(data);
+            if (typeof data === "string")
+                return data;
+            if (data instanceof Array) {
+                return data.map(d => this.replaceIds(d));
+            }
+            else if (typeof data == 'object') {
+                for (let key in data) {
+                    data[key] = this.replaceIds(data[key]);
+                }
+                return data;
+            }
+            throw new Error(`ObjectId test failed for ${data}`);
+        }
+        catch (err) {
+            console.error('error in replaceIds', err, data);
+            throw err;
+        }
+    }
+    async connect() {
+        super.connect();
+        // this.session = undefined;
+        return this.client;
+    }
+    async close() {
+        if (this.session)
+            try {
+                await this.session.endSession();
+                db_1.log.info("session ended");
+            }
+            catch (err) {
+                db_1.log.error(`Error ending session ${err.message}`);
+            }
+        try {
+            await super.close();
+            db_1.log.info("connection closed");
+        }
+        catch ( /** intentionally */_a) { /** intentionally */ }
+        this.session = undefined;
+    }
+    async inTransaction() {
+        if (!await this.isOnReplicaSet())
+            return false;
+        if (!this.session)
+            return false;
+        return this.session.inTransaction();
+    }
+    async withTransaction(funct) {
+        if (!await this.isOnReplicaSet())
+            return await funct(await this.connect(), null);
+        try {
+            let client = await this.connect();
+            let hadSession = !!this.session;
+            if (!this.session) {
+                this.session = client.startSession();
+                db_1.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");
+                this.session = undefined;
+            }
+            return;
+        }
+        catch (err) {
+            throw err;
+        }
+    }
+    async startTransaction() {
+        if (!await this.isOnReplicaSet())
+            return;
+        let client = await this.connect();
+        try {
+            if (!this.session) {
+                this.session = client.startSession(TRANSACTION_OPTIONS);
+                db_1.log.info("session started");
+            }
+            if (!await this.inTransaction()) {
+                await this.session.startTransaction();
+                db_1.log.info("transaction started");
+            }
+        }
+        catch (err) {
+            db_1.log.error('startTransaction error', err);
+            try {
+                if (this.session) {
+                    await this.session.endSession();
+                    db_1.log.info("session ended");
+                }
+                this.session = undefined;
+            }
+            catch (e) {
+                db_1.log.error("startTransaction - error in endSession", e.message || e);
+            }
+            return;
+        }
+    }
+    async commitTransaction() {
+        if (!await this.isOnReplicaSet())
+            return;
+        try {
+            if (!await this.inTransaction())
+                return;
+            let session = this.session;
+            await session.commitTransaction();
+            db_1.log.info("transaction committed");
+            session.endSession();
+            this.session = undefined;
+            db_1.log.info("session ended");
+        }
+        catch (err) {
+            db_1.log.error(`commitTransaction error ${err.message || err}`);
+        }
+    }
+    async abortTransaction() {
+        if (!await this.isOnReplicaSet())
+            return;
+        try {
+            if (!await this.inTransaction())
+                return;
+            let session = this.session;
+            await session.abortTransaction();
+            db_1.log.info("transaction aborted");
+            await session.endSession();
+            this.session = undefined;
+            db_1.log.info("session ended");
+        }
+        catch (err) {
+            db_1.log.error(`abortTransaction error ${err.message || err}`);
+        }
+    }
+    async _try_once(useTransaction, f, collection) {
+        try {
+            let conn = await this.connect();
+            if (useTransaction)
+                await this.startTransaction();
+            let ret = await f(await conn.db(this.db).collection(collection), conn);
+            if (useTransaction)
+                await this.commitTransaction();
+            return ret;
+        }
+        catch (err) {
+            try {
+                if (useTransaction)
+                    await this.abortTransaction();
+            }
+            catch ( /* intentionally */_a) { /* intentionally */ }
+            throw err;
+        }
+    }
+    async executeTransactionally(collection, f, useTransaction = false, debugObject) {
+        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);
+        }
+        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);
+            let x = (err || "").toString();
+            let isRepeatable = x.match(/Topology is closed, please connect/i)
+                || x.match(/connection timed out/)
+                || x.match(/not master/)
+                || x.match(/Topology closed/);
+            if (isRepeatable) {
+                try {
+                    db_1.log.error("Trying to reopen connection and repeat commands");
+                    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("");
+                    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("");
+                }
+            }
+            throw err;
+        }
+    }
+    async _findLastSequenceForKey(connection, key) {
+        let maxfld = await (connection
+            .find({}, { session: this.session })
+            .sort({ [key]: -1 })
+            .limit(1)
+            .toArray());
+        if (maxfld.length === 0)
+            return undefined;
+        return parseInt(maxfld[0][key]) || 0;
+    }
+    async _getNextCollectionUpdateSeqNo(collection, conn) {
+        var _a;
+        let opts = {
+            upsert: true,
+            returnNewDocument: true,
+            returnOriginal: false
+        };
+        let nextSeq = await (conn.db(this.db)
+            .collection(types_1.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;
+    }
+    _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;
+    }
+    async _processSequenceField(client, collection, insert, seqKeys) {
+        (0, assert_1.default)(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);
+            if (last === undefined) {
+                await this.createCollection(collection);
+                last = 0;
+            }
+            let next = insert[seqKey] === 'SEQ_LAST' ? last : last + 1;
+            insert[seqKey] = next;
+        }
+        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))
+            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) || []) {
+            let last = await this._findLastSequenceForKey(connection.db(this.db).collection(collection), seqKey);
+            if (last === undefined) {
+                try {
+                    await this.createCollection(collection);
+                }
+                catch ( /* intentionaly */_a) { /* intentionaly */ }
+                last = 0;
+            }
+            for (let insert of inserts) {
+                let next = insert[seqKey] === 'SEQ_LAST' ? last : last + 1;
+                last = insert[seqKey] = next;
+                if (this.syncSupport)
+                    insert._csq = (seq++);
+            }
+        }
+        return inserts;
+    }
+    _getFieldsRecursively(obj, into = []) {
+        for (let key in obj) {
+            let startsWith$ = /^\$/.test(key);
+            if (startsWith$ && typeof obj[key] === "object" && !Array.isArray(obj[key]))
+                this._getFieldsRecursively(obj[key], into);
+            else if (!startsWith$ && typeof obj[key] === "object" && !Array.isArray(obj[key]))
+                into.push(key);
+            else if (!startsWith$)
+                into.push(key);
+        }
+        return into;
+    }
+    _removeUnchanged(wholerecord, diff, returnFullObject) {
+        if (returnFullObject)
+            return wholerecord;
+        let a = {};
+        wholerecord = wholerecord || {};
+        this._getFieldsRecursively(diff).forEach(k => a[k] = wholerecord[k]);
+        if (wholerecord._rev)
+            a._rev = wholerecord._rev;
+        if (wholerecord._ts)
+            a._ts = wholerecord._ts;
+        if (wholerecord._id)
+            a._id = wholerecord._id;
+        return a;
+    }
+    _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;
+    }
+    async _publishAndAudit(operation, db, collection, data, noEmit) {
+        let toPublish = undefined;
+        if (this.emittingPublishEvents && data) {
+            toPublish = this._makePublication(db, collection, data, operation);
+            if (!noEmit)
+                this.emit(toPublish);
+        }
+        if (this._shouldAuditCollection(this.db, collection)) {
+            if (['insert', 'update', 'delete', 'block', 'unblock'].includes(operation))
+                await this._writeAuditRecord(collection, operation, data);
+        }
+        return toPublish;
+    }
+    _makePublication(db, collection, data, operation) {
+        let toPublish = {
+            channel: `db/${db}/${collection}${data._id ? "/" + data._id.toString() : ""}`,
+            payload: {
+                db,
+                collection,
+                operation,
+                data,
+            }
+        };
+        if (data && data._auth)
+            toPublish.user = data._auth.username;
+        return toPublish;
+    }
+    emit(what) {
+        db_1.log.debug("emitting publish", what);
+        this.emitter.emit('publish', what);
+    }
+    async _writeAuditRecord(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([
+            { $match: { entityid: Mongo._toId(data._id) } },
+            { $sort: { rev: -1 } },
+            { $limit: 1 }
+        ], { session: this.session })).toArray();
+        let previousAuditRecord = previousAuditRecords.length ? previousAuditRecords[0] : { rev: 0, changes: {} };
+        if (previousAuditRecords.length === 0)
+            await this.createCollection(this.auditCollectionName);
+        let dataNoId = { ...data };
+        delete dataNoId._id;
+        let auditRecord = {
+            db: this.db,
+            collection: collection,
+            entityid: _1.Base.objectid(data._id),
+            rev: previousAuditRecord.rev + 1,
+            ts: _1.Base.timestamp(),
+            on: new Date(),
+            operation: operation,
+            changes: dataNoId,
+        };
+        if (user)
+            auditRecord.user = user;
+        if (audit)
+            auditRecord.audit = audit;
+        db_1.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.result.n);
+    }
+    async _processUpdateObject(update) {
+        await this._processHashedKeys(update);
+        for (let k in update) {
+            let key = k;
+            if (key.toString()[0] === "$")
+                continue;
+            if (key === '' || key === null || key === undefined) {
+                delete update[key];
+                continue;
+            }
+            if (update[key] === undefined) {
+                update.$unset = update.$unset || {};
+                update.$unset[key] = true;
+                delete update[key];
+            }
+            else {
+                update.$set = update.$set || {};
+                update.$set[key] = update[key];
+                delete update[key];
+            }
+        }
+        if (this.revisions) {
+            update.$inc = update.$inc || {};
+            update.$inc._rev = 1;
+            update.$currentDate = { _ts: { $type: 'timestamp' } };
+        }
+        if (update.$set) {
+            delete update.$set._ts;
+            delete update.$set._rev;
+            delete update.$set._id;
+        }
+        return update;
+    }
+    async _processHashedKeys(update) {
+        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);
+                update[key] = { salt, hash };
+            }
+        }
+    }
+    _processReturnedObject(ret) {
+        if (ret instanceof Array) {
+            for (let i = 0; i < ret.length; i++) {
+                this._processReturnedObject(ret[i]);
+            }
+        }
+        else {
+            for (let key in ret) {
+                if (/^__/.test(key))
+                    delete ret[key];
+            }
+        }
+        return ret;
+    }
+}
+exports.default = Mongo;
+module.exports = Mongo;
+//# sourceMappingURL=mongo.js.map