@frogfish/k2db 3.0.6 → 3.0.8

package/db.d.ts

@@ -288,7 +288,7 @@ export declare class K2DB {
     private static normalizeCriteriaIds;
     /** Uppercase helper for `_uuid` field supporting operators like $in/$nin/$eq/$ne and arrays. */
     private static normalizeUuidField;
-    /** Lowercase helper for `_owner` field supporting operators like $in/$nin/$eq/$ne and arrays. */
+    /** Trim helper for `_owner` field supporting operators like $in/$nin/$eq/$ne and arrays. */
     private static normalizeOwnerField;
     /** Strip any user-provided fields that start with '_' (reserved). */
     private static stripReservedFields;

package/db.js

@@ -398,7 +398,9 @@ export class K2DB {
             return undefined;
         if (s === "*")
             return "*";
-        return s.toLowerCase();
+        // Scope maps to `_owner` (usually another record's `_uuid`), which is case-sensitive.
+        // Our `_uuid` is UUIDv7 Crockford Base32 (uppercase), so normalize to that form.
+        return K2DB.normalizeId(s);
     }
     /**
      * Apply a scope constraint to criteria for ownership enforcement.
@@ -418,8 +420,13 @@ export class K2DB {
         // If caller already provided _owner in criteria, ensure it matches the scope to avoid ambiguity/bypass.
         if (criteria && typeof criteria === "object" && Object.prototype.hasOwnProperty.call(criteria, "_owner")) {
             const existing = criteria._owner;
-            if (typeof existing === "string" && existing.trim().toLowerCase() !== normalizedScope) {
-                throw new K2Error(ServiceError.BAD_REQUEST, "Conflicting _owner in criteria and provided scope", "sys_mdb_scope_conflict");
+            if (typeof existing === "string") {
+                const ex = existing.trim();
+                // Treat any explicit "*" as mismatched here (caller should omit _owner or set scope="*").
+                const existingNorm = ex === "*" ? "*" : K2DB.normalizeId(ex);
+                if (existingNorm !== normalizedScope) {
+                    throw new K2Error(ServiceError.BAD_REQUEST, "Conflicting _owner in criteria and provided scope", "sys_mdb_scope_conflict");
+                }
             }
             // If it matches (or is non-string), prefer the explicit scope value.
         }
@@ -457,7 +464,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 +563,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 +584,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 +680,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 +695,12 @@ export class K2DB {
                 projectionPreview: redactShallowSecrets(projection),
                 mongo: normaliseMongoError(err),
             });
+            k2.setSensitive?.(mergedSensitive);
+            emitDbError(k2, {
+                op: "findOne",
+                collection: collectionName,
+            });
+            throw k2;
         }
     }
     /**
@@ -720,7 +781,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 +797,13 @@ export class K2DB {
                 projectionPreview: redactShallowSecrets(projection),
                 mongo: normaliseMongoError(err),
             });
+            emitDbError(k2, {
+                op: "find",
+                collection: collectionName,
+                skip,
+                limit,
+            });
+            throw k2;
         }
     }
     /**
@@ -1351,13 +1419,15 @@ export class K2DB {
         if (typeof owner !== "string") {
             throw new K2Error(ServiceError.BAD_REQUEST, "Owner must be of a string type", "sys_mdb_crv2");
         }
-        const normalizedOwner = owner.trim().toLowerCase();
-        if (!normalizedOwner) {
+        const ownerTrimmed = owner.trim();
+        if (!ownerTrimmed) {
             throw new K2Error(ServiceError.BAD_REQUEST, "Owner must be a non-empty string", "sys_mdb_owner_empty");
         }
-        if (normalizedOwner === "*") {
+        if (ownerTrimmed === "*") {
             throw new K2Error(ServiceError.BAD_REQUEST, "Owner cannot be '*'", "sys_mdb_owner_star");
         }
+        // `_owner` is typically another record's `_uuid` (case-sensitive). Normalize to the canonical ID form.
+        const normalizedOwner = K2DB.normalizeId(ownerTrimmed);
         const collection = await this.getCollection(collectionName);
         const timestamp = Date.now();
         // Generate a new UUIDv7 encoded as Crockford Base32 with hyphens
@@ -1385,7 +1455,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,
@@ -1395,6 +1465,12 @@ export class K2DB {
                 userFieldPreview: redactShallowSecrets(safeData),
                 mongo: normaliseMongoError(err),
             });
+            emitDbError(k2, {
+                op: "create",
+                collection: collectionName,
+                uuid: document._uuid,
+            });
+            throw k2;
         }
     }
     /**
@@ -1438,7 +1514,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,
@@ -1450,6 +1526,11 @@ export class K2DB {
                 valuesPreview: redactShallowSecrets(values),
                 mongo: normaliseMongoError(err),
             });
+            emitDbError(k2, {
+                op: "updateAll",
+                collection: collectionName,
+            });
+            throw k2;
         }
     }
     /**
@@ -1488,6 +1569,11 @@ export class K2DB {
                 }, {});
                 // Merge the preserved fields into the data
                 data = { ...data, ...fieldsToPreserve };
+                // Update _owner if scope is provided
+                const normalizedScope = this.normalizeScope(scope);
+                if (normalizedScope) {
+                    data._owner = normalizedScope;
+                }
                 data._updated = Date.now();
                 // Encrypt secure-prefixed fields at rest (no-op unless encryption is configured)
                 data = this.encryptSecureFieldsDeep(data, `k2db|${collectionName}|${id}`);
@@ -1506,7 +1592,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,
@@ -1517,6 +1603,13 @@ export class K2DB {
                 dataPreview: redactShallowSecrets(data),
                 mongo: normaliseMongoError(err),
             });
+            emitDbError(k2, {
+                op: "update",
+                collection: collectionName,
+                uuid: id,
+                replace,
+            });
+            throw k2;
         }
     }
     /**
@@ -1535,8 +1628,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,
@@ -1544,6 +1636,11 @@ export class K2DB {
                 criteriaPreview: redactShallowSecrets(criteria),
                 mongo: normaliseMongoError(err),
             });
+            emitDbError(k2, {
+                op: "deleteAll",
+                collection: collectionName,
+            });
+            throw k2;
         }
     }
     /**
@@ -1573,14 +1670,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;
         }
     }
     /**
@@ -1641,8 +1743,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);
@@ -1650,7 +1753,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;
         }
     }
     /**
@@ -1672,7 +1791,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;
         }
     }
     /**
@@ -1735,7 +1870,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;
         }
     }
     /**
@@ -1803,12 +1950,12 @@ export class K2DB {
         }
         return val;
     }
-    /** Lowercase helper for `_owner` field supporting operators like $in/$nin/$eq/$ne and arrays. */
+    /** Trim helper for `_owner` field supporting operators like $in/$nin/$eq/$ne and arrays. */
     static normalizeOwnerField(val) {
         if (typeof val === "string")
-            return val.trim().toLowerCase();
+            return val.trim();
         if (Array.isArray(val)) {
-            return val.map((x) => (typeof x === "string" ? x.trim().toLowerCase() : x));
+            return val.map((x) => (typeof x === "string" ? x.trim() : x));
         }
         if (val && typeof val === "object") {
             const out = { ...val };
@@ -1839,7 +1986,7 @@ export class K2DB {
     }
     /** Uppercase incoming IDs for case-insensitive lookups. */
     static normalizeId(id) {
-        return id.toUpperCase();
+        return id.trim();
     }
     /**
      * Run an async DB operation with timing, slow logging, and hooks.

package/package.json

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