underpost 2.8.843 → 2.8.845

package/src/server/valkey.js

@@ -5,22 +5,71 @@ import { loggerFactory } from './logger.js';
 
 const logger = loggerFactory(import.meta);
 
+// Per-instance registries keyed by `${host}${path}`
 const ValkeyInstances = {};
+const DummyStores = {}; // in-memory Maps per instance
+const ValkeyStatus = {}; // 'connected' | 'dummy' | 'error' | undefined
 
-let valkeyEnabled = true;
+// Backward-compatible overall flag: true if any instance is connected
+const isValkeyEnable = () => Object.values(ValkeyStatus).some((s) => s === 'connected');
 
-const disableValkeyErrorMessage = 'valkey is not enabled';
-
-const isValkeyEnable = () => valkeyEnabled;
+const _instanceKey = (opts = { host: '', path: '' }) => `${opts.host || ''}${opts.path || ''}`;
 
 const createValkeyConnection = async (
-  instance = { host: '', port: 0 },
-  valkeyServerConnectionOptions = { host: '', port: 0 },
+  instance = { host: '', path: '' },
+  valkeyServerConnectionOptions = { host: '', path: '' },
 ) => {
-  ValkeyInstances[`${instance.host}${instance.path}`] = await ValkeyAPI.valkeyClientFactory(
-    valkeyServerConnectionOptions,
-  );
-  return ValkeyInstances[`${instance.host}${instance.path}`];
+  const key = _instanceKey(instance);
+  // Initialize dummy store for the instance
+  if (!DummyStores[key]) DummyStores[key] = new Map();
+
+  try {
+    const client = await ValkeyAPI.valkeyClientFactory(valkeyServerConnectionOptions);
+
+    // Attach listeners for visibility
+    client.on?.('ready', () => {
+      ValkeyStatus[key] = 'connected';
+      logger.info('Valkey connected', { instance, status: ValkeyStatus[key] });
+    });
+    client.on?.('error', (err) => {
+      // Switch to dummy if not yet connected
+      if (ValkeyStatus[key] !== 'connected') {
+        ValkeyStatus[key] = 'dummy';
+      } else {
+        ValkeyStatus[key] = 'error';
+      }
+      logger.warn('Valkey error', { err: err?.message, instance, status: ValkeyStatus[key] });
+    });
+    client.on?.('end', () => {
+      if (ValkeyStatus[key] !== 'dummy') ValkeyStatus[key] = 'error';
+      logger.warn('Valkey connection ended', { instance, status: ValkeyStatus[key] });
+    });
+
+    // Probe connectivity with a short timeout
+    const probe = async () => {
+      try {
+        // basic ping via SET/GET roundtrip
+        const probeKey = `__vk_probe_${Date.now()}`;
+        await client.set(probeKey, '1');
+        await client.get(probeKey);
+        ValkeyStatus[key] = 'connected';
+      } catch (e) {
+        ValkeyStatus[key] = 'dummy';
+        logger.warn('Valkey probe failed, falling back to dummy', { instance, error: e?.message });
+      }
+    };
+
+    // Race with timeout to avoid hanging
+    await Promise.race([probe(), new Promise((resolve) => setTimeout(resolve, 1000))]);
+
+    ValkeyInstances[key] = client;
+    if (!ValkeyStatus[key]) ValkeyStatus[key] = 'dummy';
+  } catch (err) {
+    ValkeyStatus[key] = 'dummy';
+    logger.warn('Valkey client creation failed, using dummy', { instance, error: err?.message });
+  }
+
+  return ValkeyInstances[key];
 };
 
 const selectDtoFactory = (payload, select) => {
@@ -33,18 +82,12 @@ const selectDtoFactory = (payload, select) => {
 
 const valkeyClientFactory = async (options) => {
   const valkey = new Valkey({
-    // port: 6379,
-    // host: 'valkey-service.default.svc.cluster.local',
     port: options?.port ? options.port : undefined,
     host: options?.host ? options.host : undefined,
+    // Keep retry strategy minimal; state handled in createValkeyConnection
     retryStrategy: (attempt) => {
-      if (attempt === 1) {
-        valkey.disconnect();
-        valkeyEnabled = false;
-        logger.warn('Valkey service not enabled', { ...options, valkeyEnabled });
-        return;
-      }
-      return 1000; // 1 second interval attempt
+      if (attempt === 1) return undefined; // stop aggressive retries early
+      return 1000; // retry interval if library continues
     },
   }); // Connect to 127.0.0.1:6379
   // new Valkey(6380); // 127.0.0.1:6380
@@ -60,34 +103,52 @@ const valkeyClientFactory = async (options) => {
   return valkey;
 };
 
-const getValkeyObject = async (options = { host: '', port: 0 }, key = '') => {
-  if (!valkeyEnabled) {
-    logger.warn(disableValkeyErrorMessage + ' get', key);
-    return null;
-  }
-  const object = await ValkeyInstances[`${options.host}${options.path}`].get(key);
+const getValkeyObject = async (options = { host: '', path: '' }, key = '') => {
+  const k = _instanceKey(options);
+  const status = ValkeyStatus[k];
   try {
-    return JSON.parse(object);
-  } catch (error) {
-    logger.error(error);
-    return object;
+    if (status === 'connected' && ValkeyInstances[k]) {
+      const value = await ValkeyInstances[k].get(key);
+      if (value == null) return null;
+      try {
+        return JSON.parse(value);
+      } catch {
+        // not JSON, return raw string
+        return value;
+      }
+    }
+  } catch (err) {
+    logger.warn('Valkey get failed, using dummy', { key, err: err?.message });
   }
+  // Dummy fallback returns stored value as-is (string or object)
+  return DummyStores[k]?.get(key) ?? null;
 };
 
-const setValkeyObject = async (options = { host: '', port: 0 }, key = '', payload = {}) => {
-  if (!valkeyEnabled) throw new Error(disableValkeyErrorMessage);
-  return await ValkeyInstances[`${options.host}${options.path}`].set(key, JSON.stringify(payload));
+const setValkeyObject = async (options = { host: '', path: '' }, key = '', payload = {}) => {
+  const k = _instanceKey(options);
+  const isString = typeof payload === 'string';
+  const value = isString ? payload : JSON.stringify(payload);
+  try {
+    if (ValkeyStatus[k] === 'connected' && ValkeyInstances[k]) {
+      return await ValkeyInstances[k].set(key, value);
+    }
+  } catch (err) {
+    logger.warn('Valkey set failed, writing to dummy', { key, err: err?.message });
+  }
+  if (!DummyStores[k]) DummyStores[k] = new Map();
+  // Store raw string or object accordingly
+  DummyStores[k].set(key, isString ? payload : payload);
+  return 'OK';
 };
 
-const updateValkeyObject = async (options = { host: '', port: 0 }, key = '', payload = {}) => {
-  if (!valkeyEnabled) throw new Error(disableValkeyErrorMessage);
-  const object = await getValkeyObject(key);
-  object.updatedAt = new Date().toISOString();
-  return await ValkeyInstances[`${options.host}${options.path}`].set(key, JSON.stringify({ ...object, ...payload }));
+const updateValkeyObject = async (options = { host: '', path: '' }, key = '', payload = {}) => {
+  let base = await getValkeyObject(options, key);
+  if (typeof base !== 'object' || base === null) base = {};
+  base.updatedAt = new Date().toISOString();
+  return await setValkeyObject(options, key, { ...base, ...payload });
 };
 
-const valkeyObjectFactory = async (options = { host: 'localhost', object: {} }, module = '') => {
-  if (!valkeyEnabled) throw new Error(disableValkeyErrorMessage);
+const valkeyObjectFactory = async (options = { host: 'localhost', object: {} }, model = '') => {
   const idoDate = new Date().toISOString();
   options.object = options.object || {};
   const { object } = options;
@@ -95,7 +156,7 @@ const valkeyObjectFactory = async (options = { host: 'localhost', object: {} },
   object._id = _id;
   object.createdAt = idoDate;
   object.updatedAt = idoDate;
-  switch (module) {
+  switch (model) {
     case 'user': {
       const role = 'guest';
       object._id = `${role}${_id}`;
@@ -115,7 +176,7 @@ const valkeyObjectFactory = async (options = { host: 'localhost', object: {} },
       };
     }
     default:
-      throw new Error(`module schema not found: ${module}`);
+      throw new Error(`model schema not found: ${model}`);
   }
 };