@vida-global/core 2.4.3 → 2.4.4

package/lib/activeRecord/baseRecord.js

@@ -401,9 +401,9 @@ class BaseRecord extends Model {
     }
 
 
-    static async cachedIds(key, where, { clear=false }={}) {
+    static async cachedIds(key, where, { clear=false, expireSeconds=null }={}) {
         const pk = this.primaryKeyAttribute;
-        const result = await this.cachedFetch([key], { clear }, async () => {
+        const result = await this.cachedFetch([key], { clear, expireSeconds }, async () => {
             const rows = await this.findAll({ where, attributes: [pk], raw: true});
             return {[key]: rows.map(row => row[pk])};
         });
@@ -412,7 +412,7 @@ class BaseRecord extends Model {
     }
 
 
-    static async cachedFetch(keys, { clear=false }, fetcher) {
+    static async cachedFetch(keys, { clear=false, expireSeconds=null }, fetcher) {
         const client       = await this._getRedisClient();
         const cachedValues = clear ? [] : await client.mGet(keys);
         const kvPairs      = keys.map((key,idx) => {
@@ -429,14 +429,14 @@ class BaseRecord extends Model {
         if (missedKeys.length) {
             this.debugLog('Cache Miss', missedKeys.join(', '));
             fetchedData = await fetcher(missedKeys);
-            await this._cacheFetchedData(fetchedData)
+            await this._cacheFetchedData(fetchedData, { expireSeconds })
         }
 
         return {...cachedData, ...fetchedData};
     }
 
 
-    static async _cacheFetchedData(fetchedData) {
+    static async _cacheFetchedData(fetchedData, { expireSeconds=null }={}) {
         const toCache = {};
 
         for (const [key, value] of Object.entries(fetchedData)) {
@@ -445,7 +445,14 @@ class BaseRecord extends Model {
 
         const client = await this._getRedisClient();
         if (Object.keys(toCache).length) {
-            await client.mSet(toCache);
+            if (expireSeconds) {
+                // mSet cannot carry an expiry, so expiring entries are set one by one.
+                await Promise.all(Object.entries(toCache).map(([key, value]) => {
+                    return client.set(key, value, { EX: expireSeconds });
+                }));
+            } else {
+                await client.mSet(toCache);
+            }
         }
         this.debugLog('Cache Set', Object.keys(fetchedData).join(', '));
     }

package/lib/logger/index.js

@@ -1,4 +1,5 @@
-const   winston                           = require('winston');
+const   util                                   = require('node:util');
+const   winston                                = require('winston');
 const { colorize, combine, printf, timestamp } = winston.format;
 
 
@@ -122,12 +123,25 @@ class Logger {
     }
 
 
-    debug(msg)   { this.#logger.debug(msg) }
-    error(msg)   { this.#logger.error(msg) }
-    info(msg)    { this.#logger.info(msg) }
-    silly(msg)   { this.#logger.silly(msg) }
-    verbose(msg) { this.#logger.verbose(msg) }
-    warn(msg)    { this.#logger.warn(msg) }
+    debug(...args)   { this.#logger.debug(this.formatArguments(args))   }
+    error(...args)   { this.#logger.error(this.formatArguments(args))   }
+    info(...args)    { this.#logger.info(this.formatArguments(args))    }
+    silly(...args)   { this.#logger.silly(this.formatArguments(args))   }
+    verbose(...args) { this.#logger.verbose(this.formatArguments(args)) }
+    warn(...args)    { this.#logger.warn(this.formatArguments(args))    }
+
+
+    // The final winston formatter emits `message` as-is, so an object argument would land as
+    // "[object Object]". `util.formatWithOptions` is what console.log itself uses, so callers get
+    // the same handling of objects, format specifiers, and Errors.
+    formatArguments(args) {
+        return util.formatWithOptions(this.inspectOptions, ...args);
+    }
+
+
+    get inspectOptions() {
+        return { depth: 4, colors: false };
+    }
 
     get _winstonLogger() { 
         this.warn('Directly accessing the underlying winston logger should be avoided unless necessary');

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@vida-global/core",
-    "version": "2.4.3",
+    "version": "2.4.4",
     "description": "Core libraries for supporting Vida development",
     "author": "",
     "license": "ISC",

package/test/activeRecord/baseRecord.test.js

@@ -730,6 +730,14 @@ describe('BaseRecord', () => {
                 expect(Person.findAll).toHaveBeenCalledTimes(1);
                 expect(Person.findAll).toHaveBeenCalledWith({ where, attributes: [pk], raw: true });
             });
+
+            it ('sets the cache entry with an expiry when expireSeconds is passed', async () => {
+                Person.findAll.mockImplementation(() => rows);
+                await Person.cachedIds(key, where, {expireSeconds: 300})
+                expect(redisClient.mSet).not.toHaveBeenCalled();
+                expect(redisClient.set).toHaveBeenCalledTimes(1);
+                expect(redisClient.set).toHaveBeenCalledWith(key, JSON.stringify(ids), {EX: 300});
+            });
         });
 
 
@@ -779,7 +787,7 @@ describe('BaseRecord', () => {
                 await Person.cachedFetch([key1, key2], {}, fetcher);
 
                 expect(cacheSpy).toHaveBeenCalledTimes(1);
-                expect(cacheSpy).toHaveBeenCalledWith(data);
+                expect(cacheSpy).toHaveBeenCalledWith(data, {expireSeconds: null});
             });
 
             it ('returns data from cache hits and misses', async () => {
@@ -841,6 +849,19 @@ describe('BaseRecord', () => {
                 expect(redisClient.mSet).toHaveBeenCalledTimes(1);
                 expect(redisClient.mSet).toHaveBeenCalledWith(cachedData);
             });
+
+            it ('sets each entry with an expiry instead of a multi set when expireSeconds is passed', async () => {
+                const objKey = TestHelpers.Faker.Text.randomString();
+                const objVal = TestHelpers.Faker.Text.randomString();
+                const obj    = {[objKey]: objVal};
+
+                await Person._cacheFetchedData({ [key1]: obj, [key2]: obj }, { expireSeconds: 60 });
+
+                expect(redisClient.mSet).not.toHaveBeenCalled();
+                expect(redisClient.set).toHaveBeenCalledTimes(2);
+                expect(redisClient.set).toHaveBeenCalledWith(key1, JSON.stringify(obj), {EX: 60});
+                expect(redisClient.set).toHaveBeenCalledWith(key2, JSON.stringify(obj), {EX: 60});
+            });
         });
 
 

package/test/activeRecord/helpers/baseRecordMocks.js

@@ -60,6 +60,7 @@ const redisClient = {
     del:          jest.fn(),
     mGet:         jest.fn(),
     mSet:         jest.fn(),
+    set:          jest.fn(),
     connect:      jest.fn(),
     scanIterator: jest.fn(),
 }

package/test/logger/index.test.js

@@ -197,4 +197,81 @@ describe('Logger', () => {
             expect(result[marker]).toEqual('info');
         });
     });
+
+
+    describe('#formatArguments', () => {
+        it ('returns a lone string unchanged', () => {
+            const logger  = new Logger(randomScope());
+            const message = TestHelpers.Faker.Text.randomString();
+
+            expect(logger.formatArguments([message])).toEqual(message);
+        });
+
+        it ('inspects an object instead of stringifying it', () => {
+            const logger = new Logger(randomScope());
+            const value  = TestHelpers.Faker.Math.randomNumber();
+
+            const result = logger.formatArguments([{ count: value }]);
+
+            expect(result).toEqual(`{ count: ${value} }`);
+            expect(result).not.toContain('[object Object]');
+        });
+
+        it ('joins a message and an object the way console.log does', () => {
+            const logger = new Logger(randomScope());
+            const value  = TestHelpers.Faker.Math.randomNumber();
+
+            const result = logger.formatArguments(['totals', { count: value }]);
+
+            expect(result).toEqual(`totals { count: ${value} }`);
+        });
+
+        it ('applies printf style format specifiers', () => {
+            const logger = new Logger(randomScope());
+            const value  = TestHelpers.Faker.Math.randomNumber();
+
+            expect(logger.formatArguments(['count %d', value])).toEqual(`count ${value}`);
+        });
+
+        it ('renders an error with its stack', () => {
+            const logger  = new Logger(randomScope());
+            const message = TestHelpers.Faker.Text.randomString();
+
+            const result = logger.formatArguments([new Error(message)]);
+
+            expect(result).toContain(message);
+            expect(result).toContain('at ');
+        });
+
+        it ('nests objects to the configured depth', () => {
+            const logger = new Logger(randomScope());
+
+            const result = logger.formatArguments([{ a: { b: { c: { d: { e: { f: 1 } } } } } }]);
+
+            expect(result).toContain('e:');
+            expect(result).toContain('[Object]');
+        });
+    });
+
+
+    describe.each([
+        ['debug'],
+        ['error'],
+        ['info'],
+        ['silly'],
+        ['verbose'],
+        ['warn'],
+    ])('#%s', (level) => {
+        it ('formats its arguments before handing them to the transport', () => {
+            const logger = new Logger(randomScope());
+            const spy    = jest.spyOn(logger, 'formatArguments');
+            const value  = TestHelpers.Faker.Math.randomNumber();
+
+            logger[level]('totals', { count: value });
+
+            expect(spy).toHaveBeenCalledTimes(1);
+            expect(spy).toHaveBeenCalledWith(['totals', { count: value }]);
+            spy.mockRestore();
+        });
+    });
 });