cry-db 2.4.11 → 2.4.13

package/dist/mongo.mjs

@@ -1,4 +1,5 @@
 import * as bcrypt from 'bcrypt';
+import { Formatter, FracturedJsonOptions } from 'fracturedjsonjs';
 import cloneDeep from "lodash.clonedeep";
 import { ObjectId, ReadConcern, ReadPreference, Timestamp, WriteConcern } from 'mongodb';
 import { TypedEmitter } from "tiny-typed-emitter";
@@ -35,6 +36,34 @@ const TRANSACTION_OPTIONS = {
         writeConcern: new WriteConcern("majority")
     }
 };
+// FracturedJson formatter for readable object logging
+const fjOptions = new FracturedJsonOptions();
+fjOptions.MaxTotalLineLength = 120;
+fjOptions.MaxInlineComplexity = 2;
+const fjFormatter = new Formatter();
+fjFormatter.Options = fjOptions;
+const fj = (obj) => {
+    var _a;
+    if (obj === null || obj === undefined)
+        return String(obj);
+    if (typeof obj !== 'object')
+        return String(obj);
+    try {
+        return (_a = fjFormatter.Serialize(obj)) !== null && _a !== void 0 ? _a : JSON.stringify(obj);
+    }
+    catch {
+        return JSON.stringify(obj);
+    }
+};
+// Wrap log methods to auto-format objects with fracturedjson
+const fjArgs = (args) => args.map(a => typeof a === 'object' && a !== null ? fj(a) : a);
+const fjLog = {
+    debug: (...args) => { log.debug(...fjArgs(args)); },
+    trace: (...args) => { log.trace(...fjArgs(args)); },
+    info: (...args) => { log.info(...fjArgs(args)); },
+    warn: (...args) => { log.warn(...fjArgs(args)); },
+    error: (...args) => { log.error(...fjArgs(args)); },
+};
 // export const DummyExportToFixTsCompilation = true;
 export class Mongo extends Db {
     constructor(db, url) {
@@ -51,18 +80,18 @@ export class Mongo extends Db {
         this.emitter = new TypedEmitter();
         this.user = undefined;
         this.audit = undefined;
-        log.debug('new Mongo:', this.url, this.db);
+        fjLog.debug('new Mongo:', this.url, this.db);
     }
     on(evt, listener) {
-        log.debug("on", evt, listener);
+        fjLog.debug("on", evt, listener);
         this.emitter.on(evt, listener);
     }
     off(evt, listener) {
-        log.debug("off", evt, listener);
+        fjLog.debug("off", evt, listener);
         this.emitter.off(evt, listener);
     }
     once(evt, listener) {
-        log.debug("once", evt, listener);
+        fjLog.debug("once", evt, listener);
         this.emitter.once(evt, listener);
     }
     setUser(username) {
@@ -137,18 +166,18 @@ export class Mongo extends Db {
             this.revisions = true;
         }
         if (enabled)
-            log.debug("publishing rev events");
+            fjLog.debug("publishing rev events");
         return this.emittingPublishRevEvents = enabled;
     }
     emitsPublishRevEvents() {
         return this.emittingPublishRevEvents;
     }
     async distinct(collection, field) {
-        log.debug('distinct called', collection, field);
+        fjLog.debug('distinct called', collection, field);
         let ret = await this.executeTransactionally(collection, async (conn) => {
             return await conn.distinct(field);
         }, false, { operation: "distinct", collection, field });
-        log.debug('distinct returns', ret);
+        fjLog.debug('distinct returns', ret);
         return ret;
     }
     async count(collection, query = {}, opts = {}) {
@@ -157,11 +186,11 @@ export class Mongo extends Db {
             if (!query._deleted)
                 query._deleted = { $exists: false };
         }
-        log.debug('count called', collection, query, opts);
+        fjLog.debug('count called', collection, query, opts);
         let ret = await this.executeTransactionally(collection, async (conn) => {
             return await conn.countDocuments(query, opts);
         }, false, { operation: "count", collection, query, opts });
-        log.debug('count returns', ret);
+        fjLog.debug('count returns', ret);
         return ret;
     }
     async find(collection, query = {}, opts = {}) {
@@ -171,12 +200,12 @@ export class Mongo extends Db {
             if (!query._deleted)
                 query._deleted = { $exists: false };
         }
-        log.debug('find called', collection, query, opts);
+        fjLog.debug('find called', collection, query, opts);
         let ret = await this.executeTransactionally(collection, async (conn) => {
             let r = this._applyQueryOpts(conn.find(query, this._buildFindOptions(opts)), opts);
             return this._processReturnedObject(await r.toArray());
         }, false, { operation: "find", collection, query, opts });
-        log.debug('find returns', ret);
+        fjLog.debug('find returns', ret);
         return ret;
     }
     async findAll(collection, query = {}, opts = {}) {
@@ -186,7 +215,7 @@ export class Mongo extends Db {
             let r = this._applyQueryOpts(conn.find(query, this._buildFindOptions(opts)), opts);
             return this._processReturnedObject(await r.toArray());
         }, false, { operation: "findAll", collection, query, opts });
-        log.debug('findAll returns', ret);
+        fjLog.debug('findAll returns', ret);
         return ret;
     }
     async findNewer(collection, timestamp, query = {}, opts = {}) {
@@ -195,17 +224,17 @@ export class Mongo extends Db {
             if (!query._deleted)
                 query._deleted = { $exists: false };
         }
-        log.debug('findNewer called', collection, timestamp, query, opts);
+        fjLog.debug('findNewer called', collection, timestamp, query, opts);
         let ret = await this.executeTransactionally(collection, async (conn) => {
             let r = this._applyQueryOpts(conn.find(query, this._buildFindOptions(opts)).sort({ _ts: 1 }), opts);
             return this._processReturnedObject(await r.toArray());
         }, false, { operation: "findNewer", collection, timestamp, query, opts });
-        log.debug('findNewer returns', ret);
+        fjLog.debug('findNewer returns', ret);
         return ret;
     }
     async findNewerMany(spec = []) {
         var _a;
-        log.debug('findNewerMany called', spec);
+        fjLog.debug('findNewerMany called', spec);
         const dbName = this.db; // Capture db at operation start
         let conn = await this.connect();
         const getOneColl = async (coll) => {
@@ -216,12 +245,12 @@ export class Mongo extends Db {
                     query._deleted = { $exists: false };
             }
             if (process.env.MONGO_DEBUG_FINDNEWERMANY) {
-                log.debug("findNewerMany <-", coll.collection, coll.timestamp, coll.query, " -> ", JSON.stringify(query));
+                fjLog.debug("findNewerMany <-", coll.collection, coll.timestamp, coll.query, " -> ", JSON.stringify(query));
             }
             let r = this._applyQueryOpts(conn.db(dbName).collection(coll.collection).find(query, {}).sort({ _ts: 1 }), opts);
             let data = await r.toArray();
             if (process.env.MONGO_DEBUG_FINDNEWERMANY) {
-                log.debug("findNewerMany ->", coll.collection, JSON.stringify(data, null, 2));
+                fjLog.debug("findNewerMany ->", coll.collection, JSON.stringify(data, null, 2));
             }
             return { collection: coll.collection, data };
         };
@@ -246,7 +275,7 @@ export class Mongo extends Db {
     async latestTimestamps(collections) {
         assert(collections);
         assert(collections instanceof Array);
-        log.debug('latestTimestamps called', collections);
+        fjLog.debug('latestTimestamps called', collections);
         const dbName = this.db; // Capture db at operation start
         let conn = await this.connect();
         const getOne = async (collection) => {
@@ -268,13 +297,13 @@ export class Mongo extends Db {
         let out = {};
         (await Promise.all(promises)).forEach(r => { if (r.ts)
             out[r.collection] = r.ts; });
-        log.debug('latestTimestamps returns', out);
+        fjLog.debug('latestTimestamps returns', out);
         return out;
     }
     async latestTimestamp(collection) {
         var _a;
         assert(collection);
-        log.debug('latestTimestamp called', collection);
+        fjLog.debug('latestTimestamp called', collection);
         const dbName = this.db; // Capture db at operation start
         let conn = await this.connect();
         let cursor = conn
@@ -286,7 +315,7 @@ export class Mongo extends Db {
             .limit(1);
         let res = await cursor.toArray();
         let ts = (_a = res === null || res === void 0 ? void 0 : res[0]) === null || _a === void 0 ? void 0 : _a._ts;
-        log.debug('latestTimestamp returns', ts);
+        fjLog.debug('latestTimestamp returns', ts);
         return ts;
     }
     _createQueryForNewer(timestamp, query) {
@@ -304,7 +333,7 @@ export class Mongo extends Db {
     }
     // async findAfter<T>(collection: string, csq: number, query: QuerySpec<T> = {}, opts: QueryOpts = {}): Promise<T[]> {
     //     // query._csq = { $gt: csq };
-    //     log.debug('findAfter called', collection, csq, query, opts)
+    //     fjLog.debug('findAfter called', collection, csq, query, opts)
     //     let ret = await this.executeTransactionally(collection, async (conn) => {
     //         let optsIn: FindOptions<any> = {}
     //         if (opts.readPreference) optsIn.readPreference = opts.readPreference;
@@ -319,12 +348,12 @@ export class Mongo extends Db {
     //         if (opts.collation) r = r.collation(opts.collation);
     //         return this._processReturnedObject(await r.toArray());
     //     }, false, { operation: "findNewer", collection, csq, query, opts });
-    //     log.debug('findNewer returns', ret)
+    //     fjLog.debug('findNewer returns', ret)
     //     return ret;
     // }
     // async findAfterMany<T>(spec: GetAfterSpec<T>[] = []):
     //     Promise<Record<string, any[]>> {
-    //     log.debug('findAfterMany called', spec)
+    //     fjLog.debug('findAfterMany called', spec)
     //     let conn = await this.connect()
     //     const getOneColl = async (coll: GetAfterSpec<T>): Promise<{ collection: string, data: any[] }> => {
     //         let r = conn
@@ -351,9 +380,9 @@ export class Mongo extends Db {
     // }
     // async findNewerFromDate<T>(collection: string, date: Date | string, query: QuerySpec<T> = {}, opts: QueryOpts = {}): Promise<T[]> {
     //     let ts = new Timestamp({ i: new Date(date).valueOf() % 1000, t: new Date(date).valueOf() / 1000 });
-    //     log.debug('findNewerFromDate called', collection, date, query, opts)
+    //     fjLog.debug('findNewerFromDate called', collection, date, query, opts)
     //     let ret = await Mongo.prototype.findNewer.call(this, collection, ts, query, opts)  // prevent calling Repo.findNewer
-    //     log.debug('findNewerFromDate returns', ret)
+    //     fjLog.debug('findNewerFromDate returns', ret)
     //     return ret as T[];
     // }
     async findOne(collection, query, projection, opts = {}) {
@@ -365,9 +394,9 @@ export class Mongo extends Db {
                 query._deleted = { $exists: false };
         }
         // if (!query._blocked) query._blocked = { $exists: false };   // intentionally - blocked records are returned
-        log.debug('findOne called', collection, query, projection);
+        fjLog.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);
+        fjLog.debug('findOne returns', ret);
         return this._processReturnedObject(ret);
     }
     async findById(collection, id, projection, opts = {}) {
@@ -380,15 +409,15 @@ export class Mongo extends Db {
             _id: Mongo._toId(id),
             // _deleted: { $exists: false }
         };
-        log.debug('findById called', dbName, collection, id, projection);
-        log.trace('findById executing with query', collection, query, projection);
+        fjLog.debug('findById called', dbName, collection, id, projection);
+        fjLog.trace('findById executing with query', collection, query, projection);
         let ret = await this.executeTransactionally(collection, async (conn) => {
             let r = await conn.findOne(query, { ...(projection ? { projection } : {}), ...this._sessionOpt() });
             return r;
         }, false, { operation: "findById", collection, id, projection });
         if ((ret === null || ret === void 0 ? void 0 : ret._deleted) && this.softdelete && !opts.returnDeleted)
             ret = null;
-        log.debug('findById returns', ret);
+        fjLog.debug('findById returns', ret);
         return this._processReturnedObject(ret);
     }
     async findByIds(collection, ids, projection, opts = {}) {
@@ -398,7 +427,7 @@ export class Mongo extends Db {
             return [];
         const dbName = this.db;
         const objectIds = ids.map(id => Mongo._toId(id));
-        log.debug('findByIds called', dbName, collection, ids, projection);
+        fjLog.debug('findByIds called', dbName, collection, ids, projection);
         let ret = await this.executeTransactionally(collection, async (conn) => {
             let query = { _id: { $in: objectIds } };
             if (this.softdelete && !opts.returnDeleted) {
@@ -407,7 +436,7 @@ export class Mongo extends Db {
             let r = conn.find(query, { ...(projection ? { projection } : {}), ...this._sessionOpt() });
             return await r.toArray();
         }, false, { operation: "findByIds", collection, ids, projection });
-        log.debug('findByIds returns', ret);
+        fjLog.debug('findByIds returns', ret);
         return this._processReturnedObject(ret);
     }
     async updateOne(collection, query, update, options = { returnFullObject: false }) {
@@ -423,7 +452,7 @@ export class Mongo extends Db {
             ...this._sessionOpt()
         };
         update = await this._processUpdateObject(update);
-        log.debug('updateOne called', collection, query, update);
+        fjLog.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 || {};
@@ -438,7 +467,7 @@ export class Mongo extends Db {
             await this._publishAndAudit('update', dbName, collection, resObj);
             return resObj;
         }, !!seqKeys, { operation: "updateOne", collection, query, update, options });
-        log.debug('updateOne returns', obj);
+        fjLog.debug('updateOne returns', obj);
         return this._processReturnedObject(await obj);
     }
     async save(collection, update, id = undefined, options = { returnFullObject: false }) {
@@ -453,7 +482,7 @@ export class Mongo extends Db {
         };
         let _id = Mongo.toId(id || update._id) || Mongo.newid();
         update = await this._processUpdateObject(update);
-        log.debug('save called', collection, id, update);
+        fjLog.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 || {};
@@ -468,14 +497,14 @@ export class Mongo extends Db {
             await this._publishAndAudit('update', dbName, collection, resObj);
             return resObj;
         }, !!seqKeys, { operation: "save", collection, _id, update, options });
-        log.debug('save returns', obj);
+        fjLog.debug('save returns', obj);
         return this._processReturnedObject(await obj);
     }
     async update(collection, query, update) {
         assert(collection);
         assert(query);
         assert(update);
-        // if (this.syncSupport) log.warn("update does not increase _csq, avoit it.")
+        // if (this.syncSupport) fjLog.warn("update does not increase _csq, avoit it.")
         if (!Object.keys(update).length)
             return { n: 0, ok: false };
         const dbName = this.db; // Capture db at operation start
@@ -487,7 +516,7 @@ export class Mongo extends Db {
             ...this._sessionOpt()
         };
         update = await this._processUpdateObject(update);
-        log.debug('update called', collection, query, update);
+        fjLog.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 || {};
@@ -495,7 +524,7 @@ export class Mongo extends Db {
                 await this._processSequenceField(client, dbName, collection, update.$set, seqKeys);
             if (update.$set === undefined || Object.keys(update.$set).length === 0)
                 delete update.$set;
-            log.debug('update called', collection, query, update);
+            fjLog.debug('update called', collection, query, update);
             let res = await conn.updateMany(query, update, opts);
             let resObj = {
                 n: res.modifiedCount,
@@ -504,7 +533,7 @@ export class Mongo extends Db {
             await this._publishAndAudit('updateMany', dbName, collection, resObj);
             return resObj;
         }, !!seqKeys, { operation: "update", collection, query, update });
-        log.debug('update returns', obj);
+        fjLog.debug('update returns', obj);
         return await obj;
     }
     async upsert(collection, query, update, options = { returnFullObject: false }) {
@@ -522,10 +551,10 @@ export class Mongo extends Db {
             returnDocument: "after",
             ...this._sessionOpt()
         };
-        log.debug('upsert called', collection, query, update);
+        fjLog.debug('upsert called', collection, query, update);
         update = await this._processUpdateObject(update);
         let seqKeys = this._findSequenceKeys(update.$set);
-        log.debug('upsert processed', collection, query, update);
+        fjLog.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) => {
@@ -547,14 +576,14 @@ export class Mongo extends Db {
             ;
             return ret;
         }, !!seqKeys, { operation: "upsert", query, update, options });
-        log.debug('upsert returns', ret);
+        fjLog.debug('upsert returns', ret);
         return this._processReturnedObject(await ret);
     }
     async insert(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);
+        fjLog.debug('insert called', collection, insert);
         const dbName = this.db; // Capture db at operation start
         insert = this.replaceIds(insert);
         if (this.revisions) {
@@ -571,14 +600,174 @@ export class Mongo extends Db {
             await this._publishAndAudit('insert', dbName, collection, fullObj);
             return fullObj;
         }, !!seqKeys, { operation: "insert", collection, insert });
-        log.debug('insert returns', ret);
+        fjLog.debug('insert returns', ret);
         return this._processReturnedObject(await ret);
     }
+    /**
+     * Efficiently updates many collections at once.
+     * Returns ids of object actually updated and deleted and errors for unsucessful updates/deletes.
+     *
+     * if this.emittingPublishRevEvents===true, emits one PublishRevsPayloadBatch per collection
+     *
+     * @param collectionsBatches
+     */
+    async updateCollections(collectionsBatches) {
+        assert(collectionsBatches, "collectionsBatches can't be null");
+        assert(collectionsBatches instanceof Array, "collectionsBatches must be an Array");
+        fjLog.debug('updateCollections called', collectionsBatches.length, 'collections');
+        const dbName = this.db;
+        const conn = await this.connect();
+        const results = [];
+        // Process each collection's batches
+        for (const collectionRequest of collectionsBatches) {
+            // Each collectionRequest is an array of { collection, batch } for the same collection
+            for (const req of collectionRequest) {
+                const { collection, batch } = req;
+                const { updates, deletes } = batch;
+                const result = {
+                    collection,
+                    results: {
+                        updatedIds: [],
+                        deletedIds: [],
+                    }
+                };
+                const batchData = [];
+                const errors = [];
+                // Process updates in parallel
+                if (updates === null || updates === void 0 ? void 0 : updates.length) {
+                    const updatePromises = updates.map(async ({ _id, update }) => {
+                        try {
+                            const objectId = Mongo._toId(_id);
+                            const processedUpdate = await this._processUpdateObject({ ...update });
+                            const opts = {
+                                upsert: false,
+                                returnDocument: "after",
+                                ...this._sessionOpt()
+                            };
+                            const res = await conn
+                                .db(dbName)
+                                .collection(collection)
+                                .findOneAndUpdate({ _id: objectId }, processedUpdate, opts);
+                            if (res) {
+                                const retObj = this._removeUnchanged(res, processedUpdate, false);
+                                this._processReturnedObject(retObj);
+                                return { success: true, _id, data: retObj, operation: 'update' };
+                            }
+                            return { success: false, _id, error: 'Document not found' };
+                        }
+                        catch (err) {
+                            return { success: false, _id, error: err.message || String(err) };
+                        }
+                    });
+                    const updateResults = await Promise.all(updatePromises);
+                    for (const res of updateResults) {
+                        if (res.success && res.data) {
+                            result.results.updatedIds.push(res._id);
+                            batchData.push({ operation: res.operation, data: res.data });
+                        }
+                        else if (!res.success && res.error) {
+                            errors.push({ _id: String(res._id), error: res.error });
+                        }
+                    }
+                }
+                // Process deletes in parallel
+                if (deletes === null || deletes === void 0 ? void 0 : deletes.length) {
+                    const deletePromises = deletes.map(async ({ _id }) => {
+                        try {
+                            const objectId = Mongo._toId(_id);
+                            if (!this.softdelete) {
+                                const res = await conn
+                                    .db(dbName)
+                                    .collection(collection)
+                                    .findOneAndDelete({ _id: objectId }, this._sessionOpt());
+                                if (res) {
+                                    this._processReturnedObject(res);
+                                    return { success: true, _id, data: res, operation: 'delete' };
+                                }
+                                return { success: false, _id, error: 'Document not found' };
+                            }
+                            else {
+                                const del = {
+                                    $set: { _deleted: new Date() },
+                                    $inc: { _rev: 1 },
+                                    $currentDate: { _ts: { $type: 'timestamp' } }
+                                };
+                                const opts = {
+                                    upsert: false,
+                                    returnDocument: "after",
+                                    ...this._sessionOpt()
+                                };
+                                const res = await conn
+                                    .db(dbName)
+                                    .collection(collection)
+                                    .findOneAndUpdate({ _id: objectId }, del, opts);
+                                if (res) {
+                                    this._processReturnedObject(res);
+                                    return { success: true, _id, data: res, operation: 'delete' };
+                                }
+                                return { success: false, _id, error: 'Document not found' };
+                            }
+                        }
+                        catch (err) {
+                            return { success: false, _id, error: err.message || String(err) };
+                        }
+                    });
+                    const deleteResults = await Promise.all(deletePromises);
+                    for (const res of deleteResults) {
+                        if (res.success && res.data) {
+                            result.results.deletedIds.push(res._id);
+                            batchData.push({ operation: res.operation, data: res.data });
+                        }
+                        else if (!res.success && res.error) {
+                            errors.push({ _id: String(res._id), error: res.error });
+                        }
+                    }
+                }
+                // Set errors if any
+                if (errors.length > 0 && errors[0]) {
+                    result.results.errors = errors[0];
+                }
+                // Emit batch events per collection
+                if (batchData.length > 0) {
+                    if (this.emittingPublishEvents || this.auditing) {
+                        this.emit("publish", {
+                            channel: `db/${dbName}/${collection}`,
+                            payload: {
+                                operation: "batch",
+                                db: dbName,
+                                collection,
+                                data: batchData
+                            }
+                        });
+                    }
+                    if (this.emittingPublishRevEvents) {
+                        const payload = {
+                            operation: "batch",
+                            db: dbName,
+                            collection,
+                            data: batchData.map(item => ({
+                                operation: item.operation,
+                                _id: item.data._id,
+                                _ts: item.data._ts,
+                            }))
+                        };
+                        this.emit("publishRev", {
+                            channel: `dbrev/${dbName}/${collection}`,
+                            payload,
+                        });
+                    }
+                }
+                results.push(result);
+            }
+        }
+        fjLog.debug('updateCollections returns', results);
+        return results;
+    }
     async upsertBatch(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);
+        fjLog.debug('upsertBatch called', collection, batch);
         const dbName = this.db; // Capture db at operation start
         batch = this.replaceIds(batch);
         await Promise.all(batch.map(item => this._processHashedKeys(item === null || item === void 0 ? void 0 : item.update)));
@@ -652,14 +841,14 @@ export class Mongo extends Db {
             }
             return changes;
         }, false, { operation: "upsertBatch", collection, batch });
-        log.debug('upsertBatch returns', ret);
+        fjLog.debug('upsertBatch returns', ret);
         return ret;
     }
     async insertMany(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);
+        fjLog.debug('insertMany called', collection, insert);
         const dbName = this.db; // Capture db at operation start
         insert = this.replaceIds(insert);
         await Promise.all(insert.map(item => this._processHashedKeys(item)));
@@ -682,7 +871,7 @@ export class Mongo extends Db {
             }
             return ret;
         }, false, { operation: "insertMany", collection, insert });
-        log.debug('insertMany returns', ret);
+        fjLog.debug('insertMany returns', ret);
         return ret;
     }
     async deleteOne(collection, query) {
@@ -692,14 +881,14 @@ export class Mongo extends Db {
         query = this.replaceIds(query);
         if (!this.softdelete) {
             const opts = this._sessionOpt();
-            log.debug('deleteOne called', this.softdelete, collection, query);
+            fjLog.debug('deleteOne called', this.softdelete, collection, query);
             let ret = await this.executeTransactionally(collection, async (conn) => {
                 let obj = await conn.findOneAndDelete(query, opts);
                 if (obj)
                     await this._publishAndAudit('delete', dbName, collection, obj);
                 return obj;
             }, false, { operation: "deleteOne", collection, query, softdelete: this.softdelete });
-            log.debug('deleteOne returns', ret);
+            fjLog.debug('deleteOne returns', ret);
             return ret;
         }
         else {
@@ -708,7 +897,7 @@ export class Mongo extends Db {
                 returnDocument: "after",
                 ...this._sessionOpt()
             };
-            log.debug('deleteOne called', collection, query);
+            fjLog.debug('deleteOne called', collection, query);
             let ret = await this.executeTransactionally(collection, async (conn /*, client*/) => {
                 let del = {
                     $set: { _deleted: new Date() },
@@ -721,7 +910,7 @@ export class Mongo extends Db {
                     await this._publishAndAudit('delete', dbName, collection, obj);
                 return obj;
             }, false, { operation: "deleteOne", collection, query, softdelete: this.softdelete });
-            log.debug('deleteOne returns', ret);
+            fjLog.debug('deleteOne returns', ret);
             return ret;
         }
     }
@@ -733,7 +922,7 @@ export class Mongo extends Db {
         };
         const dbName = this.db; // Capture db at operation start
         query = this.replaceIds(query);
-        log.debug('blockOne called', collection, query);
+        fjLog.debug('blockOne called', collection, query);
         let ret = await this.executeTransactionally(collection, async (conn) => {
             query._blocked = { $exists: 0 };
             let update = {
@@ -750,7 +939,7 @@ export class Mongo extends Db {
             await this._publishAndAudit('update', dbName, collection, obj);
             return obj;
         }, false, { operation: "blockOne", collection, query });
-        log.debug('blockOne returns', ret);
+        fjLog.debug('blockOne returns', ret);
         return ret;
     }
     async unblockOne(collection, query) {
@@ -761,7 +950,7 @@ export class Mongo extends Db {
         };
         const dbName = this.db; // Capture db at operation start
         query = this.replaceIds(query);
-        log.debug('unblockOne called', collection, query);
+        fjLog.debug('unblockOne called', collection, query);
         let ret = await this.executeTransactionally(collection, async (conn) => {
             query._blocked = { $exists: 1 };
             let update = {
@@ -778,7 +967,7 @@ export class Mongo extends Db {
             await this._publishAndAudit('update', dbName, collection, obj);
             return obj;
         }, false, { operation: "unblockOne", collection, query });
-        log.debug('unblockOne returns', ret);
+        fjLog.debug('unblockOne returns', ret);
         return ret;
     }
     async hardDeleteOne(collection, query) {
@@ -793,7 +982,7 @@ export class Mongo extends Db {
             returnDocument: "after",
             ...this._sessionOpt()
         };
-        log.debug('hardDeleteOne called', collection, query);
+        fjLog.debug('hardDeleteOne called', collection, query);
         let ret = await this.executeTransactionally(collection, async (conn) => {
             let obj = await conn.findOneAndDelete(query, opts);
             if (obj) {
@@ -801,18 +990,18 @@ export class Mongo extends Db {
             }
             return obj;
         }, false, { operation: "hardDeleteOne", collection, query });
-        log.debug('hardDeleteOne returns', ret);
+        fjLog.debug('hardDeleteOne returns', ret);
         return ret;
     }
     async delete(collection, query) {
         assert(collection);
         assert(query);
-        // if (this.syncSupport) log.warn("delete does not increase _csq, avoit it.")
+        // if (this.syncSupport) fjLog.warn("delete does not increase _csq, avoit it.")
         const dbName = this.db; // Capture db at operation start
         query = this.replaceIds(query);
         if (!this.softdelete) {
             const opts = this._sessionOpt();
-            log.debug('delete called', collection, query);
+            fjLog.debug('delete called', collection, query);
             let ret = await this.executeTransactionally(collection, async (conn) => {
                 let obj = await conn.deleteMany(query, opts);
                 let resObj = {
@@ -822,7 +1011,7 @@ export class Mongo extends Db {
                 await this._publishAndAudit('deleteMany', dbName, collection, resObj);
                 return resObj;
             }, false, { operation: "delete", collection, query, softdelete: this.softdelete });
-            log.debug('delete returns', ret);
+            fjLog.debug('delete returns', ret);
             return ret;
         }
         else {
@@ -832,7 +1021,7 @@ export class Mongo extends Db {
                 ...this._sessionOpt()
             };
             let date = new Date();
-            log.debug('delete called', collection, query);
+            fjLog.debug('delete called', collection, query);
             let ret = await this.executeTransactionally(collection, async (conn) => {
                 let upd = {
                     $set: { _deleted: date },
@@ -847,18 +1036,18 @@ export class Mongo extends Db {
                 await this._publishAndAudit('deleteMany', dbName, collection, resObj);
                 return resObj;
             }, false, { operation: "delete", collection, query, softdelete: this.softdelete });
-            log.debug('delete returns', ret);
+            fjLog.debug('delete returns', ret);
             return ret;
         }
     }
     async hardDelete(collection, query) {
         assert(collection);
         assert(query);
-        // if (this.syncSupport) log.warn("hardDelete does not increase _csq, avoit it.")
+        // if (this.syncSupport) fjLog.warn("hardDelete does not increase _csq, avoit it.")
         const dbName = this.db; // Capture db at operation start
         query = this.replaceIds(query);
         const opts = this._sessionOpt();
-        log.debug('hardDelete called', collection, query);
+        fjLog.debug('hardDelete called', collection, query);
         let ret = await this.executeTransactionally(collection, async (conn) => {
             let obj = await conn.deleteMany(query, opts);
             let resObj = {
@@ -868,12 +1057,12 @@ export class Mongo extends Db {
             await this._publishAndAudit('deleteMany', dbName, collection, resObj);
             return resObj;
         }, false, { operation: "hardDelete", collection, query, softdelete: this.softdelete });
-        log.debug('hardDelete returns', ret);
+        fjLog.debug('hardDelete returns', ret);
         return ret;
     }
     async testHash(collection, query, field, unhashedValue) {
         let _field;
-        log.debug('testHash called', collection, query, field, unhashedValue);
+        fjLog.debug('testHash called', collection, query, field, unhashedValue);
         if (typeof field === "object") {
             if (Object.keys(field).length === 1)
                 [_field, unhashedValue] = Object.entries(field)[0];
@@ -888,11 +1077,11 @@ export class Mongo extends Db {
         let conn = await this.connect();
         let obj = await conn.db(dbName).collection(collection).findOne(query, { projection: { [_field]: 1 }, ...this._sessionOpt() });
         if (!obj || !obj[_field]) {
-            log.debug('testHash returns false', obj);
+            fjLog.debug('testHash returns false', obj);
             return false;
         }
         let res = await bcrypt.compare(unhashedValue, obj[_field].hash);
-        log.debug('testHash returns', res);
+        fjLog.debug('testHash returns', res);
         return res;
     }
     async aggregate(collection, pipeline, opts = {
@@ -900,7 +1089,7 @@ export class Mongo extends Db {
     }) {
         assert(collection);
         assert(pipeline instanceof Array);
-        log.debug('aggregate called', collection, pipeline);
+        fjLog.debug('aggregate called', collection, pipeline);
         pipeline = this.replaceIds(pipeline);
         if (this.session)
             opts.session = this.session;
@@ -908,7 +1097,7 @@ export class Mongo extends Db {
             let res = await conn.aggregate(pipeline, opts).toArray();
             return res;
         }, false, { operation: "aggregate", collection, pipeline, opts });
-        log.debug('aggregare returns', ret);
+        fjLog.debug('aggregare returns', ret);
         return ret;
     }
     async isUnique(collection, field, value, id) {
@@ -916,7 +1105,7 @@ export class Mongo extends Db {
         assert(field);
         if (!value)
             return false;
-        log.debug('isUnique called', collection, field, value, id);
+        fjLog.debug('isUnique called', collection, field, value, id);
         let _id = id === null || id === void 0 ? void 0 : id.toString();
         let query = typeof value === "object" ? value : { [field]: value };
         query = this.replaceIds(query);
@@ -926,21 +1115,21 @@ export class Mongo extends Db {
             return res;
         }, false, { operation: "isUnique", collection, field, value, id });
         let ret = true;
-        log.debug(`isUnique query`, query);
-        log.debug(`isUnique matches`, matches);
+        fjLog.debug(`isUnique query`, query);
+        fjLog.debug(`isUnique matches`, matches);
         for (let match of matches || []) {
             if (match._id.toString() !== _id && !match._deleted) {
                 ret = false;
                 return false;
             }
         }
-        log.debug('isUnique returns', ret);
+        fjLog.debug('isUnique returns', ret);
         return ret;
     }
     async collectFieldValues(collection, field, inArray = false, opts) {
         assert(collection);
         assert(field);
-        log.debug('collectFieldValues called', collection, field);
+        fjLog.debug('collectFieldValues called', collection, field);
         let pipeline = [
             { $group: { _id: '$' + field } },
             { $sort: { _id: 1 } }
@@ -956,34 +1145,34 @@ export class Mongo extends Db {
             return res;
         }, false, { operation: "collectFieldValues", collection, field, inArray, pipeline, opts });
         let ret = res === null || res === void 0 ? void 0 : res.map((v) => v._id);
-        log.debug('collectFieldValues returns', ret);
+        fjLog.debug('collectFieldValues returns', ret);
         return ret;
     }
     async dropCollection(collection) {
         assert(collection);
-        log.debug('dropCollection called', this.auditCollections);
+        fjLog.debug('dropCollection called', this.auditCollections);
         const dbName = this.db; // Capture db at operation start
         let client = await this.connect();
         let existing = await client.db(dbName).collections();
         if (existing.map((c) => c.collectionName).includes(collection)) {
             await client.db(dbName).dropCollection(collection);
         }
-        log.debug('dropCollection returns');
+        fjLog.debug('dropCollection returns');
     }
     async resetCollectionSync(collection) {
         assert(collection);
-        log.debug('resetCollectionSync called for', collection);
+        fjLog.debug('resetCollectionSync called for', collection);
         const dbName = this.db; // Capture db at operation start
         let client = await this.connect();
         await client.db(dbName)
             .collection(SEQUENCES_COLLECTION)
             .findOneAndDelete({ collection });
-        log.debug(`resetCollectionSync for ${collection} returns`);
+        fjLog.debug(`resetCollectionSync for ${collection} returns`);
     }
     async dropCollections(collections) {
         assert(collections);
         assert(collections instanceof Array);
-        log.debug('dropCollections called', this.auditCollections);
+        fjLog.debug('dropCollections called', this.auditCollections);
         const dbName = this.db; // Capture db at operation start
         let client = await this.connect();
         let existing = await client.db(dbName).collections();
@@ -992,12 +1181,12 @@ export class Mongo extends Db {
                 await client.db(dbName).dropCollection(collection);
             }
         }
-        log.debug('dropCollections returns');
+        fjLog.debug('dropCollections returns');
     }
     async createCollections(collections) {
         assert(collections);
         assert(collections instanceof Array);
-        log.debug('createCollections called', this.auditCollections);
+        fjLog.debug('createCollections called', this.auditCollections);
         const dbName = this.db; // Capture db at operation start
         let client = await this.connect();
         let existing = await this.getCollections();
@@ -1006,22 +1195,22 @@ export class Mongo extends Db {
                 await client.db(dbName).createCollection(collection);
             }
         }
-        log.debug('createCollections returns');
+        fjLog.debug('createCollections returns');
     }
     async createCollection(collection) {
         assert(collection);
-        log.debug('createCollection called', collection);
+        fjLog.debug('createCollection called', collection);
         const dbName = this.db; // Capture db at operation start
         let client = await this.connect();
         let existing = await this.getCollections();
         if (!existing.includes(collection)) {
             await client.db(dbName).createCollection(collection);
         }
-        log.debug('createCollection returns');
+        fjLog.debug('createCollection returns');
     }
     async dbLogPurge(collection, _id) {
         assert(collection);
-        log.debug('dblogPurge called', collection, _id);
+        fjLog.debug('dblogPurge called', collection, _id);
         const dbName = this.db; // Capture db at operation start
         let ret = await this.executeTransactionally(collection, async () => {
             let cond = { db: dbName, collection, };
@@ -1037,12 +1226,12 @@ export class Mongo extends Db {
                 n: ret.deletedCount
             };
         }, false, { operation: "dbLogPurge", collection, _id });
-        log.debug('dblogPurge returns', ret);
+        fjLog.debug('dblogPurge returns', ret);
         return ret;
     }
     async dbLogGet(collection, _id) {
         assert(collection);
-        log.debug('dblogGet called', collection, _id);
+        fjLog.debug('dblogGet called', collection, _id);
         const dbName = this.db; // Capture db at operation start
         let ret = await this.executeTransactionally(collection, async () => {
             let cond = { db: dbName, collection };
@@ -1057,7 +1246,7 @@ export class Mongo extends Db {
                 .toArray();
             return ret;
         }, false, { operation: "dbLogGet", collection, _id });
-        log.debug('dblogGet returns', ret);
+        fjLog.debug('dblogGet returns', ret);
         return ret;
     }
     // HELPER FUNCTIONS
@@ -1121,32 +1310,32 @@ export class Mongo extends Db {
         if (this.session) {
             try {
                 if (await this.inTransaction()) {
-                    log.warn("Aborting active transaction during close");
+                    fjLog.warn("Aborting active transaction during close");
                     await this.session.abortTransaction();
-                    log.info("transaction aborted");
+                    fjLog.info("transaction aborted");
                 }
                 await this.session.endSession();
-                log.info("session ended");
+                fjLog.info("session ended");
             }
             catch (err) {
-                log.error(`Error ending session ${err.message}`);
+                fjLog.error(`Error ending session ${err.message}`);
             }
         }
         // 2. Clean up event listeners
         try {
             this.emitter.removeAllListeners();
-            log.debug("event listeners removed");
+            fjLog.debug("event listeners removed");
         }
         catch (err) {
-            log.error(`Error removing event listeners ${err.message}`);
+            fjLog.error(`Error removing event listeners ${err.message}`);
         }
         // 3. Close parent connection
         try {
             await super.close(force);
-            log.info("connection closed");
+            fjLog.info("connection closed");
         }
         catch (err) {
-            log.debug(`close parent connection failed: ${err.message || err}`);
+            fjLog.debug(`close parent connection failed: ${err.message || err}`);
         }
         // 4. Clean up state
         this.session = undefined;
@@ -1166,13 +1355,13 @@ export class Mongo extends Db {
             let client = await this.connect();
             if (!this.session) {
                 this.session = client.startSession();
-                log.info("session started");
+                fjLog.info("session started");
             }
             let session = this.session;
             await session.withTransaction(async () => await funct(client, session));
             if (!hadSession) {
                 session.endSession();
-                log.info("session ended");
+                fjLog.info("session ended");
                 this.session = undefined;
             }
             return;
@@ -1181,7 +1370,7 @@ export class Mongo extends Db {
             if (!hadSession && this.session) {
                 try {
                     await this.session.endSession();
-                    log.info("session ended after error");
+                    fjLog.info("session ended after error");
                 }
                 catch { /* ignore cleanup errors */ }
                 this.session = undefined;
@@ -1196,24 +1385,24 @@ export class Mongo extends Db {
         try {
             if (!this.session) {
                 this.session = client.startSession(TRANSACTION_OPTIONS);
-                log.info("session started");
+                fjLog.info("session started");
             }
             if (!await this.inTransaction()) {
                 await this.session.startTransaction();
-                log.info("transaction started");
+                fjLog.info("transaction started");
             }
         }
         catch (err) {
-            log.error('startTransaction error', err);
+            fjLog.error('startTransaction error', err);
             try {
                 if (this.session) {
                     await this.session.endSession();
-                    log.info("session ended");
+                    fjLog.info("session ended");
                 }
                 this.session = undefined;
             }
             catch (e) {
-                log.error("startTransaction - error in endSession", e.message || e);
+                fjLog.error("startTransaction - error in endSession", e.message || e);
             }
             return;
         }
@@ -1226,13 +1415,13 @@ export class Mongo extends Db {
                 return;
             let session = this.session;
             await session.commitTransaction();
-            log.info("transaction committed");
+            fjLog.info("transaction committed");
             session.endSession();
             this.session = undefined;
-            log.info("session ended");
+            fjLog.info("session ended");
         }
         catch (err) {
-            log.error(`commitTransaction error ${err.message || err}`);
+            fjLog.error(`commitTransaction error ${err.message || err}`);
         }
     }
     async abortTransaction() {
@@ -1243,13 +1432,13 @@ export class Mongo extends Db {
                 return;
             let session = this.session;
             await session.abortTransaction();
-            log.info("transaction aborted");
+            fjLog.info("transaction aborted");
             await session.endSession();
             this.session = undefined;
-            log.info("session ended");
+            fjLog.info("session ended");
         }
         catch (err) {
-            log.error(`abortTransaction error ${err.message || err}`);
+            fjLog.error(`abortTransaction error ${err.message || err}`);
         }
     }
     async _try_once(useTransaction, f, collection, dbName) {
@@ -1274,7 +1463,7 @@ export class Mongo extends Db {
                     await this.abortTransaction();
             }
             catch (abortErr) {
-                log.debug(`abort transaction failed: ${abortErr.message || abortErr}`);
+                fjLog.debug(`abort transaction failed: ${abortErr.message || abortErr}`);
             }
             throw err;
         }
@@ -1289,13 +1478,13 @@ export class Mongo extends Db {
             return await this._try_once(useTransaction, f, collection, dbName);
         }
         catch (err) {
-            log.error(`Mongo command has failed for ${dbName}.${collection} - ${(this.session ? "ROLLBACK - " : "")} ${err.message || err}`);
-            log.error(debugObject);
-            log.debug(err);
+            fjLog.error(`Mongo command has failed for ${dbName}.${collection} - ${(this.session ? "ROLLBACK - " : "")} ${err.message || err}`);
+            fjLog.error(debugObject);
+            fjLog.debug(err);
             let x = ((err === null || err === void 0 ? void 0 : err.message) || (err === null || err === void 0 ? void 0 : err.toString()) || "").toString();
             // test for duplicate ID insert
             if ((x === null || x === void 0 ? void 0 : x.match(/E11000/gi)) && debugObject.operation === "insert") {
-                log.error("Duplicate ID insert - ignoring and returning inserted object");
+                fjLog.error("Duplicate ID insert - ignoring and returning inserted object");
                 return debugObject.insert;
             }
             let isRepeatable = x.match(/Topology is closed, please connect/i)
@@ -1306,21 +1495,21 @@ export class Mongo extends Db {
                 || x.match(/Connection pool closed/i);
             if (isRepeatable) {
                 try {
-                    log.error("Trying to reopen connection and repeat as");
+                    fjLog.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, dbName);
-                    log.error("OK - Retry succeeded.");
-                    log.error("");
+                    fjLog.error("OK - Retry succeeded.");
+                    fjLog.error("");
                     return ret;
                 }
                 catch (err2) {
                     /* intentional */
                     if (debugObject)
-                        log.error(debugObject);
-                    log.error(`FAIL - Retry failed: ${err2.message || err2}`);
-                    log.error("");
+                        fjLog.error(debugObject);
+                    fjLog.error(`FAIL - Retry failed: ${err2.message || err2}`);
+                    fjLog.error("");
                 }
             }
             throw err;
@@ -1572,7 +1761,7 @@ export class Mongo extends Db {
         return toPublish;
     }
     emit(event, what) {
-        log.debug("emitting", event, what);
+        fjLog.debug("emitting", event, what);
         if (event === "publish")
             this.emitter.emit(event, what);
         if (event === "publishRev")
@@ -1606,11 +1795,11 @@ export class Mongo extends Db {
             auditRecord.user = user;
         if (audit)
             auditRecord.audit = audit;
-        log.trace('AUDITING', auditRecord);
+        fjLog.trace('AUDITING', auditRecord);
         let ret = await client.db(db)
             .collection(this.auditCollectionName)
             .insertOne(auditRecord, this._sessionOpt());
-        log.debug('AUDITED', auditRecord, ret.insertedId);
+        fjLog.debug('AUDITED', auditRecord, ret.insertedId);
     }
     _sessionOpt() {
         return this.session ? { session: this.session } : {};