@omnizap-system/omnizap 2.6.0 → 2.6.2

package/app/modules/adminModule/groupCommandHandlers.test.js

@@ -1,3 +1,4 @@
+import { now as __timeNow, nowIso as __timeNowIso, toUnixMs as __timeNowMs } from '#time';
 import assert from 'node:assert/strict';
 import { after, afterEach, beforeEach, test } from 'node:test';
 
@@ -16,6 +17,7 @@ const ENV_OVERRIDES = {
   DB_MONITOR_ENABLED: 'false',
   METRICS_ENABLED: 'false',
   ADMIN_AI_HELP_SCHEDULER_ENABLED: 'false',
+  WHATSAPP_ADMIN_JID: OWNER_JID,
   USER_ADMIN: OWNER_PHONE,
 };
 
@@ -26,7 +28,7 @@ for (const [key, value] of Object.entries(ENV_OVERRIDES)) {
 }
 
 const originalArgv1 = process.argv[1];
-process.argv[1] = '/root/omnizap-system/database/init.js';
+process.argv[1] = new URL('../../../database/init.js', import.meta.url).pathname;
 
 let pool;
 let handleAdminCommand;
@@ -55,27 +57,113 @@ const normalizeSql = (sql) =>
 const createDbHarness = () => {
   const groupConfigRows = new Map();
   const groupMetadataRows = new Map();
+  const premiumUserRows = new Set();
+  const groupUserWarningsRows = [];
+  let warningAutoIncrement = 1;
 
   const execute = async (sql, params = []) => {
     const normalized = normalizeSql(sql);
+    const normalizedNoTicks = normalized.replaceAll('`', '');
 
-    if (normalized.startsWith('select * from `groups_metadata` where id = ?')) {
+    if (normalizedNoTicks.startsWith('select * from groups_metadata where id = ?')) {
       const row = groupMetadataRows.get(params[0]);
       return [[row].filter(Boolean), []];
     }
 
-    if (normalized.startsWith('select * from `group_configs` where id = ?')) {
+    if (normalizedNoTicks.startsWith('select * from group_configs where id = ?')) {
       const row = groupConfigRows.get(params[0]);
       return [[row].filter(Boolean), []];
     }
 
-    if (normalized.startsWith('insert into `group_configs`')) {
+    if (normalizedNoTicks.startsWith('insert into group_configs')) {
       const [id, config] = params;
       groupConfigRows.set(id, { id, config: String(config) });
       return [{ affectedRows: 1 }, []];
     }
 
-    if (normalized.includes('from lid_map') || normalized.includes('from `lid_map`') || normalized.includes('into `lid_map`') || normalized.startsWith('update `messages`')) {
+    if (normalizedNoTicks.startsWith('select id from system_premium_users')) {
+      const rows = Array.from(premiumUserRows.values())
+        .sort((left, right) => String(left).localeCompare(String(right)))
+        .map((id) => ({ id }));
+      return [rows, []];
+    }
+
+    if (normalizedNoTicks.startsWith('delete from system_premium_users')) {
+      premiumUserRows.clear();
+      return [{ affectedRows: 1 }, []];
+    }
+
+    if (normalizedNoTicks.startsWith('insert into system_premium_users')) {
+      const [id] = params;
+      premiumUserRows.add(String(id || ''));
+      return [{ affectedRows: 1 }, []];
+    }
+
+    if (normalizedNoTicks.startsWith('insert into group_user_warnings')) {
+      const [groupId, participantJid, warnedByJid, reason] = params;
+      groupUserWarningsRows.push({
+        id: warningAutoIncrement++,
+        group_id: String(groupId || ''),
+        participant_jid: String(participantJid || '').toLowerCase(),
+        warned_by_jid: warnedByJid ? String(warnedByJid).toLowerCase() : null,
+        reason: reason ? String(reason) : null,
+        created_at: new Date(__timeNowMs()).toISOString(),
+      });
+      return [{ affectedRows: 1 }, []];
+    }
+
+    if (normalizedNoTicks.startsWith('select count(*) as total from group_user_warnings')) {
+      const [groupId, participantJid] = params;
+      const filtered = groupUserWarningsRows.filter((row) => row.group_id === String(groupId || '') && row.participant_jid === String(participantJid || '').toLowerCase());
+      return [[{ total: filtered.length }], []];
+    }
+
+    if (normalizedNoTicks.startsWith('select id, group_id, participant_jid, warned_by_jid, reason, created_at from group_user_warnings')) {
+      const [groupId, participantJid, limit] = params;
+      const safeLimit = Number.parseInt(String(limit || 0), 10);
+      const filtered = groupUserWarningsRows
+        .filter((row) => row.group_id === String(groupId || '') && row.participant_jid === String(participantJid || '').toLowerCase())
+        .sort((left, right) => right.id - left.id)
+        .slice(0, Number.isFinite(safeLimit) && safeLimit > 0 ? safeLimit : 20)
+        .map((row) => ({ ...row }));
+      return [filtered, []];
+    }
+
+    if (normalizedNoTicks.startsWith('delete from group_user_warnings') && normalizedNoTicks.includes('order by id desc limit ?')) {
+      const [groupId, participantJid, limit] = params;
+      const safeGroupId = String(groupId || '');
+      const safeParticipantJid = String(participantJid || '').toLowerCase();
+      const safeLimit = Number.parseInt(String(limit || 0), 10);
+      const rowsToDelete = groupUserWarningsRows
+        .filter((row) => row.group_id === safeGroupId && row.participant_jid === safeParticipantJid)
+        .sort((left, right) => right.id - left.id)
+        .slice(0, Number.isFinite(safeLimit) && safeLimit > 0 ? safeLimit : 1)
+        .map((row) => row.id);
+
+      if (rowsToDelete.length > 0) {
+        for (let index = groupUserWarningsRows.length - 1; index >= 0; index -= 1) {
+          if (!rowsToDelete.includes(groupUserWarningsRows[index].id)) continue;
+          groupUserWarningsRows.splice(index, 1);
+        }
+      }
+
+      return [{ affectedRows: rowsToDelete.length }, []];
+    }
+
+    if (normalizedNoTicks.startsWith('delete from group_user_warnings')) {
+      const [groupId, participantJid] = params;
+      const safeGroupId = String(groupId || '');
+      const safeParticipantJid = String(participantJid || '').toLowerCase();
+      let removed = 0;
+      for (let index = groupUserWarningsRows.length - 1; index >= 0; index -= 1) {
+        if (groupUserWarningsRows[index].group_id !== safeGroupId || groupUserWarningsRows[index].participant_jid !== safeParticipantJid) continue;
+        groupUserWarningsRows.splice(index, 1);
+        removed += 1;
+      }
+      return [{ affectedRows: removed }, []];
+    }
+
+    if (normalizedNoTicks.includes('from lid_map') || normalizedNoTicks.includes('into lid_map') || normalizedNoTicks.startsWith('update messages')) {
       return [[], []];
     }
 
@@ -101,11 +189,19 @@ const createDbHarness = () => {
     return row ? JSON.parse(row.config) : {};
   };
 
+  const setPremiumUsers = (premiumUsers) => {
+    premiumUserRows.clear();
+    for (const premiumUser of premiumUsers || []) {
+      premiumUserRows.add(String(premiumUser || ''));
+    }
+  };
+
   return {
     execute,
     setGroupParticipants,
     setGroupConfig,
     getGroupConfig,
+    setPremiumUsers,
   };
 };
 
@@ -123,7 +219,7 @@ const createSockStub = () => {
         return {
           key: { remoteJid: jid },
           message: content,
-          messageTimestamp: Math.floor(Date.now() / 1000),
+          messageTimestamp: Math.floor(__timeNowMs() / 1000),
         };
       },
       groupParticipantsUpdate: async (groupId, participants, action) => {
@@ -134,10 +230,26 @@ const createSockStub = () => {
   };
 };
 
-const buildMessageInfo = (participant = OWNER_JID) => ({
-  key: { participant },
-  message: {},
-});
+const buildMessageInfo = (participant = OWNER_JID, { mentionedJid = [], replyParticipant = '' } = {}) => {
+  const contextInfo = {};
+  if (Array.isArray(mentionedJid) && mentionedJid.length > 0) {
+    contextInfo.mentionedJid = mentionedJid;
+  }
+  if (replyParticipant) {
+    contextInfo.participant = replyParticipant;
+  }
+
+  return {
+    key: { participant },
+    message: Object.keys(contextInfo).length
+      ? {
+          extendedTextMessage: {
+            contextInfo,
+          },
+        }
+      : {},
+  };
+};
 
 const runAdminCommand = async ({ command, args = [], text = args.join(' '), sock, senderJid = OWNER_JID, remoteJid = GROUP_JID, isGroupMessage = true, messageInfo, botJid = BOT_JID }) =>
   handleAdminCommand({
@@ -181,6 +293,13 @@ after(() => {
 test('isAdminCommand reconhece comandos válidos', () => {
   assert.equal(isAdminCommand('nsfw'), true);
   assert.equal(isAdminCommand('banir'), true);
+  assert.equal(isAdminCommand('warn'), true);
+  assert.equal(isAdminCommand('warnings'), true);
+  assert.equal(isAdminCommand('clearwarn'), true);
+  assert.equal(isAdminCommand('warnlimit'), true);
+  assert.equal(isAdminCommand('stickerallowance'), true);
+  assert.equal(isAdminCommand('noticiasfiltro'), true);
+  assert.equal(isAdminCommand('grupoaudit'), true);
   assert.equal(isAdminCommand('comando-inexistente'), false);
 });
 
@@ -288,6 +407,167 @@ test('ban bloqueia tentativa de remover o próprio bot', async () => {
   assert.equal(messages[0].content.text, 'Operação cancelada: o bot não pode remover a própria conta.');
 });
 
+test('warn registra advertência e warnings lista histórico', async () => {
+  const { sock, messages } = createSockStub();
+  dbHarness.setGroupParticipants(GROUP_JID, [{ id: OWNER_JID, admin: 'admin' }]);
+
+  await runAdminCommand({
+    command: 'warn',
+    args: ['@alvo', 'spam', 'repetitivo'],
+    sock,
+    messageInfo: buildMessageInfo(OWNER_JID, { mentionedJid: [TARGET_JID] }),
+  });
+
+  assert.match(messages[messages.length - 1].content.text, /Advertência registrada/i);
+  assert.match(messages[messages.length - 1].content.text, /spam repetitivo/i);
+
+  await runAdminCommand({
+    command: 'warnings',
+    args: [],
+    sock,
+    messageInfo: buildMessageInfo(OWNER_JID, { replyParticipant: TARGET_JID }),
+  });
+
+  assert.match(messages[messages.length - 1].content.text, /Histórico de advertências/i);
+  assert.match(messages[messages.length - 1].content.text, /Total neste grupo: \*1\*/i);
+  assert.match(messages[messages.length - 1].content.text, /spam repetitivo/i);
+});
+
+test('warn aplica auto-ban no limite padrão de 3 advertências', async () => {
+  const { sock, messages, participantUpdates } = createSockStub();
+  dbHarness.setGroupParticipants(GROUP_JID, [{ id: OWNER_JID, admin: 'admin' }]);
+
+  await runAdminCommand({
+    command: 'warn',
+    args: [TARGET_JID, 'motivo-1'],
+    sock,
+  });
+  await runAdminCommand({
+    command: 'warn',
+    args: [TARGET_JID, 'motivo-2'],
+    sock,
+  });
+  await runAdminCommand({
+    command: 'warn',
+    args: [TARGET_JID, 'motivo-3'],
+    sock,
+  });
+
+  assert.equal(participantUpdates.length, 1);
+  assert.deepEqual(participantUpdates[0], {
+    groupId: GROUP_JID,
+    participants: [TARGET_JID],
+    action: 'remove',
+  });
+  assert.match(messages[messages.length - 1].content.text, /Auto-ban configurado para: \*3\*/i);
+  assert.match(messages[messages.length - 1].content.text, /Limite atingido/i);
+});
+
+test('warnlimit permite ajustar limite por grupo e resetar para padrão', async () => {
+  const { sock, messages, participantUpdates } = createSockStub();
+  dbHarness.setGroupParticipants(GROUP_JID, [{ id: OWNER_JID, admin: 'admin' }]);
+
+  await runAdminCommand({
+    command: 'warnlimit',
+    args: ['2'],
+    sock,
+  });
+  assert.equal(dbHarness.getGroupConfig(GROUP_JID).warnAutoBanThreshold, 2);
+
+  await runAdminCommand({
+    command: 'warn',
+    args: [TARGET_JID, 'motivo-1'],
+    sock,
+  });
+  await runAdminCommand({
+    command: 'warn',
+    args: [TARGET_JID, 'motivo-2'],
+    sock,
+  });
+
+  assert.equal(participantUpdates.length, 1);
+  assert.deepEqual(participantUpdates[0], {
+    groupId: GROUP_JID,
+    participants: [TARGET_JID],
+    action: 'remove',
+  });
+
+  await runAdminCommand({
+    command: 'warnlimit',
+    args: ['status'],
+    sock,
+  });
+  assert.match(messages[messages.length - 1].content.text, /Limite atual de auto-ban/i);
+  assert.match(messages[messages.length - 1].content.text, /\*2\*/);
+
+  await runAdminCommand({
+    command: 'warnlimit',
+    args: ['reset'],
+    sock,
+  });
+  assert.equal(dbHarness.getGroupConfig(GROUP_JID).warnAutoBanThreshold, null);
+  assert.match(messages[messages.length - 1].content.text, /padrão: \*3\*/i);
+});
+
+test('clearwarn remove parcialmente e depois remove todas as advertências', async () => {
+  const { sock, messages } = createSockStub();
+  dbHarness.setGroupParticipants(GROUP_JID, [{ id: OWNER_JID, admin: 'admin' }]);
+
+  await runAdminCommand({
+    command: 'warn',
+    args: [TARGET_JID, 'motivo-1'],
+    sock,
+  });
+  await runAdminCommand({
+    command: 'warn',
+    args: [TARGET_JID, 'motivo-2'],
+    sock,
+  });
+  await runAdminCommand({
+    command: 'warn',
+    args: [TARGET_JID, 'motivo-3'],
+    sock,
+  });
+
+  await runAdminCommand({
+    command: 'clearwarn',
+    args: [TARGET_JID, '2'],
+    sock,
+  });
+  assert.match(messages[messages.length - 1].content.text, /removi \*2 advertência\(s\)\*/i);
+  assert.match(messages[messages.length - 1].content.text, /Advertências restantes neste grupo: \*1\*/i);
+
+  await runAdminCommand({
+    command: 'clearwarn',
+    args: [TARGET_JID, 'all'],
+    sock,
+  });
+  assert.match(messages[messages.length - 1].content.text, /todas as advertências \(1\)/i);
+  assert.match(messages[messages.length - 1].content.text, /Advertências restantes neste grupo: \*0\*/i);
+
+  await runAdminCommand({
+    command: 'warnings',
+    args: [TARGET_JID],
+    sock,
+  });
+  assert.match(messages[messages.length - 1].content.text, /não possui advertências/i);
+});
+
+test('clearwarn retorna uso ao receber quantidade inválida', async () => {
+  const { sock, messages } = createSockStub();
+  dbHarness.setGroupParticipants(GROUP_JID, [{ id: OWNER_JID, admin: 'admin' }]);
+
+  await runAdminCommand({
+    command: 'clearwarn',
+    args: [TARGET_JID, 'zero'],
+    sock,
+  });
+
+  assert.equal(messages.length, 1);
+  assert.match(messages[0].content.text, /Formato de uso/i);
+  assert.match(messages[0].content.text, /clearwarn/i);
+});
+
 test('premium exige admin principal e lista usuários quando autorizado', async () => {
   const texts = getAdminTextConfig();
   const denied = createSockStub();
@@ -305,7 +585,7 @@ test('premium exige admin principal e lista usuários quando autorizado', async
   assert.equal(denied.messages.length, 1);
   assert.equal(denied.messages[0].content.text, texts.owner_only_command_message);
 
-  dbHarness.setGroupConfig('system:premium_users', { premiumUsers: [TARGET_JID] });
+  dbHarness.setPremiumUsers([TARGET_JID]);
   const allowed = createSockStub();
 
   await runAdminCommand({
@@ -348,3 +628,90 @@ test('prefix atualiza, consulta status e reseta para padrão', async () => {
   });
   assert.equal(dbHarness.getGroupConfig(GROUP_JID).commandPrefix, null);
 });
+
+test('stickerallowance atualiza e consulta limite por janela', async () => {
+  const { sock, messages } = createSockStub();
+  dbHarness.setGroupParticipants(GROUP_JID, [{ id: OWNER_JID, admin: 'admin' }]);
+
+  await runAdminCommand({
+    command: 'stickerallowance',
+    args: ['4'],
+    sock,
+  });
+
+  const updatedConfig = dbHarness.getGroupConfig(GROUP_JID);
+  assert.equal(updatedConfig.stickerFocusMessageAllowance, 4);
+  assert.equal(updatedConfig.stickerFocusMessageAllowanceCount, 4);
+
+  await runAdminCommand({
+    command: 'stickerallowance',
+    args: ['status'],
+    sock,
+  });
+
+  assert.match(messages[messages.length - 1].content.text, /Limite atual de mensagens por usuário/i);
+  assert.match(messages[messages.length - 1].content.text, /\*4\*/);
+});
+
+test('noticiasfiltro aplica source/tag e trending no config do grupo', async () => {
+  const { sock } = createSockStub();
+  dbHarness.setGroupParticipants(GROUP_JID, [{ id: OWNER_JID, admin: 'admin' }]);
+
+  await runAdminCommand({
+    command: 'noticiasfiltro',
+    args: ['source', 'add', 'ann,mal'],
+    sock,
+  });
+
+  await runAdminCommand({
+    command: 'noticiasfiltro',
+    args: ['tag', 'add', 'shounen'],
+    sock,
+  });
+
+  await runAdminCommand({
+    command: 'noticiasfiltro',
+    args: ['trending', 'on'],
+    sock,
+  });
+
+  const updatedConfig = dbHarness.getGroupConfig(GROUP_JID);
+  assert.deepEqual(updatedConfig.newsSourceIds, ['ann', 'mal']);
+  assert.deepEqual(updatedConfig.newsEntitySlugs, ['shounen']);
+  assert.equal(updatedConfig.newsOnlyTrending, true);
+  assert.equal(updatedConfig.newsFilters.onlyTrending, true);
+});
+
+test('grupoaudit retorna resumo consolidado do grupo', async () => {
+  const { sock, messages } = createSockStub();
+  dbHarness.setGroupParticipants(GROUP_JID, [{ id: OWNER_JID, admin: 'admin' }]);
+  dbHarness.setGroupConfig(GROUP_JID, {
+    commandPrefix: '!',
+    nsfwEnabled: true,
+    autoStickerEnabled: false,
+    stickerFocusEnabled: true,
+    stickerFocusMessageCooldownMinutes: 30,
+    stickerFocusMessageAllowance: 3,
+    captchaEnabled: true,
+    autoApproveRequestsEnabled: false,
+    antilinkEnabled: true,
+    antilinkAllowedNetworks: ['youtube'],
+    antilinkAllowedDomains: ['example.com'],
+    newsEnabled: true,
+    newsSentIds: ['n1', 'n2'],
+    newsLastSentAt: '2026-03-18T00:00:00.000Z',
+    welcomeMessageEnabled: true,
+    farewellMessageEnabled: false,
+  });
+
+  await runAdminCommand({
+    command: 'grupoaudit',
+    args: [],
+    sock,
+  });
+
+  assert.equal(messages.length, 1);
+  assert.match(messages[0].content.text, /Auditoria do Grupo/i);
+  assert.match(messages[0].content.text, /Notícias enviadas: \*2\*/i);
+  assert.match(messages[0].content.text, /Antilink: \*ativado\*/i);
+});

package/app/modules/adminModule/groupWarningRepository.js

@@ -0,0 +1,152 @@
+import { executeQuery, TABLES } from '../../../database/index.js';
+
+const MAX_REASON_CHARS = 500;
+const DEFAULT_LIST_LIMIT = 20;
+
+const normalizeGroupId = (value) => {
+  const normalized = String(value || '')
+    .trim()
+    .slice(0, 255);
+  return normalized || null;
+};
+
+const normalizeParticipantJid = (value) => {
+  const normalized = String(value || '')
+    .trim()
+    .toLowerCase()
+    .slice(0, 255);
+  return normalized || null;
+};
+
+const normalizeReason = (value) => {
+  const normalized = String(value || '')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .slice(0, MAX_REASON_CHARS);
+  return normalized || null;
+};
+
+const normalizeWarnByJid = (value) => {
+  const normalized = String(value || '')
+    .trim()
+    .toLowerCase()
+    .slice(0, 255);
+  return normalized || null;
+};
+
+const toPositiveInt = (value, fallback, min = 1, max = Number.MAX_SAFE_INTEGER) => {
+  const numeric = Number.parseInt(String(value ?? ''), 10);
+  if (!Number.isFinite(numeric) || numeric < min) return fallback;
+  return Math.max(min, Math.min(max, numeric));
+};
+
+export const addGroupWarning = async ({ groupId, participantJid, warnedByJid, reason = null } = {}) => {
+  const safeGroupId = normalizeGroupId(groupId);
+  const safeParticipantJid = normalizeParticipantJid(participantJid);
+  const safeWarnedByJid = normalizeWarnByJid(warnedByJid);
+
+  if (!safeGroupId || !safeParticipantJid) {
+    throw new Error('group_warning_invalid_target');
+  }
+
+  await executeQuery(
+    `INSERT INTO ${TABLES.GROUP_USER_WARNINGS}
+      (group_id, participant_jid, warned_by_jid, reason)
+      VALUES (?, ?, ?, ?)`,
+    [safeGroupId, safeParticipantJid, safeWarnedByJid, normalizeReason(reason)],
+  );
+
+  return true;
+};
+
+export const countGroupWarnings = async ({ groupId, participantJid } = {}) => {
+  const safeGroupId = normalizeGroupId(groupId);
+  const safeParticipantJid = normalizeParticipantJid(participantJid);
+
+  if (!safeGroupId || !safeParticipantJid) return 0;
+
+  const rows = await executeQuery(
+    `SELECT COUNT(*) AS total
+       FROM ${TABLES.GROUP_USER_WARNINGS}
+      WHERE group_id = ? AND participant_jid = ?`,
+    [safeGroupId, safeParticipantJid],
+  );
+
+  const total = Number(rows?.[0]?.total || 0);
+  return Number.isFinite(total) ? Math.max(0, Math.floor(total)) : 0;
+};
+
+export const listGroupWarnings = async ({ groupId, participantJid, limit = DEFAULT_LIST_LIMIT } = {}) => {
+  const safeGroupId = normalizeGroupId(groupId);
+  const safeParticipantJid = normalizeParticipantJid(participantJid);
+  const safeLimit = toPositiveInt(limit, DEFAULT_LIST_LIMIT, 1, 100);
+
+  if (!safeGroupId || !safeParticipantJid) return [];
+
+  const rows = await executeQuery(
+    `SELECT id, group_id, participant_jid, warned_by_jid, reason, created_at
+       FROM ${TABLES.GROUP_USER_WARNINGS}
+      WHERE group_id = ? AND participant_jid = ?
+      ORDER BY id DESC
+      LIMIT ?`,
+    [safeGroupId, safeParticipantJid, safeLimit],
+  );
+
+  return (Array.isArray(rows) ? rows : []).map((row) => ({
+    id: Number(row?.id || 0),
+    groupId: normalizeGroupId(row?.group_id),
+    participantJid: normalizeParticipantJid(row?.participant_jid),
+    warnedByJid: normalizeWarnByJid(row?.warned_by_jid),
+    reason: normalizeReason(row?.reason),
+    createdAt: row?.created_at || null,
+  }));
+};
+
+export const clearGroupWarnings = async ({ groupId, participantJid, clearAll = false, limit = 1 } = {}) => {
+  const safeGroupId = normalizeGroupId(groupId);
+  const safeParticipantJid = normalizeParticipantJid(participantJid);
+  const safeLimit = toPositiveInt(limit, 1, 1, 500);
+
+  if (!safeGroupId || !safeParticipantJid) {
+    return {
+      removedCount: 0,
+      remainingCount: 0,
+    };
+  }
+
+  const beforeCount = await countGroupWarnings({
+    groupId: safeGroupId,
+    participantJid: safeParticipantJid,
+  });
+  if (beforeCount <= 0) {
+    return {
+      removedCount: 0,
+      remainingCount: 0,
+    };
+  }
+
+  if (clearAll) {
+    await executeQuery(
+      `DELETE FROM ${TABLES.GROUP_USER_WARNINGS}
+        WHERE group_id = ? AND participant_jid = ?`,
+      [safeGroupId, safeParticipantJid],
+    );
+  } else {
+    await executeQuery(
+      `DELETE FROM ${TABLES.GROUP_USER_WARNINGS}
+        WHERE group_id = ? AND participant_jid = ?
+        ORDER BY id DESC
+        LIMIT ?`,
+      [safeGroupId, safeParticipantJid, safeLimit],
+    );
+  }
+
+  const remainingCount = await countGroupWarnings({
+    groupId: safeGroupId,
+    participantJid: safeParticipantJid,
+  });
+  return {
+    removedCount: Math.max(0, beforeCount - remainingCount),
+    remainingCount,
+  };
+};