@omnizap-system/omnizap 2.5.12

package/app/modules/stickerPackModule/stickerPackConfigRuntime.js

@@ -0,0 +1,68 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { createModuleCommandConfigRuntime } from '../../services/ai/moduleCommandConfigRuntimeService.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const CONFIG_PATH = path.join(__dirname, 'commandConfig.json');
+
+const DEFAULT_TEXTS = {
+  usage_header: '',
+};
+
+const runtime = createModuleCommandConfigRuntime({
+  configPath: CONFIG_PATH,
+  fallbackConfig: {
+    module: 'stickerPackModule',
+    commands: [],
+    textos: DEFAULT_TEXTS,
+  },
+});
+
+const renderUsageMethod = (method, commandPrefix) => String(method || '').replaceAll('<prefix>', String(commandPrefix || '/'));
+
+const resolveUsageLines = (entry, variant) => {
+  if (!entry || typeof entry !== 'object') return [];
+
+  const usageMessages = entry?.mensagens_uso && typeof entry.mensagens_uso === 'object' ? entry.mensagens_uso : null;
+
+  if (usageMessages) {
+    const variantKey = typeof variant === 'string' ? variant.trim() : '';
+    const picked = (variantKey && usageMessages[variantKey]) || usageMessages.default || null;
+    if (Array.isArray(picked)) {
+      return picked.filter(Boolean).map((value) => String(value));
+    }
+    if (typeof picked === 'string' && picked.trim()) {
+      return [picked.trim()];
+    }
+  }
+
+  const methods = Array.isArray(entry?.metodos_de_uso) ? entry.metodos_de_uso : [];
+  return methods.filter(Boolean).map((value) => String(value));
+};
+
+export const getStickerPackModuleConfig = () => runtime.getModuleConfig();
+
+export const resolveStickerPackCommandName = (command) => runtime.resolveCommandName(command);
+export const getStickerPackCommandEntry = (command) => runtime.getCommandEntry(command);
+export const listEnabledStickerPackCommands = () => runtime.listEnabledCommands();
+
+export const getStickerPackTextConfig = () => {
+  const config = getStickerPackModuleConfig();
+  const raw = config?.textos && typeof config.textos === 'object' ? config.textos : {};
+  return {
+    ...DEFAULT_TEXTS,
+    ...raw,
+  };
+};
+
+export const getStickerPackUsageText = (command, { commandPrefix = '/', header, variant } = {}) => {
+  const entry = getStickerPackCommandEntry(command);
+  const methods = resolveUsageLines(entry, variant);
+  if (!methods.length) return '';
+
+  const prefixHeader = typeof header === 'string' ? header : getStickerPackTextConfig().usage_header || DEFAULT_TEXTS.usage_header;
+  const lines = methods.map((method) => renderUsageMethod(method, commandPrefix));
+  return prefixHeader ? [prefixHeader, ...lines].join('\n') : lines.join('\n');
+};

package/app/modules/stickerPackModule/stickerPackEngagementRepository.js

@@ -0,0 +1,152 @@
+import { executeQuery, TABLES } from '../../../database/index.js';
+import { STICKER_DOMAIN_EVENTS } from './domainEvents.js';
+import { publishStickerDomainEvent } from './stickerDomainEventBus.js';
+
+const normalizeEngagementRow = (row) => ({
+  pack_id: row?.pack_id || null,
+  open_count: Number(row?.open_count || 0),
+  like_count: Number(row?.like_count || 0),
+  dislike_count: Number(row?.dislike_count || 0),
+  score: Number(row?.like_count || 0) - Number(row?.dislike_count || 0),
+  updated_at: row?.updated_at || null,
+});
+
+const EMPTY_ENGAGEMENT = Object.freeze({
+  open_count: 0,
+  like_count: 0,
+  dislike_count: 0,
+  score: 0,
+  updated_at: null,
+});
+
+export const getEmptyStickerPackEngagement = () => ({ ...EMPTY_ENGAGEMENT });
+
+export async function listStickerPackEngagementByPackIds(packIds, connection = null) {
+  const ids = Array.from(new Set((Array.isArray(packIds) ? packIds : []).filter(Boolean)));
+  if (!ids.length) return new Map();
+
+  const placeholders = ids.map(() => '?').join(', ');
+  const rows = await executeQuery(
+    `SELECT pack_id, open_count, like_count, dislike_count, updated_at
+     FROM ${TABLES.STICKER_PACK_ENGAGEMENT}
+     WHERE pack_id IN (${placeholders})`,
+    ids,
+    connection,
+  );
+
+  const byPackId = new Map();
+  rows.forEach((row) => {
+    const normalized = normalizeEngagementRow(row);
+    if (normalized.pack_id) byPackId.set(normalized.pack_id, normalized);
+  });
+  return byPackId;
+}
+
+export async function getStickerPackEngagementByPackId(packId, connection = null) {
+  if (!packId) return getEmptyStickerPackEngagement();
+  const rows = await executeQuery(
+    `SELECT pack_id, open_count, like_count, dislike_count, updated_at
+     FROM ${TABLES.STICKER_PACK_ENGAGEMENT}
+     WHERE pack_id = ?
+     LIMIT 1`,
+    [packId],
+    connection,
+  );
+
+  if (!rows?.[0]) return getEmptyStickerPackEngagement();
+  return normalizeEngagementRow(rows[0]);
+}
+
+export async function incrementStickerPackOpen(packId, connection = null) {
+  if (!packId) return getEmptyStickerPackEngagement();
+
+  await executeQuery(
+    `INSERT INTO ${TABLES.STICKER_PACK_ENGAGEMENT}
+      (pack_id, open_count, like_count, dislike_count, last_opened_at)
+     VALUES (?, 1, 0, 0, CURRENT_TIMESTAMP)
+     ON DUPLICATE KEY UPDATE
+       open_count = open_count + 1,
+       last_opened_at = CURRENT_TIMESTAMP,
+       updated_at = CURRENT_TIMESTAMP`,
+    [packId],
+    connection,
+  );
+
+  await publishStickerDomainEvent(
+    {
+      eventType: STICKER_DOMAIN_EVENTS.ENGAGEMENT_RECORDED,
+      aggregateType: 'sticker_pack',
+      aggregateId: packId,
+      payload: {
+        action: 'open',
+        pack_id: packId,
+      },
+      priority: 55,
+    },
+    { connection },
+  );
+
+  return getStickerPackEngagementByPackId(packId, connection);
+}
+
+export async function incrementStickerPackLike(packId, connection = null) {
+  if (!packId) return getEmptyStickerPackEngagement();
+
+  await executeQuery(
+    `INSERT INTO ${TABLES.STICKER_PACK_ENGAGEMENT}
+      (pack_id, open_count, like_count, dislike_count)
+     VALUES (?, 0, 1, 0)
+     ON DUPLICATE KEY UPDATE
+       like_count = like_count + 1,
+       updated_at = CURRENT_TIMESTAMP`,
+    [packId],
+    connection,
+  );
+
+  await publishStickerDomainEvent(
+    {
+      eventType: STICKER_DOMAIN_EVENTS.ENGAGEMENT_RECORDED,
+      aggregateType: 'sticker_pack',
+      aggregateId: packId,
+      payload: {
+        action: 'like',
+        pack_id: packId,
+      },
+      priority: 55,
+    },
+    { connection },
+  );
+
+  return getStickerPackEngagementByPackId(packId, connection);
+}
+
+export async function incrementStickerPackDislike(packId, connection = null) {
+  if (!packId) return getEmptyStickerPackEngagement();
+
+  await executeQuery(
+    `INSERT INTO ${TABLES.STICKER_PACK_ENGAGEMENT}
+      (pack_id, open_count, like_count, dislike_count)
+     VALUES (?, 0, 0, 1)
+     ON DUPLICATE KEY UPDATE
+       dislike_count = dislike_count + 1,
+       updated_at = CURRENT_TIMESTAMP`,
+    [packId],
+    connection,
+  );
+
+  await publishStickerDomainEvent(
+    {
+      eventType: STICKER_DOMAIN_EVENTS.ENGAGEMENT_RECORDED,
+      aggregateType: 'sticker_pack',
+      aggregateId: packId,
+      payload: {
+        action: 'dislike',
+        pack_id: packId,
+      },
+      priority: 55,
+    },
+    { connection },
+  );
+
+  return getStickerPackEngagementByPackId(packId, connection);
+}

package/app/modules/stickerPackModule/stickerPackErrors.js

@@ -0,0 +1,30 @@
+/**
+ * Erro padrão para operações relacionadas a packs de figurinha.
+ */
+export class StickerPackError extends Error {
+  /**
+   * @param {string} code Código semântico do erro.
+   * @param {string} message Mensagem amigável para logs/cliente.
+   * @param {unknown} [details=null] Objeto técnico opcional para diagnóstico.
+   */
+  constructor(code, message, details = null) {
+    super(message);
+    this.name = 'StickerPackError';
+    this.code = code;
+    this.details = details;
+  }
+}
+
+/**
+ * Catálogo de códigos de erro usados pelo domínio de sticker pack.
+ */
+export const STICKER_PACK_ERROR_CODES = {
+  INVALID_INPUT: 'INVALID_INPUT',
+  PACK_NOT_FOUND: 'PACK_NOT_FOUND',
+  NOT_ALLOWED: 'NOT_ALLOWED',
+  STICKER_NOT_FOUND: 'STICKER_NOT_FOUND',
+  PACK_LIMIT_REACHED: 'PACK_LIMIT_REACHED',
+  DUPLICATE_STICKER: 'DUPLICATE_STICKER',
+  STORAGE_ERROR: 'STORAGE_ERROR',
+  INTERNAL_ERROR: 'INTERNAL_ERROR',
+};

package/app/modules/stickerPackModule/stickerPackInteractionEventRepository.js

@@ -0,0 +1,101 @@
+import { executeQuery, TABLES } from '../../../database/index.js';
+
+const clamp = (value, fallback, min, max) => {
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric)) return fallback;
+  return Math.max(min, Math.min(max, Math.floor(numeric)));
+};
+
+const normalizeInteraction = (value) => {
+  const normalized = String(value || '')
+    .trim()
+    .toLowerCase();
+  if (['open', 'like', 'dislike'].includes(normalized)) return normalized;
+  return null;
+};
+
+const sanitizeKey = (value, maxLength = 120) => {
+  const normalized = String(value || '')
+    .trim()
+    .replace(/\s+/g, ' ')
+    .slice(0, maxLength);
+  return normalized || null;
+};
+
+export async function createStickerPackInteractionEvent({ packId, interaction, actorKey = null, sessionKey = null, source = null }, connection = null) {
+  const normalizedInteraction = normalizeInteraction(interaction);
+  if (!packId || !normalizedInteraction) return false;
+
+  await executeQuery(
+    `INSERT INTO ${TABLES.STICKER_PACK_INTERACTION_EVENT}
+      (pack_id, interaction, actor_key, session_key, source)
+     VALUES (?, ?, ?, ?, ?)`,
+    [packId, normalizedInteraction, sanitizeKey(actorKey), sanitizeKey(sessionKey), sanitizeKey(source, 32)],
+    connection,
+  );
+  return true;
+}
+
+export async function listStickerPackInteractionStatsByPackIds(packIds, { horizonHours = 24, baselineDays = 7 } = {}, connection = null) {
+  const ids = Array.from(new Set((Array.isArray(packIds) ? packIds : []).filter(Boolean)));
+  if (!ids.length) return new Map();
+
+  const safeHorizonHours = clamp(horizonHours, 24, 1, 240);
+  const safeBaselineDays = clamp(baselineDays, 7, 2, 60);
+  const placeholders = ids.map(() => '?').join(', ');
+
+  const rows = await executeQuery(
+    `SELECT
+       pack_id,
+       SUM(CASE WHEN interaction = 'open' AND created_at >= (UTC_TIMESTAMP() - INTERVAL ${safeHorizonHours} HOUR) THEN 1 ELSE 0 END) AS open_horizon,
+       SUM(CASE WHEN interaction = 'open' AND created_at >= (UTC_TIMESTAMP() - INTERVAL ${safeBaselineDays} DAY) THEN 1 ELSE 0 END) AS open_baseline,
+       SUM(CASE WHEN interaction = 'like' AND created_at >= (UTC_TIMESTAMP() - INTERVAL ${safeHorizonHours} HOUR) THEN 1 ELSE 0 END) AS like_horizon,
+       SUM(CASE WHEN interaction = 'like' AND created_at >= (UTC_TIMESTAMP() - INTERVAL ${safeBaselineDays} DAY) THEN 1 ELSE 0 END) AS like_baseline,
+       SUM(CASE WHEN interaction = 'dislike' AND created_at >= (UTC_TIMESTAMP() - INTERVAL ${safeHorizonHours} HOUR) THEN 1 ELSE 0 END) AS dislike_horizon,
+       SUM(CASE WHEN interaction = 'dislike' AND created_at >= (UTC_TIMESTAMP() - INTERVAL ${safeBaselineDays} DAY) THEN 1 ELSE 0 END) AS dislike_baseline
+     FROM ${TABLES.STICKER_PACK_INTERACTION_EVENT}
+     WHERE pack_id IN (${placeholders})
+     GROUP BY pack_id`,
+    ids,
+    connection,
+  );
+
+  const byPackId = new Map();
+  for (const row of rows) {
+    byPackId.set(row.pack_id, {
+      pack_id: row.pack_id,
+      open_horizon: Number(row.open_horizon || 0),
+      open_baseline: Number(row.open_baseline || 0),
+      like_horizon: Number(row.like_horizon || 0),
+      like_baseline: Number(row.like_baseline || 0),
+      dislike_horizon: Number(row.dislike_horizon || 0),
+      dislike_baseline: Number(row.dislike_baseline || 0),
+    });
+  }
+  return byPackId;
+}
+
+export async function listViewerRecentPackIds(viewerKey, { days = 30, limit = 120 } = {}, connection = null) {
+  const normalizedViewer = sanitizeKey(viewerKey);
+  if (!normalizedViewer) return [];
+
+  const safeDays = clamp(days, 30, 1, 180);
+  const safeLimit = clamp(limit, 120, 5, 500);
+  const rows = await executeQuery(
+    `SELECT pack_id, COUNT(*) AS interactions, MAX(created_at) AS last_interaction_at
+     FROM ${TABLES.STICKER_PACK_INTERACTION_EVENT}
+     WHERE actor_key = ?
+       AND created_at >= (UTC_TIMESTAMP() - INTERVAL ${safeDays} DAY)
+     GROUP BY pack_id
+     ORDER BY interactions DESC, last_interaction_at DESC
+     LIMIT ${safeLimit}`,
+    [normalizedViewer],
+    connection,
+  );
+
+  return rows.map((row) => ({
+    pack_id: row.pack_id,
+    interactions: Number(row.interactions || 0),
+    last_interaction_at: row.last_interaction_at || null,
+  }));
+}