@frogfish/k2db 3.0.4 → 3.0.7

package/db.js

@@ -457,7 +457,23 @@ export class K2DB {
                 const msg = err instanceof Error
                     ? `Failed to connect to MongoDB: ${err.message}`
                     : `Failed to connect to MongoDB: ${String(err)}`;
-                throw wrap(err, ServiceError.SERVICE_UNAVAILABLE, "sys_mdb_init", msg);
+                // Preserve existing K2Error severity if already typed; otherwise map to SERVICE_UNAVAILABLE.
+                const sev = err instanceof K2Error ? undefined : ServiceError.SERVICE_UNAVAILABLE;
+                const k2 = chain(err, "sys_mdb_init", msg, sev, "k2db.init")
+                    .setSensitive({
+                    op: "init",
+                    db: this.conf?.name,
+                    // safeConnectUrl is already masked (no credentials)
+                    connectUrl: safeConnectUrl,
+                    options: summariseValueShape(options),
+                    mongo: normaliseMongoError(err),
+                });
+                // Emit once (deduped per error instance)
+                emitDbError(k2, {
+                    op: "init",
+                    db: this.conf?.name,
+                });
+                throw k2;
             }
         })().finally(() => {
             // Allow retry after failure; once initialized, subsequent calls return early.
@@ -540,12 +556,16 @@ export class K2DB {
         }
         catch (err) {
             const sev = err instanceof K2Error ? undefined : ServiceError.SYSTEM_ERROR;
-            throw chain(err, "sys_mdb_gc", `Error getting collection: ${collectionName}`, sev, "k2db.getCollection")
-                .setSensitive({
+            const k2 = chain(err, "sys_mdb_gc", `Error getting collection: ${collectionName}`, sev, "k2db.getCollection").setSensitive({
                 op: "getCollection",
                 collection: collectionName,
                 mongo: normaliseMongoError(err),
             });
+            emitDbError(k2, {
+                op: "getCollection",
+                collection: collectionName,
+            });
+            throw k2;
         }
     }
     /**
@@ -557,10 +577,35 @@ export class K2DB {
     async get(collectionName, uuid, scope) {
         const id = K2DB.normalizeId(uuid);
         // Note: findOne() decrypts secure-prefixed fields for single-record reads when encryption is enabled.
-        const res = await this.findOne(collectionName, {
-            _uuid: id,
-            _deleted: { $ne: true },
-        }, undefined, scope);
+        let res;
+        try {
+            res = await this.findOne(collectionName, {
+                _uuid: id,
+                _deleted: { $ne: true },
+            }, undefined, scope);
+        }
+        catch (err) {
+            const sev = err instanceof K2Error ? undefined : ServiceError.SYSTEM_ERROR;
+            const k2 = chain(err, "sys_mdb_get", "Error getting document", sev, "k2db.get");
+            // Merge/attach sensitive diagnostics without stomping any existing sensitive payload.
+            const prevSensitive = k2.sensitive;
+            const mergedSensitive = prevSensitive && typeof prevSensitive === "object" ? { ...prevSensitive } : {};
+            Object.assign(mergedSensitive, {
+                op: "get",
+                collection: collectionName,
+                uuid: id,
+                scope,
+                mongo: normaliseMongoError(err),
+            });
+            k2.setSensitive?.(mergedSensitive);
+            // Emit once (deduped per error instance)
+            emitDbError(k2, {
+                op: "get",
+                collection: collectionName,
+                uuid: id,
+            });
+            throw k2;
+        }
         if (!res) {
             throw new K2Error(ServiceError.NOT_FOUND, "Document not found", "sys_mdb_get_not_found");
         }
@@ -628,8 +673,11 @@ export class K2DB {
         }
         catch (err) {
             const sev = err instanceof K2Error ? undefined : ServiceError.SYSTEM_ERROR;
-            throw chain(err, "sys_mdb_fo", "Error finding document", sev, "k2db.findOne")
-                .setSensitive({
+            const k2 = chain(err, "sys_mdb_fo", "Error finding document", sev, "k2db.findOne");
+            // Merge/attach sensitive diagnostics without stomping any existing sensitive payload.
+            const prevSensitive = k2.sensitive;
+            const mergedSensitive = prevSensitive && typeof prevSensitive === "object" ? { ...prevSensitive } : {};
+            Object.assign(mergedSensitive, {
                 op: "findOne",
                 collection: collectionName,
                 scope,
@@ -640,6 +688,12 @@ export class K2DB {
                 projectionPreview: redactShallowSecrets(projection),
                 mongo: normaliseMongoError(err),
             });
+            k2.setSensitive?.(mergedSensitive);
+            emitDbError(k2, {
+                op: "findOne",
+                collection: collectionName,
+            });
+            throw k2;
         }
     }
     /**
@@ -720,7 +774,7 @@ export class K2DB {
         }
         catch (err) {
             const sev = err instanceof K2Error ? undefined : ServiceError.SYSTEM_ERROR;
-            throw chain(err, "sys_mdb_find_error", "Error executing find query", sev, "k2db.find")
+            const k2 = chain(err, "sys_mdb_find_error", "Error executing find query", sev, "k2db.find")
                 .setSensitive({
                 op: "find",
                 collection: collectionName,
@@ -736,6 +790,13 @@ export class K2DB {
                 projectionPreview: redactShallowSecrets(projection),
                 mongo: normaliseMongoError(err),
             });
+            emitDbError(k2, {
+                op: "find",
+                collection: collectionName,
+                skip,
+                limit,
+            });
+            throw k2;
         }
     }
     /**
@@ -1182,8 +1243,10 @@ export class K2DB {
                 }
                 else if (lu.localField && lu.foreignField) {
                     // Convert simple lookup to pipeline lookup so we can enforce owner scope (and deleted) in foreign coll.
-                    const localVar = "__lk";
-                    const ownerVar = "__own";
+                    // NOTE: MongoDB aggregation user variables must start with a letter.
+                    // Avoid leading underscores (e.g. "__lk") which fail to parse on MongoDB.
+                    const localVar = "k2lk";
+                    const ownerVar = "k2own";
                     lu.let = { [localVar]: `$${lu.localField}`, [ownerVar]: normalizedScope };
                     lu.pipeline = [
                         {
@@ -1276,7 +1339,9 @@ export class K2DB {
                 }
                 else if (lu.localField && lu.foreignField) {
                     // Convert simple lookup to pipeline lookup to filter _deleted
-                    const localVar = "__lk";
+                    // NOTE: MongoDB aggregation user variables must start with a letter.
+                    // Avoid leading underscores (e.g. "__lk") which fail to parse on MongoDB.
+                    const localVar = "k2lk";
                     lu.let = { [localVar]: `$${lu.localField}` };
                     lu.pipeline = [
                         {
@@ -1381,7 +1446,7 @@ export class K2DB {
                 throw new K2Error(ServiceError.ALREADY_EXISTS, `A document with _uuid ${document._uuid} already exists.`, "sys_mdb_crv3");
             }
             const sev = err instanceof K2Error ? undefined : ServiceError.SYSTEM_ERROR;
-            throw chain(err, "sys_mdb_sav", "Error saving object to database", sev, "k2db.create")
+            const k2 = chain(err, "sys_mdb_sav", "Error saving object to database", sev, "k2db.create")
                 .setSensitive({
                 op: "insertOne",
                 collection: collectionName,
@@ -1391,6 +1456,12 @@ export class K2DB {
                 userFieldPreview: redactShallowSecrets(safeData),
                 mongo: normaliseMongoError(err),
             });
+            emitDbError(k2, {
+                op: "create",
+                collection: collectionName,
+                uuid: document._uuid,
+            });
+            throw k2;
         }
     }
     /**
@@ -1434,7 +1505,7 @@ export class K2DB {
         }
         catch (err) {
             const sev = err instanceof K2Error ? undefined : ServiceError.SYSTEM_ERROR;
-            throw chain(err, "sys_mdb_update1", `Error updating ${collectionName}`, sev, "k2db.updateAll")
+            const k2 = chain(err, "sys_mdb_update1", `Error updating ${collectionName}`, sev, "k2db.updateAll")
                 .setSensitive({
                 op: "updateMany",
                 collection: collectionName,
@@ -1446,6 +1517,11 @@ export class K2DB {
                 valuesPreview: redactShallowSecrets(values),
                 mongo: normaliseMongoError(err),
             });
+            emitDbError(k2, {
+                op: "updateAll",
+                collection: collectionName,
+            });
+            throw k2;
         }
     }
     /**
@@ -1502,7 +1578,7 @@ export class K2DB {
         }
         catch (err) {
             const sev = err instanceof K2Error ? undefined : ServiceError.SYSTEM_ERROR;
-            throw chain(err, "sys_mdb_update_error", `Error updating ${collectionName}`, sev, "k2db.update")
+            const k2 = chain(err, "sys_mdb_update_error", `Error updating ${collectionName}`, sev, "k2db.update")
                 .setSensitive({
                 op: replace ? "replaceOne" : "updateOne",
                 collection: collectionName,
@@ -1513,6 +1589,13 @@ export class K2DB {
                 dataPreview: redactShallowSecrets(data),
                 mongo: normaliseMongoError(err),
             });
+            emitDbError(k2, {
+                op: "update",
+                collection: collectionName,
+                uuid: id,
+                replace,
+            });
+            throw k2;
         }
     }
     /**
@@ -1531,8 +1614,7 @@ export class K2DB {
         }
         catch (err) {
             const sev = err instanceof K2Error ? undefined : ServiceError.SYSTEM_ERROR;
-            throw chain(err, "sys_mdb_deleteall_update", `Error deleting from ${collectionName}`, sev, "k2db.deleteAll")
-                .setSensitive({
+            const k2 = chain(err, "sys_mdb_deleteall_update", `Error deleting from ${collectionName}`, sev, "k2db.deleteAll").setSensitive({
                 op: "softDeleteMany",
                 collection: collectionName,
                 scope,
@@ -1540,6 +1622,11 @@ export class K2DB {
                 criteriaPreview: redactShallowSecrets(criteria),
                 mongo: normaliseMongoError(err),
             });
+            emitDbError(k2, {
+                op: "deleteAll",
+                collection: collectionName,
+            });
+            throw k2;
         }
     }
     /**
@@ -1569,14 +1656,19 @@ export class K2DB {
         }
         catch (err) {
             const sev = err instanceof K2Error ? undefined : ServiceError.SYSTEM_ERROR;
-            throw chain(err, "sys_mdb_remove_upd", "Error removing object from collection", sev, "k2db.delete")
-                .setSensitive({
+            const k2 = chain(err, "sys_mdb_remove_upd", "Error removing object from collection", sev, "k2db.delete").setSensitive({
                 op: "softDeleteOne",
                 collection: collectionName,
                 uuid: id,
                 scope,
                 mongo: normaliseMongoError(err),
             });
+            emitDbError(k2, {
+                op: "delete",
+                collection: collectionName,
+                uuid: id,
+            });
+            throw k2;
         }
     }
     /**
@@ -1637,8 +1729,9 @@ export class K2DB {
         }
         const collection = await this.getCollection(collectionName);
         const cutoff = Date.now() - olderThanMs;
+        let delFilter;
         try {
-            const delFilter = this.applyScopeToCriteria({
+            delFilter = this.applyScopeToCriteria({
                 _deleted: true,
                 _updated: { $lte: cutoff },
             }, scope);
@@ -1646,7 +1739,23 @@ export class K2DB {
             return { purged: res.deletedCount ?? 0 };
         }
         catch (err) {
-            throw wrap(err, ServiceError.SYSTEM_ERROR, 'sys_mdb_purge_older', 'Error purging deleted items by age');
+            const sev = err instanceof K2Error ? undefined : ServiceError.SYSTEM_ERROR;
+            const k2 = chain(err, 'sys_mdb_purge_older', 'Error purging deleted items by age', sev, 'k2db.purgeDeletedOlderThan').setSensitive({
+                op: 'purgeDeletedOlderThan',
+                collection: collectionName,
+                scope,
+                olderThanMs,
+                cutoff,
+                delFilterShape: summariseValueShape(delFilter),
+                delFilterPreview: redactShallowSecrets(delFilter),
+                mongo: normaliseMongoError(err),
+            });
+            emitDbError(k2, {
+                op: 'purgeDeletedOlderThan',
+                collection: collectionName,
+                olderThanMs,
+            });
+            throw k2;
         }
     }
     /**
@@ -1668,7 +1777,23 @@ export class K2DB {
             return { status: "restored", modified: res.modifiedCount };
         }
         catch (err) {
-            throw wrap(err, ServiceError.SYSTEM_ERROR, "sys_mdb_pres", "Error restoring a deleted item");
+            const sev = err instanceof K2Error ? undefined : ServiceError.SYSTEM_ERROR;
+            const k2 = chain(err, "sys_mdb_pres", "Error restoring a deleted item", sev, "k2db.restore")
+                .setSensitive({
+                op: "restore",
+                collection: collectionName,
+                scope,
+                criteriaShape: summariseValueShape(crit),
+                criteriaPreview: redactShallowSecrets(crit),
+                queryShape: summariseValueShape(query),
+                queryPreview: redactShallowSecrets(query),
+                mongo: normaliseMongoError(err),
+            });
+            emitDbError(k2, {
+                op: "restore",
+                collection: collectionName,
+            });
+            throw k2;
         }
     }
     /**
@@ -1731,7 +1856,19 @@ export class K2DB {
             return { status: "ok" };
         }
         catch (err) {
-            throw wrap(err, ServiceError.SYSTEM_ERROR, "sys_mdb_drop", "Error dropping collection");
+            const sev = err instanceof K2Error ? undefined : ServiceError.SYSTEM_ERROR;
+            const k2 = chain(err, "sys_mdb_drop", "Error dropping collection", sev, "k2db.drop").setSensitive({
+                op: "drop",
+                collection: collectionName,
+                scope,
+                normalizedScope,
+                mongo: normaliseMongoError(err),
+            });
+            emitDbError(k2, {
+                op: "drop",
+                collection: collectionName,
+            });
+            throw k2;
         }
     }
     /**

package/package.json

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