cry-db 2.4.19 → 2.4.21

package/dist/mongo.mjs

@@ -70,6 +70,7 @@ export class Mongo extends Db {
         super(db, url);
         this.revisions = false;
         this.softdelete = false;
+        this.softarchive = false;
         this.syncSupport = false;
         this.session = undefined;
         this.emittingPublishEvents = false;
@@ -114,6 +115,17 @@ export class Mongo extends Db {
     usesSoftDelete() {
         return this.softdelete;
     }
+    /**
+     * Enable or disable archive filtering.
+     * When enabled, query operations exclude records with `_archived` set,
+     * unless `returnArchived: true` is passed in opts.
+     */
+    useArchive(enabled) {
+        return this.softarchive = !!enabled;
+    }
+    usesArchive() {
+        return this.softarchive;
+    }
     useAuditing(enabled) {
         return this.auditing = enabled;
     }
@@ -199,6 +211,10 @@ export class Mongo extends Db {
             if (!query._deleted)
                 query._deleted = { $exists: false };
         }
+        if (this.softarchive && !opts.returnArchived) {
+            if (!query._archived)
+                query._archived = { $exists: false };
+        }
         fjLog.debug('count called', collection, query, opts);
         let ret = await this.executeTransactionally(collection, async (conn) => {
             return await conn.countDocuments(query, opts);
@@ -213,6 +229,10 @@ export class Mongo extends Db {
             if (!query._deleted)
                 query._deleted = { $exists: false };
         }
+        if (this.softarchive && !opts.returnArchived) {
+            if (!query._archived)
+                query._archived = { $exists: false };
+        }
         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);
@@ -237,6 +257,10 @@ export class Mongo extends Db {
             if (!query._deleted)
                 query._deleted = { $exists: false };
         }
+        if (this.softarchive && !opts.returnArchived) {
+            if (!query._archived)
+                query._archived = { $exists: false };
+        }
         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);
@@ -245,18 +269,22 @@ export class Mongo extends Db {
         fjLog.debug('findNewer returns', ret);
         return ret;
     }
-    async findNewerMany(spec = []) {
+    async findNewerMany(spec = [], defaultOpts = {}) {
         var _a;
         fjLog.debug('findNewerMany called', spec);
         const dbName = this.db; // Capture db at operation start
         let conn = await this.connect();
         const getOneColl = async (coll) => {
             let query = this._createQueryForNewer(coll.timestamp, coll.query || {});
-            const opts = coll.opts || {};
+            const opts = { ...defaultOpts, ...coll.opts };
             if (this.softdelete && !opts.returnDeleted) {
                 if (!query._deleted)
                     query._deleted = { $exists: false };
             }
+            if (this.softarchive && !opts.returnArchived) {
+                if (!query._archived)
+                    query._archived = { $exists: false };
+            }
             if (process.env.MONGO_DEBUG_FINDNEWERMANY) {
                 fjLog.debug("findNewerMany <-", coll.collection, coll.timestamp, coll.query, " -> ", JSON.stringify(query));
             }
@@ -406,6 +434,10 @@ export class Mongo extends Db {
             if (!query._deleted)
                 query._deleted = { $exists: false };
         }
+        if (this.softarchive && !opts.returnArchived) {
+            if (!query._archived)
+                query._archived = { $exists: false };
+        }
         // if (!query._blocked) query._blocked = { $exists: false };   // intentionally - blocked records are returned
         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 });
@@ -420,16 +452,19 @@ export class Mongo extends Db {
         const dbName = this.db; // Capture db at operation start
         let query = {
             _id: Mongo._toId(id),
-            // _deleted: { $exists: false }
         };
+        if (this.softdelete && !opts.returnDeleted) {
+            query._deleted = { $exists: false };
+        }
+        if (this.softarchive && !opts.returnArchived) {
+            query._archived = { $exists: false };
+        }
         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;
         fjLog.debug('findById returns', ret);
         return this._processReturnedObject(ret);
     }
@@ -450,6 +485,9 @@ export class Mongo extends Db {
                 if (this.softdelete && !opts.returnDeleted) {
                     query._deleted = { $exists: false };
                 }
+                if (this.softarchive && !opts.returnArchived) {
+                    query._archived = { $exists: false };
+                }
                 let r = conn.find(query, { ...(projection ? { projection } : {}), ...this._sessionOpt() });
                 return await r.toArray();
             }, false, { operation: "findByIdsInManyCollections", collection, ids, projection });
@@ -476,6 +514,9 @@ export class Mongo extends Db {
             if (this.softdelete && !opts.returnDeleted) {
                 query._deleted = { $exists: false };
             }
+            if (this.softarchive && !opts.returnArchived) {
+                query._archived = { $exists: false };
+            }
             let r = conn.find(query, { ...(projection ? { projection } : {}), ...this._sessionOpt() });
             return await r.toArray();
         }, false, { operation: "findByIds", collection, ids, projection });
@@ -1067,6 +1108,158 @@ export class Mongo extends Db {
         fjLog.debug('unblockOne returns', ret);
         return ret;
     }
+    /**
+     * Archives a single document by setting `_archived` to the current date.
+     * Increments `_rev` and updates `_ts`.
+     */
+    async archiveOne(collection, query) {
+        let opts = {
+            upsert: false,
+            returnDocument: "after",
+            ...this._sessionOpt()
+        };
+        const dbName = this.db;
+        query = this.replaceIds(query);
+        fjLog.debug('archiveOne called', collection, query);
+        let ret = await this.executeTransactionally(collection, async (conn) => {
+            query._archived = { $exists: false };
+            let update = {
+                $set: { _archived: new Date(), },
+                $inc: { _rev: 1, },
+                $currentDate: { _ts: { $type: 'timestamp' } }
+            };
+            let obj = await conn.findOneAndUpdate(query, update, opts);
+            if (!obj || !(obj === null || obj === void 0 ? void 0 : obj._id))
+                return {
+                    ok: false
+                };
+            await this._publishAndAudit('update', dbName, collection, obj);
+            return obj;
+        }, false, { operation: "archiveOne", collection, query });
+        fjLog.debug('archiveOne returns', ret);
+        return ret;
+    }
+    /**
+     * Unarchives a single document by removing the `_archived` field.
+     * Increments `_rev` and updates `_ts`.
+     */
+    async unarchiveOne(collection, query) {
+        let opts = {
+            upsert: false,
+            returnDocument: "after",
+            ...this._sessionOpt()
+        };
+        const dbName = this.db;
+        query = this.replaceIds(query);
+        fjLog.debug('unarchiveOne called', collection, query);
+        let ret = await this.executeTransactionally(collection, async (conn) => {
+            query._archived = { $exists: true };
+            let update = {
+                $unset: { _archived: 1 },
+                $inc: { _rev: 1, },
+                $currentDate: { _ts: { $type: 'timestamp' } }
+            };
+            let obj = await conn.findOneAndUpdate(query, update, opts);
+            if (!obj || !(obj === null || obj === void 0 ? void 0 : obj._id))
+                return {
+                    ok: false
+                };
+            await this._publishAndAudit('update', dbName, collection, obj);
+            return obj;
+        }, false, { operation: "unarchiveOne", collection, query });
+        fjLog.debug('unarchiveOne returns', ret);
+        return ret;
+    }
+    /**
+     * Archives a single document found by its `_id`.
+     */
+    async archiveOneById(collection, id) {
+        assert(collection);
+        assert(id);
+        return await this.archiveOne(collection, { _id: Mongo._toId(id) });
+    }
+    /**
+     * Archives multiple documents found by their `_id`s.
+     * Returns the array of archived documents.
+     */
+    async archiveManyByIds(collection, ids) {
+        assert(collection);
+        assert(ids);
+        if (!ids || ids.length === 0)
+            return [];
+        const opts = {
+            upsert: false,
+            returnDocument: "after",
+            ...this._sessionOpt()
+        };
+        const dbName = this.db;
+        fjLog.debug('archiveManyByIds called', collection, ids);
+        let ret = [];
+        for (const id of ids) {
+            let r = await this.executeTransactionally(collection, async (conn) => {
+                let query = { _id: Mongo._toId(id), _archived: { $exists: false } };
+                let update = {
+                    $set: { _archived: new Date() },
+                    $inc: { _rev: 1 },
+                    $currentDate: { _ts: { $type: 'timestamp' } }
+                };
+                let obj = await conn.findOneAndUpdate(query, update, opts);
+                if (obj === null || obj === void 0 ? void 0 : obj._id) {
+                    await this._publishAndAudit('update', dbName, collection, obj);
+                }
+                return obj;
+            }, false, { operation: "archiveManyByIds", collection, id });
+            if (r === null || r === void 0 ? void 0 : r._id)
+                ret.push(r);
+        }
+        fjLog.debug('archiveManyByIds returns', ret);
+        return ret;
+    }
+    /**
+     * Unarchives a single document found by its `_id`.
+     */
+    async unarchiveOneById(collection, id) {
+        assert(collection);
+        assert(id);
+        return await this.unarchiveOne(collection, { _id: Mongo._toId(id) });
+    }
+    /**
+     * Unarchives multiple documents found by their `_id`s.
+     * Returns the array of unarchived documents.
+     */
+    async unarchiveManyByIds(collection, ids) {
+        assert(collection);
+        assert(ids);
+        if (!ids || ids.length === 0)
+            return [];
+        const opts = {
+            upsert: false,
+            returnDocument: "after",
+            ...this._sessionOpt()
+        };
+        const dbName = this.db;
+        fjLog.debug('unarchiveManyByIds called', collection, ids);
+        let ret = [];
+        for (const id of ids) {
+            let r = await this.executeTransactionally(collection, async (conn) => {
+                let query = { _id: Mongo._toId(id), _archived: { $exists: true } };
+                let update = {
+                    $unset: { _archived: 1 },
+                    $inc: { _rev: 1 },
+                    $currentDate: { _ts: { $type: 'timestamp' } }
+                };
+                let obj = await conn.findOneAndUpdate(query, update, opts);
+                if (obj === null || obj === void 0 ? void 0 : obj._id) {
+                    await this._publishAndAudit('update', dbName, collection, obj);
+                }
+                return obj;
+            }, false, { operation: "unarchiveManyByIds", collection, id });
+            if (r === null || r === void 0 ? void 0 : r._id)
+                ret.push(r);
+        }
+        fjLog.debug('unarchiveManyByIds returns', ret);
+        return ret;
+    }
     async hardDeleteOne(collection, query) {
         assert(collection);
         assert(query);