@naturalcycles/db-lib 9.9.0 → 9.9.2

package/dist/commondao/common.dao.js

@@ -494,23 +494,29 @@ class CommonDao {
             return await this.patchInTransaction(bm, patch, opt);
         }
         if (opt.skipDBRead) {
-            const bmBefore = (0, js_lib_1._deepCopy)(bm);
-            Object.assign(bm, patch);
-            if ((0, js_lib_1._deepJsonEquals)(bm, bmBefore)) {
+            const patched = {
+                ...bm,
+                ...patch,
+            };
+            if ((0, js_lib_1._deepJsonEquals)(bm, patched)) {
                 // Skipping the save operation, as data is the same
                 return bm;
             }
+            Object.assign(bm, patch);
         }
         else {
             const loaded = await this.getById(bm.id, opt);
             if (loaded) {
-                Object.assign(loaded, patch);
-                if ((0, js_lib_1._deepJsonEquals)(loaded, bm)) {
+                const loadedWithPatch = {
+                    ...loaded,
+                    ...patch,
+                };
+                // Make `bm` exactly the same as `loadedWithPatch`
+                (0, js_lib_1._objectAssignExact)(bm, loadedWithPatch);
+                if ((0, js_lib_1._deepJsonEquals)(loaded, loadedWithPatch)) {
                     // Skipping the save operation, as data is the same
                     return bm;
                 }
-                // Make `bm` exactly the same as `loaded`
-                (0, js_lib_1._objectAssignExact)(bm, loaded);
             }
             else {
                 Object.assign(bm, patch);

package/dist/kv/commonKeyValueDaoMemoCache.d.ts

@@ -1,4 +1,4 @@
-import { AsyncMemoCache } from '@naturalcycles/js-lib';
+import { AsyncMemoCache, MISS } from '@naturalcycles/js-lib';
 import { CommonKeyValueDao } from './commonKeyValueDao';
 /**
  * AsyncMemoCache implementation, backed by CommonKeyValueDao.
@@ -11,7 +11,7 @@ import { CommonKeyValueDao } from './commonKeyValueDao';
 export declare class CommonKeyValueDaoMemoCache<VALUE = any> implements AsyncMemoCache<string, VALUE> {
     private dao;
     constructor(dao: CommonKeyValueDao<VALUE>);
-    get(k: string): Promise<VALUE | Error | undefined>;
-    set(k: string, v: VALUE | Error): Promise<void>;
+    get(k: string): Promise<VALUE | typeof MISS>;
+    set(k: string, v: VALUE): Promise<void>;
     clear(): Promise<void>;
 }

package/dist/kv/commonKeyValueDaoMemoCache.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommonKeyValueDaoMemoCache = void 0;
+const js_lib_1 = require("@naturalcycles/js-lib");
 /**
  * AsyncMemoCache implementation, backed by CommonKeyValueDao.
  *
@@ -14,13 +15,9 @@ class CommonKeyValueDaoMemoCache {
         this.dao = dao;
     }
     async get(k) {
-        return (await this.dao.getById(k)) || undefined;
+        return (await this.dao.getById(k)) || js_lib_1.MISS;
     }
     async set(k, v) {
-        if (v instanceof Error) {
-            // We currently don't persist errors there
-            return;
-        }
         await this.dao.save(k, v);
     }
     async clear() {

package/package.json

@@ -40,7 +40,7 @@
   "engines": {
     "node": ">=18.12"
   },
-  "version": "9.9.0",
+  "version": "9.9.2",
   "description": "Lowest Common Denominator API to supported Databases",
   "keywords": [
     "db",

package/src/commondao/common.dao.ts

@@ -669,25 +669,32 @@ export class CommonDao<BM extends BaseDBEntity, DBM extends BaseDBEntity = BM> {
     }
 
     if (opt.skipDBRead) {
-      const bmBefore = _deepCopy(bm)
-      Object.assign(bm, patch)
-      if (_deepJsonEquals(bm, bmBefore)) {
+      const patched: BM = {
+        ...bm,
+        ...patch,
+      }
+
+      if (_deepJsonEquals(bm, patched)) {
         // Skipping the save operation, as data is the same
         return bm
       }
+      Object.assign(bm, patch)
     } else {
       const loaded = await this.getById(bm.id, opt)
 
       if (loaded) {
-        Object.assign(loaded, patch)
+        const loadedWithPatch: BM = {
+          ...loaded,
+          ...patch,
+        }
+
+        // Make `bm` exactly the same as `loadedWithPatch`
+        _objectAssignExact(bm, loadedWithPatch)
 
-        if (_deepJsonEquals(loaded, bm)) {
+        if (_deepJsonEquals(loaded, loadedWithPatch)) {
           // Skipping the save operation, as data is the same
           return bm
         }
-
-        // Make `bm` exactly the same as `loaded`
-        _objectAssignExact(bm, loaded)
       } else {
         Object.assign(bm, patch)
       }

package/src/kv/commonKeyValueDaoMemoCache.ts

@@ -1,4 +1,4 @@
-import { AsyncMemoCache } from '@naturalcycles/js-lib'
+import { AsyncMemoCache, MISS } from '@naturalcycles/js-lib'
 import { CommonKeyValueDao } from './commonKeyValueDao'
 
 /**
@@ -12,16 +12,11 @@ import { CommonKeyValueDao } from './commonKeyValueDao'
 export class CommonKeyValueDaoMemoCache<VALUE = any> implements AsyncMemoCache<string, VALUE> {
   constructor(private dao: CommonKeyValueDao<VALUE>) {}
 
-  async get(k: string): Promise<VALUE | Error | undefined> {
-    return (await this.dao.getById(k)) || undefined
+  async get(k: string): Promise<VALUE | typeof MISS> {
+    return (await this.dao.getById(k)) || MISS
   }
 
-  async set(k: string, v: VALUE | Error): Promise<void> {
-    if (v instanceof Error) {
-      // We currently don't persist errors there
-      return
-    }
-
+  async set(k: string, v: VALUE): Promise<void> {
     await this.dao.save(k, v)
   }