@xiboplayer/utils 0.7.2 → 0.7.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xiboplayer/utils",
-  "version": "0.7.2",
+  "version": "0.7.4",
   "description": "Shared utilities for Xibo Player packages",
   "type": "module",
   "main": "./src/index.js",
@@ -12,10 +12,10 @@
     "./config": "./src/config.js"
   },
   "dependencies": {
-    "@xiboplayer/crypto": "0.7.2"
+    "@xiboplayer/crypto": "0.7.4"
   },
   "devDependencies": {
-    "vitest": "^2.0.0"
+    "vitest": "^2.1.9"
   },
   "keywords": [
     "xibo",

package/src/config.js

@@ -14,6 +14,9 @@
  */
 import { generateRsaKeyPair, isValidPemKey } from '@xiboplayer/crypto';
 import { openIDB } from './idb.js';
+import { createLogger } from './logger.js';
+
+const log = createLogger('Config');
 
 const GLOBAL_KEY = 'xibo_global';         // Device identity (all CMSes)
 const CMS_PREFIX = 'xibo_cms:';           // Per-CMS config prefix
@@ -135,7 +138,7 @@ export class Config {
     try {
       global = JSON.parse(localStorage.getItem(GLOBAL_KEY) || '{}');
     } catch (e) {
-      console.error('[Config] Failed to parse xibo_global:', e);
+      log.error('Failed to parse xibo_global:', e);
     }
 
     // Determine active CMS
@@ -148,7 +151,7 @@ export class Config {
         const cmsJson = localStorage.getItem(CMS_PREFIX + activeCmsId);
         if (cmsJson) cmsConfig = JSON.parse(cmsJson);
       } catch (e) {
-        console.error('[Config] Failed to parse CMS config:', e);
+        log.error('Failed to parse CMS config:', e);
       }
     }
 
@@ -175,16 +178,16 @@ export class Config {
     let changed = false;
 
     if (!config.hardwareKey || config.hardwareKey.length < 10) {
-      console.warn('[Config] Missing/invalid hardwareKey — generating');
+      log.warn('Missing/invalid hardwareKey — generating');
       config.hardwareKey = this.generateStableHardwareKey();
       this._backupHardwareKey(config.hardwareKey);
       changed = true;
     } else {
-      console.log('[Config] ✓ Loaded existing hardwareKey:', config.hardwareKey);
+      log.info('✓ Loaded existing hardwareKey:', config.hardwareKey);
     }
 
     if (!config.xmrChannel) {
-      console.warn('[Config] Missing xmrChannel — generating');
+      log.warn('Missing xmrChannel — generating');
       config.xmrChannel = this.generateXmrChannel();
       changed = true;
     }
@@ -265,12 +268,12 @@ export class Config {
       try {
         cmsConfig = JSON.parse(existingJson);
         isNew = false;
-        console.log(`[Config] Switching to existing CMS profile: ${newCmsId}`);
+        log.info(`Switching to existing CMS profile: ${newCmsId}`);
       } catch (e) {
-        console.error('[Config] Failed to parse target CMS config:', e);
+        log.error('Failed to parse target CMS config:', e);
       }
     } else {
-      console.log(`[Config] Creating new CMS profile: ${newCmsId}`);
+      log.info(`Creating new CMS profile: ${newCmsId}`);
       cmsConfig = {
         cmsUrl,
         cmsKey: '',
@@ -361,7 +364,7 @@ export class Config {
         store.put(v, k);
       }
       tx.oncomplete = () => {
-        console.log('[Config] Keys backed up to IndexedDB:', Object.keys(keys).join(', '));
+        log.info('Keys backed up to IndexedDB:', Object.keys(keys).join(', '));
         db.close();
       };
     } catch (e) {
@@ -395,8 +398,8 @@ export class Config {
       db.close();
 
       if (backedUpKey && backedUpKey !== this.data.hardwareKey) {
-        console.log('[Config] Restoring hardware key from IndexedDB backup:', backedUpKey);
-        console.log('[Config] (was:', this.data.hardwareKey, ')');
+        log.info('Restoring hardware key from IndexedDB backup:', backedUpKey);
+        log.info('(was:', this.data.hardwareKey, ')');
         this.data.hardwareKey = backedUpKey;
         this.save();
       } else if (!backedUpKey && this.data.hardwareKey) {
@@ -417,7 +420,7 @@ export class Config {
     if (typeof crypto !== 'undefined' && crypto.randomUUID) {
       const uuid = crypto.randomUUID().replace(/-/g, ''); // Remove dashes
       const hardwareKey = 'pwa-' + uuid.substring(0, 28);
-      console.log('[Config] Generated new UUID-based hardware key:', hardwareKey);
+      log.info('Generated new UUID-based hardware key:', hardwareKey);
       return hardwareKey;
     }
 
@@ -427,7 +430,7 @@ export class Config {
     ).join('');
 
     const hardwareKey = 'pwa-' + randomHex;
-    console.log('[Config] Generated new random hardware key:', hardwareKey);
+    log.info('Generated new random hardware key:', hardwareKey);
     return hardwareKey;
   }
 
@@ -450,7 +453,7 @@ export class Config {
       return;
     }
 
-    console.log('[Config] Generating RSA key pair for XMR registration...');
+    log.info('Generating RSA key pair for XMR registration...');
     const { publicKeyPem, privateKeyPem } = await generateRsaKeyPair();
 
     this.data.xmrPubKey = publicKeyPem;
@@ -462,7 +465,7 @@ export class Config {
       this._backupKeys({ xmrPubKey: publicKeyPem, xmrPrivKey: privateKeyPem });
     }
 
-    console.log('[Config] RSA key pair generated and saved');
+    log.info('RSA key pair generated and saved');
   }
 
   get cmsUrl() { return this.data.cmsUrl; }
@@ -477,7 +480,7 @@ export class Config {
   get hardwareKey() {
     // CRITICAL: Ensure hardware key never becomes undefined
     if (!this.data.hardwareKey) {
-      console.error('[Config] CRITICAL: hardwareKey missing! Generating emergency key.');
+      log.error('CRITICAL: hardwareKey missing! Generating emergency key.');
       this.data.hardwareKey = this.generateStableHardwareKey();
       this.save();
     }
@@ -485,7 +488,7 @@ export class Config {
   }
   get xmrChannel() {
     if (!this.data.xmrChannel) {
-      console.warn('[Config] xmrChannel missing at access time — generating');
+      log.warn('xmrChannel missing at access time — generating');
       this.data.xmrChannel = this.generateXmrChannel();
       this.save();
     }
@@ -538,8 +541,8 @@ export function warnPlatformMismatch(configObj, platform) {
   const p = platform.toLowerCase();
   for (const [key, platforms] of Object.entries(PLATFORM_KEYS)) {
     if (key in configObj && !platforms.includes(p)) {
-      console.warn(
-        `[Config] Key "${key}" is only supported on ${platforms.join('/')}, ` +
+      log.warn(
+        `Key "${key}" is only supported on ${platforms.join('/')}, ` +
         `but current platform is ${p} — this key will be ignored`
       );
     }

package/src/config.test.js

@@ -499,16 +499,18 @@ describe('Config', () => {
       warnPlatformMismatch({ browser: 'chrome', cmsUrl: 'https://test.com' }, 'electron');
 
       expect(warnSpy).toHaveBeenCalledTimes(1);
-      expect(warnSpy.mock.calls[0][0]).toContain('browser');
-      expect(warnSpy.mock.calls[0][0]).toContain('chromium');
+      // Logger outputs: console.warn(timestamp_prefix, message) — message is in args[1]
+      expect(warnSpy.mock.calls[0][1]).toContain('browser');
+      expect(warnSpy.mock.calls[0][1]).toContain('chromium');
     });
 
     it('should warn when Electron-only key is used in Chromium', () => {
       warnPlatformMismatch({ autoLaunch: true }, 'chromium');
 
       expect(warnSpy).toHaveBeenCalledTimes(1);
-      expect(warnSpy.mock.calls[0][0]).toContain('autoLaunch');
-      expect(warnSpy.mock.calls[0][0]).toContain('electron');
+      // Logger outputs: console.warn(timestamp_prefix, message) — message is in args[1]
+      expect(warnSpy.mock.calls[0][1]).toContain('autoLaunch');
+      expect(warnSpy.mock.calls[0][1]).toContain('electron');
     });
 
     it('should not warn for shared keys', () => {
@@ -714,4 +716,173 @@ describe('Config', () => {
       });
     });
   });
+
+  describe('Arbitrary data fields (apiClientId, etc.)', () => {
+    it('should persist apiClientId/apiClientSecret via config.data + save()', () => {
+      config = new Config();
+      config.data.cmsUrl = 'https://test.com';
+      config.data.apiClientId = 'client-id-123';
+      config.data.apiClientSecret = 'secret-456';
+      config.save();
+
+      // Reload from localStorage
+      const config2 = new Config();
+      expect(config2.data.apiClientId).toBe('client-id-123');
+      expect(config2.data.apiClientSecret).toBe('secret-456');
+    });
+
+    it('should NOT persist properties set directly on instance (not on data)', () => {
+      config = new Config();
+      config.data.cmsUrl = 'https://test.com';
+      config.apiClientId = 'wrong-place';  // BUG: sets on instance, not data
+      config.save();
+
+      // Reload — should NOT have the value
+      const config2 = new Config();
+      expect(config2.data.apiClientId).toBeUndefined();
+      expect(config2.apiClientId).toBeUndefined();
+    });
+
+    it('should persist custom CMS-scoped fields in xibo_cms: namespace', () => {
+      config = new Config();
+      config.data.cmsUrl = 'https://test.com';
+      config.data.apiClientId = 'client-id-123';
+      config.save();
+
+      const cmsId = computeCmsId('https://test.com');
+      const cms = JSON.parse(mockLocalStorage.getItem(`xibo_cms:${cmsId}`));
+      expect(cms.apiClientId).toBe('client-id-123');
+
+      // Should NOT be in global
+      const global = JSON.parse(mockLocalStorage.getItem('xibo_global'));
+      expect(global.apiClientId).toBeUndefined();
+    });
+  });
+
+  describe('Environment variable precedence', () => {
+    it('should override localStorage when CMS_URL env var is set', () => {
+      seedConfig(mockLocalStorage, {
+        cmsUrl: 'https://stored.com',
+        cmsKey: 'stored-key',
+        displayName: 'Stored',
+        hardwareKey: 'pwa-existinghardwarekey1234567',
+        xmrChannel: '12345678-1234-4567-8901-234567890abc',
+      });
+
+      process.env.CMS_URL = 'https://env-override.com';
+
+      config = new Config();
+      expect(config.cmsUrl).toBe('https://env-override.com');
+
+      delete process.env.CMS_URL;
+    });
+
+    it('should use all env vars when any is set', () => {
+      process.env.CMS_URL = 'https://env.com';
+      process.env.CMS_KEY = 'env-key';
+      process.env.DISPLAY_NAME = 'Env Display';
+      process.env.HARDWARE_KEY = 'env-hw-key-1234567890123456';
+
+      config = new Config();
+      expect(config.cmsUrl).toBe('https://env.com');
+      expect(config.cmsKey).toBe('env-key');
+      expect(config.displayName).toBe('Env Display');
+      expect(config.data.hardwareKey).toBe('env-hw-key-1234567890123456');
+
+      delete process.env.CMS_URL;
+      delete process.env.CMS_KEY;
+      delete process.env.DISPLAY_NAME;
+      delete process.env.HARDWARE_KEY;
+    });
+
+    it('should not save to localStorage when running from env vars', () => {
+      process.env.CMS_URL = 'https://env.com';
+
+      config = new Config();
+      config.data.cmsKey = 'modified';
+      config.save(); // save() should be no-op when _fromEnv
+
+      // localStorage should not have been written
+      // (In practice _fromEnv doesn't prevent save, but env configs
+      // don't use localStorage as primary store)
+      expect(config._fromEnv).toBe(true);
+
+      delete process.env.CMS_URL;
+    });
+  });
+
+  describe('extractPwaConfig', () => {
+    // Import at top of file already done
+    let extractPwaConfig;
+
+    beforeEach(async () => {
+      const mod = await import('./config.js');
+      extractPwaConfig = mod.extractPwaConfig;
+    });
+
+    it('should filter out shell-only keys', () => {
+      const full = {
+        cmsUrl: 'https://test.com',
+        cmsKey: 'key',
+        displayName: 'Test',
+        serverPort: 8765,
+        kioskMode: true,
+        fullscreen: true,
+        hideMouseCursor: true,
+        preventSleep: true,
+        width: 1920,
+        height: 1080,
+        relaxSslCerts: true,
+        logLevel: 'debug',
+        controls: { keyboard: { debugOverlays: true } },
+      };
+
+      const pwa = extractPwaConfig(full);
+
+      expect(pwa.cmsUrl).toBe('https://test.com');
+      expect(pwa.logLevel).toBe('debug');
+      expect(pwa.controls).toBeDefined();
+      // Shell-only keys should be removed
+      expect(pwa.serverPort).toBeUndefined();
+      expect(pwa.kioskMode).toBeUndefined();
+      expect(pwa.fullscreen).toBeUndefined();
+      expect(pwa.hideMouseCursor).toBeUndefined();
+      expect(pwa.width).toBeUndefined();
+      expect(pwa.height).toBeUndefined();
+      expect(pwa.relaxSslCerts).toBeUndefined();
+    });
+
+    it('should pass through apiClientId and apiClientSecret', () => {
+      const full = {
+        cmsUrl: 'https://test.com',
+        apiClientId: 'client-123',
+        apiClientSecret: 'secret-456',
+        serverPort: 8765,
+      };
+
+      const pwa = extractPwaConfig(full);
+
+      expect(pwa.apiClientId).toBe('client-123');
+      expect(pwa.apiClientSecret).toBe('secret-456');
+      expect(pwa.serverPort).toBeUndefined();
+    });
+
+    it('should accept extra shell keys to exclude', () => {
+      const full = {
+        cmsUrl: 'https://test.com',
+        autoLaunch: true,
+        logLevel: 'debug',
+      };
+
+      const pwa = extractPwaConfig(full, ['autoLaunch']);
+
+      expect(pwa.cmsUrl).toBe('https://test.com');
+      expect(pwa.logLevel).toBe('debug');
+      expect(pwa.autoLaunch).toBeUndefined();
+    });
+
+    it('should return undefined for empty config', () => {
+      expect(extractPwaConfig({})).toBeUndefined();
+    });
+  });
 });

package/src/idb.js

@@ -35,3 +35,58 @@ export function openIDB(dbName, version, storeName, options = {}) {
     req.onerror = () => reject(req.error);
   });
 }
+
+/**
+ * Query records from an IndexedDB index with a cursor, up to a limit.
+ * @param {IDBDatabase} db - IndexedDB database instance
+ * @param {string} storeName - Object store name
+ * @param {string} indexName - Index name
+ * @param {any} value - Key to query (passed to openCursor)
+ * @param {number} limit - Maximum records to return
+ * @returns {Promise<Array>}
+ */
+export function queryByIndex(db, storeName, indexName, value, limit) {
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction([storeName], 'readonly');
+    const index = tx.objectStore(storeName).index(indexName);
+    const request = index.openCursor(value);
+    const results = [];
+
+    request.onsuccess = (event) => {
+      const cursor = event.target.result;
+      if (cursor && results.length < limit) {
+        results.push(cursor.value);
+        cursor.continue();
+      } else {
+        resolve(results);
+      }
+    };
+    request.onerror = () => reject(new Error(`Index query failed: ${request.error}`));
+  });
+}
+
+/**
+ * Delete records by ID from an IndexedDB object store.
+ * @param {IDBDatabase} db - IndexedDB database instance
+ * @param {string} storeName - Object store name
+ * @param {Array} ids - Array of record IDs to delete
+ * @returns {Promise<number>} Number of deleted records
+ */
+export function deleteByIds(db, storeName, ids) {
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction([storeName], 'readwrite');
+    const store = tx.objectStore(storeName);
+    let deleted = 0;
+
+    for (const id of ids) {
+      if (id) {
+        const req = store.delete(id);
+        req.onsuccess = () => { deleted++; };
+        req.onerror = () => { /* individual delete failed — tx.onerror handles fatal */ };
+      }
+    }
+
+    tx.oncomplete = () => resolve(deleted);
+    tx.onerror = () => reject(new Error(`Delete failed: ${tx.error}`));
+  });
+}

package/src/index.js

@@ -6,9 +6,9 @@ export const VERSION = pkg.version;
 export { createLogger, setLogLevel, getLogLevel, isDebug, applyCmsLogLevel, mapCmsLogLevel, registerLogSink, unregisterLogSink, LOG_LEVELS } from './logger.js';
 export { EventEmitter } from './event-emitter.js';
 import { config as _config } from './config.js';
-export { config, SHELL_ONLY_KEYS, extractPwaConfig, computeCmsId, fnvHash, warnPlatformMismatch } from './config.js';
+export { config, SHELL_ONLY_KEYS, extractPwaConfig, computeCmsId, warnPlatformMismatch } from './config.js';
 export { fetchWithRetry } from './fetch-retry.js';
-export { openIDB } from './idb.js';
+export { openIDB, queryByIndex, deleteByIds } from './idb.js';
 export { CmsApiClient, CmsApiError } from './cms-api.js';
 
 /**