@omnizap-system/omnizap 2.5.12

package/app/modules/stickerPackModule/stickerPackRepository.js

@@ -0,0 +1,450 @@
+import { executeQuery, TABLES } from '../../../database/index.js';
+import { STICKER_DOMAIN_EVENTS } from './domainEvents.js';
+import { publishStickerDomainEvent } from './stickerDomainEventBus.js';
+
+const CATALOG_COMPLETE_PACK_TARGET = Math.max(1, Number(process.env.STICKER_PACK_MAX_ITEMS) || 30);
+
+/**
+ * Normaliza linha da tabela de packs para formato usado no domínio.
+ *
+ * @param {Record<string, unknown>|null|undefined} row Linha retornada da query.
+ * @returns {object|null} Pack normalizado.
+ */
+const normalizeStickerPackRow = (row) => {
+  if (!row) return null;
+
+  return {
+    id: row.id,
+    owner_jid: row.owner_jid,
+    name: row.name,
+    publisher: row.publisher,
+    description: row.description,
+    pack_key: row.pack_key,
+    cover_sticker_id: row.cover_sticker_id,
+    visibility: row.visibility,
+    status: row.status || 'published',
+    pack_status: row.pack_status || 'ready',
+    pack_theme_key: row.pack_theme_key || null,
+    pack_volume: row.pack_volume !== null && row.pack_volume !== undefined ? Number(row.pack_volume) : null,
+    is_auto_pack: row.is_auto_pack === 1 || row.is_auto_pack === true,
+    last_rebalanced_at: row.last_rebalanced_at || null,
+    version: Number(row.version || 1),
+    created_at: row.created_at,
+    updated_at: row.updated_at,
+    deleted_at: row.deleted_at,
+    sticker_count: row.sticker_count !== null && row.sticker_count !== undefined ? Number(row.sticker_count) : undefined,
+  };
+};
+
+/**
+ * Busca pack por ID.
+ *
+ * @param {string} packId ID interno do pack.
+ * @param {{ includeDeleted?: boolean, connection?: import('mysql2/promise').PoolConnection|null }} [options]
+ * @returns {Promise<object|null>} Pack encontrado.
+ */
+export async function findStickerPackById(packId, { includeDeleted = false, connection = null } = {}) {
+  const rows = await executeQuery(
+    `SELECT p.*,
+      (SELECT COUNT(*) FROM ${TABLES.STICKER_PACK_ITEM} i WHERE i.pack_id = p.id) AS sticker_count
+     FROM ${TABLES.STICKER_PACK} p
+     WHERE p.id = ? ${includeDeleted ? '' : 'AND p.deleted_at IS NULL'}
+     LIMIT 1`,
+    [packId],
+    connection,
+  );
+
+  return normalizeStickerPackRow(rows?.[0] || null);
+}
+
+/**
+ * Busca pack por chave pública (pack_key).
+ *
+ * @param {string} packKey Chave pública do pack.
+ * @param {{ includeDeleted?: boolean, connection?: import('mysql2/promise').PoolConnection|null }} [options]
+ * @returns {Promise<object|null>} Pack encontrado.
+ */
+export async function findStickerPackByPackKey(packKey, { includeDeleted = false, connection = null } = {}) {
+  const rows = await executeQuery(
+    `SELECT p.*,
+      (SELECT COUNT(*) FROM ${TABLES.STICKER_PACK_ITEM} i WHERE i.pack_id = p.id) AS sticker_count
+     FROM ${TABLES.STICKER_PACK} p
+     WHERE p.pack_key = ? ${includeDeleted ? '' : 'AND p.deleted_at IS NULL'}
+     LIMIT 1`,
+    [packKey],
+    connection,
+  );
+
+  return normalizeStickerPackRow(rows?.[0] || null);
+}
+
+/**
+ * Busca pack do dono por ID, pack_key ou nome.
+ *
+ * @param {string} ownerJid JID do dono.
+ * @param {string} identifier ID, chave ou nome do pack.
+ * @param {{ includeDeleted?: boolean, connection?: import('mysql2/promise').PoolConnection|null }} [options]
+ * @returns {Promise<object|null>} Pack encontrado.
+ */
+export async function findStickerPackByOwnerAndIdentifier(ownerJid, identifier, { includeDeleted = false, connection = null } = {}) {
+  if (!identifier) return null;
+
+  const idOrPack = await executeQuery(
+    `SELECT p.*,
+      (SELECT COUNT(*) FROM ${TABLES.STICKER_PACK_ITEM} i WHERE i.pack_id = p.id) AS sticker_count
+     FROM ${TABLES.STICKER_PACK} p
+     WHERE p.owner_jid = ?
+       ${includeDeleted ? '' : 'AND p.deleted_at IS NULL'}
+       AND (p.id = ? OR p.pack_key = ?)
+     ORDER BY p.updated_at DESC
+     LIMIT 1`,
+    [ownerJid, identifier, identifier],
+    connection,
+  );
+
+  if (idOrPack?.[0]) {
+    return normalizeStickerPackRow(idOrPack[0]);
+  }
+
+  const byName = await executeQuery(
+    `SELECT p.*,
+      (SELECT COUNT(*) FROM ${TABLES.STICKER_PACK_ITEM} i WHERE i.pack_id = p.id) AS sticker_count
+     FROM ${TABLES.STICKER_PACK} p
+     WHERE p.owner_jid = ?
+       ${includeDeleted ? '' : 'AND p.deleted_at IS NULL'}
+       AND LOWER(p.name) = LOWER(?)
+     ORDER BY p.updated_at DESC
+     LIMIT 1`,
+    [ownerJid, identifier],
+    connection,
+  );
+
+  return normalizeStickerPackRow(byName?.[0] || null);
+}
+
+/**
+ * Lista packs de um usuário com paginação simples.
+ *
+ * @param {string} ownerJid JID do dono.
+ * @param {{ includeDeleted?: boolean, limit?: number, offset?: number, connection?: import('mysql2/promise').PoolConnection|null }} [options]
+ * @returns {Promise<object[]>} Lista de packs.
+ */
+export async function listStickerPacksByOwner(ownerJid, { includeDeleted = false, limit = 50, offset = 0, connection = null } = {}) {
+  const safeLimit = Math.max(1, Number(limit) || 50);
+  const safeOffset = Math.max(0, Number(offset) || 0);
+
+  const rows = await executeQuery(
+    `SELECT p.*,
+      (SELECT COUNT(*) FROM ${TABLES.STICKER_PACK_ITEM} i WHERE i.pack_id = p.id) AS sticker_count
+     FROM ${TABLES.STICKER_PACK} p
+     WHERE p.owner_jid = ? ${includeDeleted ? '' : 'AND p.deleted_at IS NULL'}
+     ORDER BY p.updated_at DESC
+     LIMIT ${safeLimit} OFFSET ${safeOffset}`,
+    [ownerJid],
+    connection,
+  );
+
+  return rows.map((row) => normalizeStickerPackRow(row));
+}
+
+/**
+ * Lista packs automáticos de curadoria para um conjunto de owners.
+ *
+ * @param {{
+ *   ownerJids?: string[],
+ *   includeArchived?: boolean,
+ *   themeKey?: string,
+ *   limit?: number,
+ *   offset?: number,
+ *   connection?: import('mysql2/promise').PoolConnection|null,
+ * }} [options]
+ * @returns {Promise<object[]>}
+ */
+export async function listStickerAutoPacksForCuration({ ownerJids = [], includeArchived = true, themeKey = '', includeLegacyMarkers = true, limit = 2000, offset = 0, connection = null } = {}) {
+  const owners = Array.from(new Set((Array.isArray(ownerJids) ? ownerJids : []).filter(Boolean)));
+  if (!owners.length) return [];
+
+  const safeLimit = Math.max(1, Math.min(5000, Number(limit) || 2000));
+  const safeOffset = Math.max(0, Number(offset) || 0);
+  const ownerPlaceholders = owners.map(() => '?').join(', ');
+
+  const whereClauses = ['p.deleted_at IS NULL', `p.owner_jid IN (${ownerPlaceholders})`];
+  const params = [...owners];
+
+  if (includeLegacyMarkers) {
+    whereClauses.push("(p.is_auto_pack = 1 OR p.description LIKE '%[auto-theme:%' OR p.description LIKE '%[auto-tag:%')");
+  } else {
+    whereClauses.push('p.is_auto_pack = 1');
+  }
+
+  const normalizedThemeKey = String(themeKey || '')
+    .trim()
+    .toLowerCase();
+  if (normalizedThemeKey) {
+    whereClauses.push("LOWER(COALESCE(p.pack_theme_key, '')) = ?");
+    params.push(normalizedThemeKey);
+  }
+
+  if (!includeArchived) {
+    whereClauses.push("COALESCE(p.pack_status, 'ready') <> 'archived'");
+  }
+
+  const rows = await executeQuery(
+    `SELECT p.*,
+      (SELECT COUNT(*) FROM ${TABLES.STICKER_PACK_ITEM} i WHERE i.pack_id = p.id) AS sticker_count
+     FROM ${TABLES.STICKER_PACK} p
+     WHERE ${whereClauses.join(' AND ')}
+     ORDER BY
+       COALESCE(p.pack_theme_key, '') ASC,
+       COALESCE(p.pack_volume, 0) ASC,
+       p.updated_at DESC
+     LIMIT ${safeLimit} OFFSET ${safeOffset}`,
+    params,
+    connection,
+  );
+
+  return rows.map((row) => normalizeStickerPackRow(row));
+}
+
+/**
+ * Lista packs públicos para catálogo web com busca e paginação.
+ *
+ * @param {{
+ *   visibility?: 'public'|'unlisted'|'all',
+ *   search?: string,
+ *   limit?: number,
+ *   offset?: number,
+ *   connection?: import('mysql2/promise').PoolConnection|null,
+ * }} [options] Filtros de listagem.
+ * @returns {Promise<{ packs: object[], hasMore: boolean }>} Resultado paginado.
+ */
+export async function listStickerPacksForCatalog({ visibility = 'public', search = '', limit = 24, offset = 0, connection = null } = {}) {
+  const safeLimit = Math.max(1, Math.min(60, Number(limit) || 24));
+  const safeOffset = Math.max(0, Number(offset) || 0);
+  const safeLimitWithSentinel = safeLimit + 1;
+
+  const normalizedVisibility = String(visibility || 'public')
+    .trim()
+    .toLowerCase();
+  const visibilityValues = normalizedVisibility === 'all' ? ['public', 'unlisted'] : normalizedVisibility === 'unlisted' ? ['unlisted'] : ['public'];
+
+  const normalizedSearch = String(search || '')
+    .trim()
+    .toLowerCase()
+    .slice(0, 120);
+  const params = [...visibilityValues];
+  const whereClauses = ['p.deleted_at IS NULL', "p.status = 'published'", "COALESCE(p.pack_status, 'ready') = 'ready'", `p.visibility IN (${visibilityValues.map(() => '?').join(', ')})`];
+
+  if (normalizedSearch) {
+    const like = `%${normalizedSearch}%`;
+    whereClauses.push("(LOWER(p.name) LIKE ? OR LOWER(p.publisher) LIKE ? OR LOWER(COALESCE(p.description, '')) LIKE ? OR LOWER(p.pack_key) LIKE ?)");
+    params.push(like, like, like, like);
+  }
+
+  const rows = await executeQuery(
+    `SELECT p.*,
+      (SELECT COUNT(*) FROM ${TABLES.STICKER_PACK_ITEM} i WHERE i.pack_id = p.id) AS sticker_count
+     FROM ${TABLES.STICKER_PACK} p
+     WHERE ${whereClauses.join(' AND ')}
+     ORDER BY
+       (sticker_count >= ${CATALOG_COMPLETE_PACK_TARGET}) DESC,
+       sticker_count DESC,
+       p.updated_at DESC
+     LIMIT ${safeLimitWithSentinel} OFFSET ${safeOffset}`,
+    params,
+    connection,
+  );
+
+  const hasMore = rows.length > safeLimit;
+  return {
+    packs: rows.slice(0, safeLimit).map((row) => normalizeStickerPackRow(row)),
+    hasMore,
+  };
+}
+
+/**
+ * Cria um registro de pack.
+ *
+ * @param {object} pack Dados do pack.
+ * @param {import('mysql2/promise').PoolConnection|null} [connection=null] Conexão transacional opcional.
+ * @returns {Promise<object|null>} Pack criado.
+ */
+export async function createStickerPack(pack, connection = null) {
+  await executeQuery(
+    `INSERT INTO ${TABLES.STICKER_PACK}
+      (
+        id,
+        owner_jid,
+        name,
+        publisher,
+        description,
+        pack_key,
+        cover_sticker_id,
+        visibility,
+        status,
+        pack_status,
+        pack_theme_key,
+        pack_volume,
+        is_auto_pack,
+        last_rebalanced_at,
+        version
+      )
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    [pack.id, pack.owner_jid, pack.name, pack.publisher, pack.description ?? null, pack.pack_key, pack.cover_sticker_id ?? null, pack.visibility, pack.status ?? 'published', pack.pack_status ?? 'ready', pack.pack_theme_key ?? null, pack.pack_volume ?? null, pack.is_auto_pack ? 1 : 0, pack.last_rebalanced_at ?? null, pack.version ?? 1],
+    connection,
+  );
+
+  await publishStickerDomainEvent(
+    {
+      eventType: STICKER_DOMAIN_EVENTS.PACK_UPDATED,
+      aggregateType: 'sticker_pack',
+      aggregateId: pack.id,
+      payload: {
+        action: 'created',
+        pack_id: pack.id,
+        pack_key: pack.pack_key,
+        owner_jid: pack.owner_jid,
+        visibility: pack.visibility,
+      },
+      priority: 75,
+      idempotencyKey: `pack_created:${pack.id}`,
+    },
+    { connection },
+  );
+
+  return findStickerPackById(pack.id, { includeDeleted: true, connection });
+}
+
+const UPDATE_FIELD_MAP = {
+  name: 'name',
+  publisher: 'publisher',
+  description: 'description',
+  pack_key: 'pack_key',
+  cover_sticker_id: 'cover_sticker_id',
+  visibility: 'visibility',
+  status: 'status',
+  pack_status: 'pack_status',
+  pack_theme_key: 'pack_theme_key',
+  pack_volume: 'pack_volume',
+  is_auto_pack: 'is_auto_pack',
+  last_rebalanced_at: 'last_rebalanced_at',
+  deleted_at: 'deleted_at',
+};
+
+/**
+ * Atualiza campos permitidos de um pack.
+ *
+ * @param {string} packId ID do pack.
+ * @param {Record<string, unknown>} fields Campos para atualização.
+ * @param {import('mysql2/promise').PoolConnection|null} [connection=null] Conexão transacional opcional.
+ * @returns {Promise<object|null>} Pack atualizado.
+ */
+export async function updateStickerPackFields(packId, fields, connection = null) {
+  const setClauses = [];
+  const params = [];
+
+  for (const [field, column] of Object.entries(UPDATE_FIELD_MAP)) {
+    if (!(field in fields)) continue;
+    setClauses.push(`${column} = ?`);
+    params.push(fields[field]);
+  }
+
+  if (!setClauses.length) {
+    return findStickerPackById(packId, { includeDeleted: true, connection });
+  }
+
+  setClauses.push('version = version + 1');
+  setClauses.push('updated_at = CURRENT_TIMESTAMP');
+
+  await executeQuery(
+    `UPDATE ${TABLES.STICKER_PACK}
+     SET ${setClauses.join(', ')}
+     WHERE id = ?`,
+    [...params, packId],
+    connection,
+  );
+
+  await publishStickerDomainEvent(
+    {
+      eventType: STICKER_DOMAIN_EVENTS.PACK_UPDATED,
+      aggregateType: 'sticker_pack',
+      aggregateId: packId,
+      payload: {
+        action: 'updated',
+        pack_id: packId,
+        fields: Object.keys(fields || {}).slice(0, 30),
+      },
+      priority: 70,
+      idempotencyKey: `pack_updated:${packId}:${Object.keys(fields || {})
+        .sort()
+        .join(',')}`,
+    },
+    { connection },
+  );
+
+  return findStickerPackById(packId, { includeDeleted: true, connection });
+}
+
+/**
+ * Marca um pack como deletado sem remover dados físicos.
+ *
+ * @param {string} packId ID do pack.
+ * @param {import('mysql2/promise').PoolConnection|null} [connection=null] Conexão transacional opcional.
+ * @returns {Promise<object|null>} Pack atualizado.
+ */
+export async function softDeleteStickerPack(packId, connection = null) {
+  return updateStickerPackFields(
+    packId,
+    {
+      deleted_at: new Date(),
+    },
+    connection,
+  );
+}
+
+/**
+ * Verifica se a chave pública (pack_key) está disponível.
+ *
+ * @param {string} packKey Chave candidata.
+ * @param {import('mysql2/promise').PoolConnection|null} [connection=null] Conexão transacional opcional.
+ * @returns {Promise<boolean>} `true` quando não existe pack com essa chave.
+ */
+export async function ensureUniquePackKey(packKey, connection = null) {
+  const existing = await findStickerPackByPackKey(packKey, { includeDeleted: true, connection });
+  return !existing;
+}
+
+/**
+ * Incrementa versão e timestamp de atualização do pack.
+ *
+ * @param {string} packId ID do pack.
+ * @param {import('mysql2/promise').PoolConnection|null} [connection=null] Conexão transacional opcional.
+ * @returns {Promise<object|null>} Pack atualizado.
+ */
+export async function bumpStickerPackVersion(packId, connection = null) {
+  await executeQuery(
+    `UPDATE ${TABLES.STICKER_PACK}
+     SET version = version + 1,
+         updated_at = CURRENT_TIMESTAMP
+     WHERE id = ?`,
+    [packId],
+    connection,
+  );
+
+  await publishStickerDomainEvent(
+    {
+      eventType: STICKER_DOMAIN_EVENTS.PACK_UPDATED,
+      aggregateType: 'sticker_pack',
+      aggregateId: packId,
+      payload: {
+        action: 'version_bumped',
+        pack_id: packId,
+      },
+      priority: 65,
+      idempotencyKey: `pack_version_bumped:${packId}`,
+    },
+    { connection },
+  );
+
+  return findStickerPackById(packId, { includeDeleted: true, connection });
+}

package/app/modules/stickerPackModule/stickerPackScoreSnapshotRepository.js

@@ -0,0 +1,179 @@
+import { executeQuery, TABLES } from '../../../database/index.js';
+
+const parseJson = (value, fallback = null) => {
+  if (value === null || value === undefined) return fallback;
+  if (typeof value === 'object') return value;
+  if (Buffer.isBuffer(value)) {
+    try {
+      return JSON.parse(value.toString('utf8'));
+    } catch {
+      return fallback;
+    }
+  }
+  if (typeof value === 'string') {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return fallback;
+    }
+  }
+  return fallback;
+};
+
+const clampScore = (value) => {
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric)) return 0;
+  return Number(numeric.toFixed(6));
+};
+
+const normalizeNsfwLevel = (value) => {
+  const normalized = String(value || '')
+    .trim()
+    .toLowerCase();
+  if (['safe', 'suggestive', 'explicit'].includes(normalized)) return normalized;
+  return 'safe';
+};
+
+const normalizeRow = (row) => {
+  if (!row) return null;
+  const scoresFromJson = parseJson(row.scores_json, {}) || {};
+  return {
+    pack_id: row.pack_id,
+    ranking_score: clampScore(row.ranking_score),
+    pack_score: clampScore(row.pack_score),
+    trend_score: clampScore(row.trend_score),
+    quality_score: clampScore(row.quality_score),
+    engagement_score: clampScore(row.engagement_score),
+    diversity_score: clampScore(row.diversity_score),
+    cohesion_score: clampScore(row.cohesion_score),
+    sensitive_content: row.sensitive_content === 1 || row.sensitive_content === true,
+    nsfw_level: normalizeNsfwLevel(row.nsfw_level),
+    sticker_count: Number(row.sticker_count || 0),
+    tags: Array.isArray(parseJson(row.tags, [])) ? parseJson(row.tags, []) : [],
+    source_version: row.source_version || 'v1',
+    refreshed_at: row.refreshed_at || null,
+    updated_at: row.updated_at || null,
+    signals: {
+      ...scoresFromJson,
+      quality_score: clampScore(row.quality_score),
+      engagement_score: clampScore(row.engagement_score),
+      diversity_score: clampScore(row.diversity_score),
+      cohesion_score: clampScore(row.cohesion_score),
+      trend_score: clampScore(row.trend_score),
+      pack_score: clampScore(row.pack_score),
+      ranking_score: clampScore(row.ranking_score),
+      nsfw_level: normalizeNsfwLevel(row.nsfw_level),
+      sensitive_content: row.sensitive_content === 1 || row.sensitive_content === true,
+    },
+  };
+};
+
+const normalizeSnapshotInput = (entry) => {
+  if (!entry?.pack_id) return null;
+  const signals = entry?.signals && typeof entry.signals === 'object' ? entry.signals : {};
+  return {
+    pack_id: String(entry.pack_id),
+    ranking_score: clampScore(signals.ranking_score),
+    pack_score: clampScore(signals.pack_score),
+    trend_score: clampScore(signals.trend_score),
+    quality_score: clampScore(signals.quality_score),
+    engagement_score: clampScore(signals.engagement_score),
+    diversity_score: clampScore(signals.diversity_score),
+    cohesion_score: clampScore(signals.cohesion_score),
+    sensitive_content: signals.sensitive_content === true || signals.sensitive_content === 1 ? 1 : 0,
+    nsfw_level: normalizeNsfwLevel(signals.nsfw_level),
+    sticker_count: Math.max(0, Number(entry.sticker_count || 0)),
+    tags: Array.isArray(entry.tags) ? entry.tags.slice(0, 30) : [],
+    source_version:
+      String(entry.source_version || 'v1')
+        .trim()
+        .slice(0, 32) || 'v1',
+    scores_json: signals,
+  };
+};
+
+export async function upsertStickerPackScoreSnapshots(entries = [], connection = null) {
+  const normalized = (Array.isArray(entries) ? entries : []).map((entry) => normalizeSnapshotInput(entry)).filter(Boolean);
+  if (!normalized.length) return 0;
+
+  let written = 0;
+  for (let offset = 0; offset < normalized.length; offset += 100) {
+    const chunk = normalized.slice(offset, offset + 100);
+    const placeholders = chunk.map(() => '(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, UTC_TIMESTAMP())').join(', ');
+    const params = chunk.flatMap((entry) => [entry.pack_id, entry.ranking_score, entry.pack_score, entry.trend_score, entry.quality_score, entry.engagement_score, entry.diversity_score, entry.cohesion_score, entry.sensitive_content, entry.nsfw_level, entry.sticker_count, JSON.stringify(entry.tags || []), JSON.stringify(entry.scores_json || {}), entry.source_version]);
+    const result = await executeQuery(
+      `INSERT INTO ${TABLES.STICKER_PACK_SCORE_SNAPSHOT}
+        (
+          pack_id,
+          ranking_score,
+          pack_score,
+          trend_score,
+          quality_score,
+          engagement_score,
+          diversity_score,
+          cohesion_score,
+          sensitive_content,
+          nsfw_level,
+          sticker_count,
+          tags,
+          scores_json,
+          source_version,
+          refreshed_at
+        )
+       VALUES ${placeholders}
+       ON DUPLICATE KEY UPDATE
+        ranking_score = VALUES(ranking_score),
+        pack_score = VALUES(pack_score),
+        trend_score = VALUES(trend_score),
+        quality_score = VALUES(quality_score),
+        engagement_score = VALUES(engagement_score),
+        diversity_score = VALUES(diversity_score),
+        cohesion_score = VALUES(cohesion_score),
+        sensitive_content = VALUES(sensitive_content),
+        nsfw_level = VALUES(nsfw_level),
+        sticker_count = VALUES(sticker_count),
+        tags = VALUES(tags),
+        scores_json = VALUES(scores_json),
+        source_version = VALUES(source_version),
+        refreshed_at = UTC_TIMESTAMP(),
+        updated_at = CURRENT_TIMESTAMP`,
+      params,
+      connection,
+    );
+    written += Number(result?.affectedRows || 0);
+  }
+
+  return written;
+}
+
+export async function listStickerPackScoreSnapshotsByPackIds(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 *
+     FROM ${TABLES.STICKER_PACK_SCORE_SNAPSHOT}
+     WHERE pack_id IN (${placeholders})`,
+    ids,
+    connection,
+  );
+  const byPackId = new Map();
+  (Array.isArray(rows) ? rows : []).forEach((row) => {
+    const normalized = normalizeRow(row);
+    if (!normalized?.pack_id) return;
+    byPackId.set(normalized.pack_id, normalized);
+  });
+  return byPackId;
+}
+
+export async function removeSnapshotsForDeletedPacks(connection = null) {
+  const result = await executeQuery(
+    `DELETE s
+       FROM ${TABLES.STICKER_PACK_SCORE_SNAPSHOT} s
+       LEFT JOIN ${TABLES.STICKER_PACK} p ON p.id = s.pack_id
+      WHERE p.id IS NULL OR p.deleted_at IS NOT NULL`,
+    [],
+    connection,
+  );
+  return Number(result?.affectedRows || 0);
+}