@naturalcycles/db-lib 8.33.0 → 8.33.1

package/dist/kv/commonKeyValueDaoMemoCache.d.ts

@@ -1,9 +1,17 @@
 import { AsyncMemoCache } from '@naturalcycles/js-lib';
 import { CommonKeyValueDao } from './commonKeyValueDao';
+/**
+ * AsyncMemoCache implementation, backed by CommonKeyValueDao.
+ *
+ * Does NOT support persisting Errors, skips them instead.
+ *
+ * Also, does not support .clear(), as it's more dangerous than useful to actually
+ * clear the whole table/cache.
+ */
 export declare class CommonKeyValueDaoMemoCache<VALUE = any> implements AsyncMemoCache<string, VALUE> {
     private dao;
     constructor(dao: CommonKeyValueDao<VALUE>);
-    get(k: string): Promise<VALUE | undefined>;
-    set(k: string, v: VALUE): Promise<void>;
+    get(k: string): Promise<VALUE | Error | undefined>;
+    set(k: string, v: VALUE | Error): Promise<void>;
     clear(): Promise<void>;
 }

package/dist/kv/commonKeyValueDaoMemoCache.js

@@ -1,6 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommonKeyValueDaoMemoCache = void 0;
+/**
+ * AsyncMemoCache implementation, backed by CommonKeyValueDao.
+ *
+ * Does NOT support persisting Errors, skips them instead.
+ *
+ * Also, does not support .clear(), as it's more dangerous than useful to actually
+ * clear the whole table/cache.
+ */
 class CommonKeyValueDaoMemoCache {
     constructor(dao) {
         this.dao = dao;
@@ -9,10 +17,14 @@ class CommonKeyValueDaoMemoCache {
         return (await this.dao.getById(k)) || undefined;
     }
     async set(k, v) {
+        if (v instanceof Error) {
+            // We currently don't persist errors there
+            return;
+        }
         await this.dao.save(k, v);
     }
     async clear() {
-        throw new Error('CommonKeyValueDaoCacheFactory.clear is not supported, because cache is expected to be persistent');
+        throw new Error('CommonKeyValueDaoMemoCache.clear is not supported, because cache is expected to be persistent');
     }
 }
 exports.CommonKeyValueDaoMemoCache = CommonKeyValueDaoMemoCache;

package/package.json

@@ -43,7 +43,7 @@
   "engines": {
     "node": ">=14.15"
   },
-  "version": "8.33.0",
+  "version": "8.33.1",
   "description": "Lowest Common Denominator API to supported Databases",
   "keywords": [
     "db",

package/src/kv/commonKeyValueDaoMemoCache.ts

@@ -1,20 +1,33 @@
 import { AsyncMemoCache } from '@naturalcycles/js-lib'
 import { CommonKeyValueDao } from './commonKeyValueDao'
 
+/**
+ * AsyncMemoCache implementation, backed by CommonKeyValueDao.
+ *
+ * Does NOT support persisting Errors, skips them instead.
+ *
+ * Also, does not support .clear(), as it's more dangerous than useful to actually
+ * clear the whole table/cache.
+ */
 export class CommonKeyValueDaoMemoCache<VALUE = any> implements AsyncMemoCache<string, VALUE> {
   constructor(private dao: CommonKeyValueDao<VALUE>) {}
 
-  async get(k: string): Promise<VALUE | undefined> {
+  async get(k: string): Promise<VALUE | Error | undefined> {
     return (await this.dao.getById(k)) || undefined
   }
 
-  async set(k: string, v: VALUE): Promise<void> {
+  async set(k: string, v: VALUE | Error): Promise<void> {
+    if (v instanceof Error) {
+      // We currently don't persist errors there
+      return
+    }
+
     await this.dao.save(k, v)
   }
 
   async clear(): Promise<void> {
     throw new Error(
-      'CommonKeyValueDaoCacheFactory.clear is not supported, because cache is expected to be persistent',
+      'CommonKeyValueDaoMemoCache.clear is not supported, because cache is expected to be persistent',
     )
   }
 }