underpost 2.8.84 → 2.8.86

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}`);
   }
 };
 

package/docker-compose.yml

@@ -1,67 +0,0 @@
-# https://docs.docker.com/compose/compose-file/compose-file-v3
-# https://docs.docker.com/engine/reference/commandline/compose/
-version: '3'
-services:
-  prometheus:
-    image: prom/prometheus
-    ports:
-      - 9090:9090
-    volumes:
-      - ./prometheus_data:/prometheus
-      - ./prometheus.yml:/etc/prometheus/prometheus.yml
-    command:
-      - '--config.file=/etc/prometheus/prometheus.yml'
-    networks:
-      - load-balancer
-
-  grafana:
-    image: grafana/grafana
-    ports:
-      - 3000:3000
-    volumes:
-      - ./grafana_data:/var/lib/grafana
-    #  - ./grafana.ini:/etc/grafana/grafana.ini
-    networks:
-      - load-balancer
-    depends_on:
-      - prometheus
-
-  underpost-engine:
-    build:
-      dockerfile: ./Dockerfile
-      context: . # workdir path
-    # image: underpost-engine
-    # container_name: <name> ignore for replicas
-    ports:
-      - '22'
-      - '80' # host port allocated dynamically, host ports are unique independent of replicas
-      - '443'
-      - '3306'
-      - '27017'
-      - '4001-4002:3001'
-      - '3002-3020'
-    volumes:
-      - ./logs:/code/logs
-    deploy:
-      mode: replicated
-      replicas: 2
-      restart_policy:
-        condition: on-failure
-        delay: 5s
-        max_attempts: 3
-        window: 120s
-      resources:
-        limits:
-          cpus: '2'
-          memory: 400M
-        reservations:
-          cpus: '0.25'
-          memory: 20M
-    labels: # labels in Compose file instead of Dockerfile
-      engine.version: '2.8.84'
-    networks:
-      - load-balancer
-
-networks:
-  load-balancer:
-    driver: bridge

package/prometheus.yml

@@ -1,36 +0,0 @@
-# my global config
-global:
-  scrape_interval: 5s # Set the scrape interval to every 15 seconds. Default is every 1 minute.
-  evaluation_interval: 5s # Evaluate rules every 15 seconds. The default is every 1 minute.
-  # scrape_timeout is set to the global default (10s).
-
-# Alertmanager configuration
-alerting:
-  alertmanagers:
-    - static_configs:
-        - targets:
-          # - alertmanager:9093
-
-# Load rules once and periodically evaluate them according to the global 'evaluation_interval'.
-rule_files:
-  # - "first_rules.yml"
-  # - "second_rules.yml"
-
-# A scrape configuration containing exactly one endpoint to scrape:
-# Here it's Prometheus itself.
-scrape_configs:
-  # The job name is added as a label `job=<job_name>` to any timeseries scraped from this config.
-  - job_name: 'prometheus_service'
-
-    # metrics_path defaults to '/metrics'
-    # scheme defaults to 'http'.
-
-    static_configs:
-      - targets: ['host.docker.internal:9090']
-
-  - job_name: 'nodejs_service'
-    static_configs:
-      - targets: ['host.docker.internal:4001', 'host.docker.internal:4002']
-      # - targets: ['localhost:4001', 'localhost:4002']
-      # - targets: ["host.docker.internal:3002"] # Windows
-      # - targets: ["docker.for.mac.localhost:9090"] # macOs