@omnizap-system/omnizap 2.6.0 → 2.6.2

package/app/store/aiPromptStore.js

@@ -1,36 +1,53 @@
-import groupConfigStore from './groupConfigStore.js';
+import { TABLES, executeQuery, findById, remove, upsert } from '../../database/index.js';
+import { normalizeJid } from '../config/index.js';
 
-const PROMPT_CONFIG_ID = 'system:ai_prompts';
+const AI_PROMPTS_TABLE = TABLES.SYSTEM_AI_PROMPTS;
+const SELECT_AI_PROMPTS_SQL = `SELECT id, prompt FROM \`${AI_PROMPTS_TABLE}\` ORDER BY id ASC`;
 
-const normalizeMap = (map) => (map && typeof map === 'object' ? map : {});
+const normalizePromptJid = (jid) => {
+  const raw = String(jid || '').trim();
+  if (!raw) return '';
+  return normalizeJid(raw) || raw;
+};
+
+const normalizePromptValue = (prompt) => {
+  if (typeof prompt === 'string') return prompt;
+  if (prompt === null || prompt === undefined) return '';
+  return String(prompt);
+};
 
 const aiPromptStore = {
   getAllPrompts: async function () {
-    const config = await groupConfigStore.getGroupConfig(PROMPT_CONFIG_ID);
-    return normalizeMap(config.prompts);
+    const rows = await executeQuery(SELECT_AI_PROMPTS_SQL);
+    const prompts = {};
+    for (const row of rows) {
+      const promptJid = normalizePromptJid(row?.id);
+      if (!promptJid) continue;
+      prompts[promptJid] = normalizePromptValue(row?.prompt);
+    }
+    return prompts;
   },
 
   getPrompt: async function (jid) {
-    if (!jid) return null;
-    const prompts = await this.getAllPrompts();
-    return prompts[jid] || null;
+    const normalizedJid = normalizePromptJid(jid);
+    if (!normalizedJid) return null;
+    const row = await findById(AI_PROMPTS_TABLE, normalizedJid);
+    if (!row) return null;
+    return normalizePromptValue(row.prompt);
   },
 
   setPrompt: async function (jid, prompt) {
-    if (!jid) return null;
-    const prompts = await this.getAllPrompts();
-    prompts[jid] = prompt;
-    await groupConfigStore.updateGroupConfig(PROMPT_CONFIG_ID, { prompts });
-    return prompt;
+    const normalizedJid = normalizePromptJid(jid);
+    if (!normalizedJid) return null;
+    const normalizedPrompt = normalizePromptValue(prompt);
+    await upsert(AI_PROMPTS_TABLE, { id: normalizedJid, prompt: normalizedPrompt });
+    return normalizedPrompt;
   },
 
   clearPrompt: async function (jid) {
-    if (!jid) return null;
-    const prompts = await this.getAllPrompts();
-    if (prompts[jid]) {
-      delete prompts[jid];
-      await groupConfigStore.updateGroupConfig(PROMPT_CONFIG_ID, { prompts });
-    }
+    const normalizedJid = normalizePromptJid(jid);
+    if (!normalizedJid) return null;
+    await remove(AI_PROMPTS_TABLE, normalizedJid);
     return true;
   },
 };

package/app/store/conversationSessionStore.js

@@ -1,3 +1,4 @@
+import { now as __timeNow, nowIso as __timeNowIso, toUnixMs as __timeNowMs } from '#time';
 const DEFAULT_SESSION_TTL_MS = 15 * 60 * 1000;
 const DEFAULT_HISTORY_LIMIT = 8;
 
@@ -22,7 +23,7 @@ const buildSessionKey = ({ chatId, userId, scope = 'private' } = {}) => {
   return `${safeScope}:${safeChatId}:${safeUserId}`;
 };
 
-const pruneExpiredSessions = (nowMs = Date.now()) => {
+const pruneExpiredSessions = (nowMs = __timeNowMs()) => {
   for (const [key, session] of sessions.entries()) {
     if (!session || !Number.isFinite(session.expiresAt) || session.expiresAt <= nowMs) {
       sessions.delete(key);
@@ -47,7 +48,7 @@ const getOrCreateSession = ({ chatId, userId, scope = 'private', ttlMs }) => {
   const key = buildSessionKey({ chatId, userId, scope });
   if (!key) return null;
 
-  const nowMs = Date.now();
+  const nowMs = __timeNowMs();
   const safeTtlMs = toFinitePositiveInt(ttlMs, DEFAULT_SESSION_TTL_MS, 1_000);
   const existing = sessions.get(key);
 
@@ -90,7 +91,7 @@ export const appendConversationSessionMessage = ({ chatId, userId, scope = 'priv
       role: safeRole,
       text: safeText,
       metadata: metadata && typeof metadata === 'object' ? { ...metadata } : null,
-      createdAt: new Date().toISOString(),
+      createdAt: __timeNowIso(),
     });
     const maxHistory = toFinitePositiveInt(historyLimit, DEFAULT_HISTORY_LIMIT, 1);
     if (session.history.length > maxHistory) {
@@ -98,7 +99,7 @@ export const appendConversationSessionMessage = ({ chatId, userId, scope = 'priv
     }
   }
 
-  session.updatedAt = new Date().toISOString();
+  session.updatedAt = __timeNowIso();
   return cloneSession(session);
 };
 
@@ -110,10 +111,10 @@ export const setConversationSessionIntent = ({ chatId, userId, scope = 'private'
     intent && typeof intent === 'object'
       ? {
           ...intent,
-          updatedAt: new Date().toISOString(),
+          updatedAt: __timeNowIso(),
         }
       : null;
-  session.updatedAt = new Date().toISOString();
+  session.updatedAt = __timeNowIso();
   return cloneSession(session);
 };
 

package/app/store/groupConfigStore.js

@@ -1,6 +1,31 @@
 import logger from '#logger';
+import { isGroupJid, normalizeJid } from '../config/index.js';
 import { findById, upsert } from '../../database/index.js';
 
+const SYSTEM_CONFIG_PREFIX = 'system:';
+
+const normalizeGroupConfigId = (groupId) => {
+  const raw = String(groupId || '').trim();
+  if (!raw) return '';
+  return normalizeJid(raw) || raw;
+};
+
+const isReservedSystemConfigId = (groupId) => groupId.startsWith(SYSTEM_CONFIG_PREFIX);
+
+const assertWritableGroupConfigId = (groupId) => {
+  if (!groupId) {
+    throw new Error('O identificador do grupo é obrigatório para persistir configurações.');
+  }
+
+  if (isReservedSystemConfigId(groupId)) {
+    throw new Error(`O id ${groupId} é reservado para configurações de sistema e não pode ser salvo em group_configs.`);
+  }
+
+  if (!isGroupJid(groupId)) {
+    throw new Error(`O id ${groupId} não representa um grupo válido para group_configs.`);
+  }
+};
+
 const groupConfigStore = {
   /**
    * Recupera a configuracao de um grupo especifico.
@@ -8,8 +33,17 @@ const groupConfigStore = {
    * @returns {object} A configuracao do grupo, ou um objeto vazio se nao encontrado.
    */
   getGroupConfig: async function (groupId) {
+    const normalizedGroupId = normalizeGroupConfigId(groupId);
+    if (!normalizedGroupId || !isGroupJid(normalizedGroupId)) {
+      return {};
+    }
+    if (isReservedSystemConfigId(normalizedGroupId)) {
+      logger.warn('Tentativa bloqueada de leitura de configuração reservada em group_configs.', { groupId: normalizedGroupId });
+      return {};
+    }
+
     try {
-      const record = await findById('group_configs', groupId);
+      const record = await findById('group_configs', normalizedGroupId);
       if (!record || record.config === null || record.config === undefined) {
         return {};
       }
@@ -23,7 +57,7 @@ const groupConfigStore = {
     } catch (error) {
       logger.error('Error loading group configuration from DB:', {
         error: error.message,
-        groupId,
+        groupId: normalizedGroupId,
       });
       return {};
     }
@@ -37,18 +71,20 @@ const groupConfigStore = {
    * @param {string} [newConfig.farewellMedia] - Caminho opcional para midia de despedida.
    */
   updateGroupConfig: async function (groupId, newConfig) {
-    const currentConfig = await this.getGroupConfig(groupId);
+    const normalizedGroupId = normalizeGroupConfigId(groupId);
+    assertWritableGroupConfigId(normalizedGroupId);
+    const currentConfig = await this.getGroupConfig(normalizedGroupId);
     const updatedConfig = { ...currentConfig, ...newConfig };
     try {
       await upsert('group_configs', {
-        id: groupId,
+        id: normalizedGroupId,
         config: JSON.stringify(updatedConfig),
       });
       return updatedConfig;
     } catch (error) {
       logger.error('Error updating group configuration in DB:', {
         error: error.message,
-        groupId,
+        groupId: normalizedGroupId,
       });
       throw error;
     }

package/app/store/premiumUserStore.js

@@ -1,7 +1,10 @@
-import groupConfigStore from './groupConfigStore.js';
+import { TABLES, executeQuery, withTransaction } from '../../database/index.js';
 import { isSameJidUser, normalizeJid } from '../config/index.js';
 
-const PREMIUM_CONFIG_ID = 'system:premium_users';
+const PREMIUM_USERS_TABLE = TABLES.SYSTEM_PREMIUM_USERS;
+const SELECT_PREMIUM_USERS_SQL = `SELECT id FROM \`${PREMIUM_USERS_TABLE}\` ORDER BY id ASC`;
+const DELETE_ALL_PREMIUM_USERS_SQL = `DELETE FROM \`${PREMIUM_USERS_TABLE}\``;
+const INSERT_PREMIUM_USER_SQL = `INSERT INTO \`${PREMIUM_USERS_TABLE}\` (id) VALUES (?)`;
 
 const normalizePremiumEntry = (value) => {
   const raw = String(value || '').trim();
@@ -23,22 +26,33 @@ const normalizeList = (list) => {
   return normalizedList;
 };
 
+const loadPremiumUsersFromDb = async () => {
+  const rows = await executeQuery(SELECT_PREMIUM_USERS_SQL);
+  return normalizeList(rows.map((row) => row.id));
+};
+
 const premiumUserStore = {
   getPremiumUsers: async function () {
-    const config = await groupConfigStore.getGroupConfig(PREMIUM_CONFIG_ID);
-    return normalizeList(config.premiumUsers);
+    return loadPremiumUsersFromDb();
   },
 
   setPremiumUsers: async function (premiumUsers) {
     const normalized = normalizeList(premiumUsers);
-    await groupConfigStore.updateGroupConfig(PREMIUM_CONFIG_ID, { premiumUsers: normalized });
+
+    await withTransaction(async (connection) => {
+      await executeQuery(DELETE_ALL_PREMIUM_USERS_SQL, [], connection);
+      for (const premiumJid of normalized) {
+        await executeQuery(INSERT_PREMIUM_USER_SQL, [premiumJid], connection);
+      }
+    });
+
     return normalized;
   },
 
   addPremiumUsers: async function (usersToAdd) {
     const current = await this.getPremiumUsers();
     const updated = normalizeList([...current, ...usersToAdd]);
-    await groupConfigStore.updateGroupConfig(PREMIUM_CONFIG_ID, { premiumUsers: updated });
+    await this.setPremiumUsers(updated);
     return updated;
   },
 
@@ -46,7 +60,7 @@ const premiumUserStore = {
     const current = await this.getPremiumUsers();
     const normalizedTargets = normalizeList(usersToRemove);
     const updated = current.filter((jid) => !normalizedTargets.some((target) => target === jid || isSameJidUser(target, jid)));
-    await groupConfigStore.updateGroupConfig(PREMIUM_CONFIG_ID, { premiumUsers: updated });
+    await this.setPremiumUsers(updated);
     return updated;
   },
 };