underpost 2.8.843 → 2.8.844

package/src/client/components/core/Panel.js

@@ -119,10 +119,11 @@ const Panel = {
         });
         s(`.a-${payload._id}`).onclick = async (e) => {
           e.preventDefault();
+          if (options.onClick) await options.onClick({ payload });
         };
         s(`.container-${idPanel}-${id}`).onclick = async (e) => {
           e.preventDefault();
-          if (options.onClick) await options.onClick({ payload });
+          // if (options.onClick) await options.onClick({ payload });
         };
       });
       if (s(`.${idPanel}-${id}`)) s(`.${idPanel}-${id}`).remove();
@@ -540,7 +541,6 @@ const Panel = {
           background: #f6f6f6;
           color: black;
           padding: 10px;
-          cursor: pointer;
           min-height: 400px;
         }
         .${idPanel}:hover {

package/src/client/components/core/PanelForm.js

@@ -425,7 +425,9 @@ const PanelForm = {
       });
     let firsUpdateEvent = false;
     let lastCid;
+    console.warn('------------->  updatePanel 1');
     this.Data[idPanel].updatePanel = async () => {
+      console.warn('------------->  updatePanel 2');
       const cid = getQueryParams().cid ? getQueryParams().cid : '';
       if (lastCid === cid) return;
       lastCid = cid;

package/src/client/components/core/Recover.js

@@ -62,7 +62,7 @@ const Recover = {
 
     setTimeout(async () => {
       if (user && user.email) {
-        s(`.recover-email`).value = user.email;
+        s(`.recover-email`).value = user.role === 'guest' ? '' : user.email;
         if (user.emailConfirmed) s(`.recover-email`).setAttribute('disabled', '');
       }
 

package/src/index.js

@@ -34,7 +34,7 @@ class Underpost {
    * @type {String}
    * @memberof Underpost
    */
-  static version = 'v2.8.843';
+  static version = 'v2.8.844';
   /**
    * Repository cli API
    * @static

package/src/server/client-build.js

@@ -577,9 +577,6 @@ Sitemap: https://${host}${path === '/' ? '' : path}/sitemap.xml`,
         fs.mkdirSync(coverageBuildPath, { recursive: true });
         fs.copySync(`./coverage`, coverageBuildPath);
 
-        // uml
-        // shellExec(`node bin/deploy uml ${host} ${path}`);
-
         // https://swagger-autogen.github.io/docs/
 
         const basePath = path === '/' ? `${process.env.BASE_API}` : `/${process.env.BASE_API}`;
@@ -667,10 +664,6 @@ Sitemap: https://${host}${path === '/' ? '' : path}/sitemap.xml`,
           },
         };
 
-        // plantuml
-        logger.info('copy plantuml', `${rootClientPath}/docs/plantuml`);
-        fs.copySync(`./src/client/public/default/plantuml`, `${rootClientPath}/docs/plantuml`);
-
         logger.warn('build swagger api docs', doc.info);
 
         const outputFile = `./public/${host}${path === '/' ? path : `${path}/`}swagger-output.json`;
@@ -683,19 +676,6 @@ Sitemap: https://${host}${path === '/' ? '' : path}/sitemap.xml`,
 root file where the route starts, such as index.js, app.js, routes.js, etc ... */
 
         await swaggerAutoGen({ openapi: '3.0.0' })(outputFile, routes, doc);
-
-        const htmlFiles = await fs.readdir(`./public/${host}/docs/engine/${Underpost.version.replace('v', '')}`);
-        for (const htmlFile of htmlFiles) {
-          if (htmlFile.match('.html')) {
-            fs.writeFileSync(
-              `./public/${host}/docs/engine/${Underpost.version.replace('v', '')}/${htmlFile}`,
-              fs
-                .readFileSync(`./public/${host}/docs/engine/${Underpost.version.replace('v', '')}/${htmlFile}`, 'utf8')
-                .replaceAll('Tutorials', 'References'),
-              'utf8',
-            );
-          }
-        }
       }
 
       if (client) {

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