@frogfish/k2db 2.0.3 → 2.0.6

package/dist/db.d.ts

@@ -47,6 +47,9 @@ export interface DropResult {
 export interface PurgeResult {
     id: string;
 }
+export interface PurgeManyResult {
+    purged: number;
+}
 export interface VersionedUpdateResult {
     updated: number;
     versionSaved: number;
@@ -150,6 +153,14 @@ export declare class K2DB {
      * @param id - UUID of the document.
      */
     purge(collectionName: string, id: string): Promise<PurgeResult>;
+    /**
+     * Permanently deletes all documents that are soft-deleted and whose _updated
+     * timestamp is older than the provided threshold (in milliseconds ago).
+     * @param collectionName - Name of the collection.
+     * @param olderThanMs - Age threshold in milliseconds; documents with
+     *                      `_updated <= (Date.now() - olderThanMs)` will be purged.
+     */
+    purgeDeletedOlderThan(collectionName: string, olderThanMs: number): Promise<PurgeManyResult>;
     /**
      * Restores a soft-deleted document.
      * @param collectionName - Name of the collection.

package/dist/db.js

@@ -398,9 +398,19 @@ export class K2DB {
         this.validateCollectionName(collectionName);
         const collection = await this.getCollection(collectionName);
         debug(`Updating ${collectionName} with criteria: ${JSON.stringify(criteria)}`);
+        // Preserve intent to set _deleted during internal soft-delete operations.
+        // stripReservedFields removes underscore-prefixed keys (by design) to protect
+        // internal fields from user updates. However, deleteAll() legitimately passes
+        // {_deleted: true}. Capture and restore it here.
+        const deletedFlag = Object.prototype.hasOwnProperty.call(values, "_deleted")
+            ? values._deleted
+            : undefined;
         values = K2DB.stripReservedFields(values);
         values = this.applySchema(collectionName, values, /*partial*/ true);
         values._updated = Date.now();
+        if (deletedFlag !== undefined) {
+            values._deleted = deletedFlag;
+        }
         criteria = {
             ...criteria,
             _deleted: { $ne: true },
@@ -507,6 +517,10 @@ export class K2DB {
             }
         }
         catch (err) {
+            // Preserve existing K2Error classifications (e.g., NOT_FOUND)
+            if (err instanceof K2Error) {
+                throw err;
+            }
             throw new K2Error(ServiceError.SYSTEM_ERROR, "Error removing object from collection", "sys_mdb_remove_upd", this.normalizeError(err));
         }
     }
@@ -535,6 +549,31 @@ export class K2DB {
             throw new K2Error(ServiceError.SYSTEM_ERROR, `Error purging item with id: ${id}`, "sys_mdb_pg", this.normalizeError(err));
         }
     }
+    /**
+     * Permanently deletes all documents that are soft-deleted and whose _updated
+     * timestamp is older than the provided threshold (in milliseconds ago).
+     * @param collectionName - Name of the collection.
+     * @param olderThanMs - Age threshold in milliseconds; documents with
+     *                      `_updated <= (Date.now() - olderThanMs)` will be purged.
+     */
+    async purgeDeletedOlderThan(collectionName, olderThanMs) {
+        this.validateCollectionName(collectionName);
+        if (typeof olderThanMs !== 'number' || !isFinite(olderThanMs) || olderThanMs < 0) {
+            throw new K2Error(ServiceError.BAD_REQUEST, 'olderThanMs must be a non-negative number', 'sys_mdb_purge_older_invalid');
+        }
+        const collection = await this.getCollection(collectionName);
+        const cutoff = Date.now() - olderThanMs;
+        try {
+            const res = await this.runTimed('deleteMany', { collectionName, olderThanMs, cutoff }, async () => await collection.deleteMany({
+                _deleted: true,
+                _updated: { $lte: cutoff },
+            }));
+            return { purged: res.deletedCount ?? 0 };
+        }
+        catch (err) {
+            throw new K2Error(ServiceError.SYSTEM_ERROR, 'Error purging deleted items by age', 'sys_mdb_purge_older', this.normalizeError(err));
+        }
+    }
     /**
      * Restores a soft-deleted document.
      * @param collectionName - Name of the collection.
@@ -545,7 +584,8 @@ export class K2DB {
         const query = { ...(criteria || {}), _deleted: true };
         try {
             const res = await this.runTimed("updateMany", { collectionName, query }, async () => await collection.updateMany(query, {
-                $set: { _deleted: false },
+                // Restoring is a data change: flip _deleted and bump _updated
+                $set: { _deleted: false, _updated: Date.now() },
             }));
             return { status: "restored", modified: res.modifiedCount };
         }
@@ -656,7 +696,9 @@ export class K2DB {
         const { uuidUnique = false, uuidPartialUnique = true, ownerIndex = true, deletedIndex = true, } = opts;
         const collection = await this.getCollection(collectionName);
         if (uuidPartialUnique) {
-            await collection.createIndex({ _uuid: 1 }, { unique: true, partialFilterExpression: { _deleted: { $ne: true } } });
+            // Use a compound unique index to ensure at most one non-deleted document per _uuid
+            // without relying on partialFilterExpression (which may be limited in some environments).
+            await collection.createIndex({ _uuid: 1, _deleted: 1 }, { unique: true });
         }
         else if (uuidUnique) {
             await collection.createIndex({ _uuid: 1 }, { unique: true });

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frogfish/k2db",
-  "version": "2.0.3",
+  "version": "2.0.6",
   "description": "A data handling library for K2 applications.",
   "type": "module",
   "main": "data.js",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frogfish/k2db",
-  "version": "2.0.3",
+  "version": "2.0.6",
   "description": "A data handling library for K2 applications.",
   "main": "./dist/data.js",
   "types": "./dist/data.d.ts",